Mercurial > projects > ldc
annotate dmd/expression.c @ 1138:4c8bb03e4fbc
Update DtoConstFP() to be correct after LLVM r67562, which changed the way the
APFloat constructor expects its i80 APInts to be formatted. (They're now
actually consistent with the x87 format)
| author | Frits van Bommel <fvbommel wxs.nl> |
|---|---|
| date | Tue, 24 Mar 2009 15:24:59 +0100 |
| parents | eeb8b95ea92e |
| children | 1860414bf3b7 |
| 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 |
| 159 | 37 #if IN_GCC |
| 38 // Issues with using -include total.h (defines integer_t) and then complex.h fails... | |
| 39 #undef integer_t | |
| 40 #endif | |
| 41 | |
| 42 #ifdef __APPLE__ | |
| 43 #define integer_t dmd_integer_t | |
| 44 #endif | |
| 45 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
46 #include "rmem.h" |
| 159 | 47 |
| 48 //#include "port.h" | |
| 49 #include "mtype.h" | |
| 50 #include "init.h" | |
| 51 #include "expression.h" | |
| 52 #include "template.h" | |
| 53 #include "utf.h" | |
| 54 #include "enum.h" | |
| 55 #include "scope.h" | |
| 56 #include "statement.h" | |
| 57 #include "declaration.h" | |
| 58 #include "aggregate.h" | |
| 59 #include "import.h" | |
| 60 #include "id.h" | |
| 61 #include "dsymbol.h" | |
| 62 #include "module.h" | |
| 63 #include "attrib.h" | |
| 64 #include "hdrgen.h" | |
| 65 #include "parse.h" | |
| 66 | |
| 67 Expression *createTypeInfoArray(Scope *sc, Expression *args[], int dim); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
68 Expression *expandVar(int result, VarDeclaration *v); |
| 159 | 69 |
| 70 #define LOGSEMANTIC 0 | |
| 71 | |
| 72 /********************************** | |
| 73 * Set operator precedence for each operator. | |
| 74 */ | |
| 75 | |
| 76 // Operator precedence - greater values are higher precedence | |
| 77 | |
| 78 enum PREC | |
| 79 { | |
| 80 PREC_zero, | |
| 81 PREC_expr, | |
| 82 PREC_assign, | |
| 83 PREC_cond, | |
| 84 PREC_oror, | |
| 85 PREC_andand, | |
| 86 PREC_or, | |
| 87 PREC_xor, | |
| 88 PREC_and, | |
| 89 PREC_equal, | |
| 90 PREC_rel, | |
| 91 PREC_shift, | |
| 92 PREC_add, | |
| 93 PREC_mul, | |
| 94 PREC_unary, | |
| 95 PREC_primary, | |
| 96 }; | |
| 97 | |
| 98 enum PREC precedence[TOKMAX]; | |
| 99 | |
| 100 void initPrecedence() | |
| 101 { | |
| 102 precedence[TOKdotvar] = PREC_primary; | |
| 103 precedence[TOKimport] = PREC_primary; | |
| 104 precedence[TOKidentifier] = PREC_primary; | |
| 105 precedence[TOKthis] = PREC_primary; | |
| 106 precedence[TOKsuper] = PREC_primary; | |
| 107 precedence[TOKint64] = PREC_primary; | |
| 108 precedence[TOKfloat64] = PREC_primary; | |
| 109 precedence[TOKnull] = PREC_primary; | |
| 110 precedence[TOKstring] = PREC_primary; | |
| 111 precedence[TOKarrayliteral] = PREC_primary; | |
| 112 precedence[TOKtypedot] = PREC_primary; | |
| 113 precedence[TOKtypeid] = PREC_primary; | |
| 114 precedence[TOKis] = PREC_primary; | |
| 115 precedence[TOKassert] = PREC_primary; | |
| 116 precedence[TOKfunction] = PREC_primary; | |
| 117 precedence[TOKvar] = PREC_primary; | |
| 336 | 118 #if DMDV2 |
| 119 precedence[TOKdefault] = PREC_primary; | |
| 120 #endif | |
| 159 | 121 |
| 122 // post | |
| 123 precedence[TOKdotti] = PREC_primary; | |
| 124 precedence[TOKdot] = PREC_primary; | |
| 125 // precedence[TOKarrow] = PREC_primary; | |
| 126 precedence[TOKplusplus] = PREC_primary; | |
| 127 precedence[TOKminusminus] = PREC_primary; | |
| 128 precedence[TOKcall] = PREC_primary; | |
| 129 precedence[TOKslice] = PREC_primary; | |
| 130 precedence[TOKarray] = PREC_primary; | |
| 131 | |
| 132 precedence[TOKaddress] = PREC_unary; | |
| 133 precedence[TOKstar] = PREC_unary; | |
| 134 precedence[TOKneg] = PREC_unary; | |
| 135 precedence[TOKuadd] = PREC_unary; | |
| 136 precedence[TOKnot] = PREC_unary; | |
| 137 precedence[TOKtobool] = PREC_add; | |
| 138 precedence[TOKtilde] = PREC_unary; | |
| 139 precedence[TOKdelete] = PREC_unary; | |
| 140 precedence[TOKnew] = PREC_unary; | |
| 141 precedence[TOKcast] = PREC_unary; | |
| 142 | |
| 143 precedence[TOKmul] = PREC_mul; | |
| 144 precedence[TOKdiv] = PREC_mul; | |
| 145 precedence[TOKmod] = PREC_mul; | |
| 146 | |
| 147 precedence[TOKadd] = PREC_add; | |
| 148 precedence[TOKmin] = PREC_add; | |
| 149 precedence[TOKcat] = PREC_add; | |
| 150 | |
| 151 precedence[TOKshl] = PREC_shift; | |
| 152 precedence[TOKshr] = PREC_shift; | |
| 153 precedence[TOKushr] = PREC_shift; | |
| 154 | |
| 155 precedence[TOKlt] = PREC_rel; | |
| 156 precedence[TOKle] = PREC_rel; | |
| 157 precedence[TOKgt] = PREC_rel; | |
| 158 precedence[TOKge] = PREC_rel; | |
| 159 precedence[TOKunord] = PREC_rel; | |
| 160 precedence[TOKlg] = PREC_rel; | |
| 161 precedence[TOKleg] = PREC_rel; | |
| 162 precedence[TOKule] = PREC_rel; | |
| 163 precedence[TOKul] = PREC_rel; | |
| 164 precedence[TOKuge] = PREC_rel; | |
| 165 precedence[TOKug] = PREC_rel; | |
| 166 precedence[TOKue] = PREC_rel; | |
| 167 precedence[TOKin] = PREC_rel; | |
| 168 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
169 #if 0 |
| 159 | 170 precedence[TOKequal] = PREC_equal; |
| 171 precedence[TOKnotequal] = PREC_equal; | |
| 172 precedence[TOKidentity] = PREC_equal; | |
| 173 precedence[TOKnotidentity] = PREC_equal; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
174 #else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
175 /* 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
|
176 * 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
|
177 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
178 precedence[TOKequal] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
179 precedence[TOKnotequal] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
180 precedence[TOKidentity] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
181 precedence[TOKnotidentity] = PREC_rel; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
182 #endif |
| 159 | 183 |
| 184 precedence[TOKand] = PREC_and; | |
| 185 | |
| 186 precedence[TOKxor] = PREC_xor; | |
| 187 | |
| 188 precedence[TOKor] = PREC_or; | |
| 189 | |
| 190 precedence[TOKandand] = PREC_andand; | |
| 191 | |
| 192 precedence[TOKoror] = PREC_oror; | |
| 193 | |
| 194 precedence[TOKquestion] = PREC_cond; | |
| 195 | |
| 196 precedence[TOKassign] = PREC_assign; | |
| 197 precedence[TOKconstruct] = PREC_assign; | |
| 198 precedence[TOKblit] = PREC_assign; | |
| 199 precedence[TOKaddass] = PREC_assign; | |
| 200 precedence[TOKminass] = PREC_assign; | |
| 201 precedence[TOKcatass] = PREC_assign; | |
| 202 precedence[TOKmulass] = PREC_assign; | |
| 203 precedence[TOKdivass] = PREC_assign; | |
| 204 precedence[TOKmodass] = PREC_assign; | |
| 205 precedence[TOKshlass] = PREC_assign; | |
| 206 precedence[TOKshrass] = PREC_assign; | |
| 207 precedence[TOKushrass] = PREC_assign; | |
| 208 precedence[TOKandass] = PREC_assign; | |
| 209 precedence[TOKorass] = PREC_assign; | |
| 210 precedence[TOKxorass] = PREC_assign; | |
| 211 | |
| 212 precedence[TOKcomma] = PREC_expr; | |
| 213 } | |
| 214 | |
| 336 | 215 /************************************************************* |
| 216 * Given var, we need to get the | |
| 217 * right 'this' pointer if var is in an outer class, but our | |
| 218 * existing 'this' pointer is in an inner class. | |
| 219 * Input: | |
| 220 * e1 existing 'this' | |
| 221 * ad struct or class we need the correct 'this' for | |
| 222 * var the specific member of ad we're accessing | |
| 223 */ | |
| 224 | |
| 225 Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, | |
| 226 Expression *e1, Declaration *var) | |
| 227 { | |
| 228 //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars()); | |
| 229 L1: | |
| 230 Type *t = e1->type->toBasetype(); | |
| 231 //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars()); | |
| 232 | |
| 233 /* If e1 is not the 'this' pointer for ad | |
| 234 */ | |
| 235 if (ad && | |
| 236 !(t->ty == Tpointer && t->nextOf()->ty == Tstruct && | |
| 237 ((TypeStruct *)t->nextOf())->sym == ad) | |
| 238 && | |
| 239 !(t->ty == Tstruct && | |
| 240 ((TypeStruct *)t)->sym == ad) | |
| 241 ) | |
| 242 { | |
| 243 ClassDeclaration *cd = ad->isClassDeclaration(); | |
| 244 ClassDeclaration *tcd = t->isClassHandle(); | |
| 245 | |
| 246 /* e1 is the right this if ad is a base class of e1 | |
| 247 */ | |
| 248 if (!cd || !tcd || | |
| 249 !(tcd == cd || cd->isBaseOf(tcd, NULL)) | |
| 250 ) | |
| 251 { | |
| 252 /* Only classes can be inner classes with an 'outer' | |
| 253 * member pointing to the enclosing class instance | |
| 254 */ | |
| 255 if (tcd && tcd->isNested()) | |
| 256 { /* e1 is the 'this' pointer for an inner class: tcd. | |
| 257 * Rewrite it as the 'this' pointer for the outer class. | |
| 258 */ | |
| 259 | |
| 260 e1 = new DotVarExp(loc, e1, tcd->vthis); | |
| 261 e1->type = tcd->vthis->type; | |
| 262 // Do not call checkNestedRef() | |
| 263 //e1 = e1->semantic(sc); | |
| 264 | |
| 265 // Skip up over nested functions, and get the enclosing | |
| 266 // class type. | |
| 267 int n = 0; | |
| 268 Dsymbol *s; | |
| 269 for (s = tcd->toParent(); | |
| 270 s && s->isFuncDeclaration(); | |
| 271 s = s->toParent()) | |
| 272 { FuncDeclaration *f = s->isFuncDeclaration(); | |
| 273 if (f->vthis) | |
| 274 { | |
| 275 //printf("rewriting e1 to %s's this\n", f->toChars()); | |
| 276 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
|
277 |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
278 // 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
|
279 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
|
280 |
| 336 | 281 e1 = new VarExp(loc, f->vthis); |
| 282 } | |
| 283 } | |
| 284 if (s && s->isClassDeclaration()) | |
| 285 { e1->type = s->isClassDeclaration()->type; | |
| 286 if (n > 1) | |
| 287 e1 = e1->semantic(sc); | |
| 288 } | |
| 289 else | |
| 290 e1 = e1->semantic(sc); | |
| 291 goto L1; | |
| 292 } | |
| 293 /* Can't find a path from e1 to ad | |
| 294 */ | |
| 295 e1->error("this for %s needs to be type %s not type %s", | |
| 296 var->toChars(), ad->toChars(), t->toChars()); | |
| 297 } | |
| 298 } | |
| 299 return e1; | |
| 300 } | |
| 301 | |
| 159 | 302 /***************************************** |
| 303 * Determine if 'this' is available. | |
| 304 * If it is, return the FuncDeclaration that has it. | |
| 305 */ | |
| 306 | |
| 307 FuncDeclaration *hasThis(Scope *sc) | |
| 308 { FuncDeclaration *fd; | |
| 309 FuncDeclaration *fdthis; | |
| 310 | |
| 311 //printf("hasThis()\n"); | |
| 312 fdthis = sc->parent->isFuncDeclaration(); | |
| 313 //printf("fdthis = %p, '%s'\n", fdthis, fdthis ? fdthis->toChars() : ""); | |
| 314 | |
| 315 // Go upwards until we find the enclosing member function | |
| 316 fd = fdthis; | |
| 317 while (1) | |
| 318 { | |
| 319 if (!fd) | |
| 320 { | |
| 321 goto Lno; | |
| 322 } | |
| 323 if (!fd->isNested()) | |
| 324 break; | |
| 325 | |
| 326 Dsymbol *parent = fd->parent; | |
| 327 while (parent) | |
| 328 { | |
| 329 TemplateInstance *ti = parent->isTemplateInstance(); | |
| 330 if (ti) | |
| 331 parent = ti->parent; | |
| 332 else | |
| 333 break; | |
| 334 } | |
| 335 | |
| 336 fd = fd->parent->isFuncDeclaration(); | |
| 337 } | |
| 338 | |
| 339 if (!fd->isThis()) | |
| 340 { //printf("test '%s'\n", fd->toChars()); | |
| 341 goto Lno; | |
| 342 } | |
| 343 | |
| 344 assert(fd->vthis); | |
| 345 return fd; | |
| 346 | |
| 347 Lno: | |
| 348 return NULL; // don't have 'this' available | |
| 349 } | |
| 350 | |
| 351 | |
| 352 /*************************************** | |
| 353 * Pull out any properties. | |
| 354 */ | |
| 355 | |
| 356 Expression *resolveProperties(Scope *sc, Expression *e) | |
| 357 { | |
| 358 //printf("resolveProperties(%s)\n", e->toChars()); | |
| 359 if (e->type) | |
| 360 { | |
| 361 Type *t = e->type->toBasetype(); | |
| 362 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
363 if (t->ty == Tfunction /*|| e->op == TOKoverloadset*/) |
| 159 | 364 { |
| 365 e = new CallExp(e->loc, e); | |
| 366 e = e->semantic(sc); | |
| 367 } | |
| 368 | |
| 369 /* Look for e being a lazy parameter; rewrite as delegate call | |
| 370 */ | |
| 371 else if (e->op == TOKvar) | |
| 372 { VarExp *ve = (VarExp *)e; | |
| 373 | |
| 374 if (ve->var->storage_class & STClazy) | |
| 375 { | |
| 376 e = new CallExp(e->loc, e); | |
| 377 e = e->semantic(sc); | |
| 378 } | |
| 379 } | |
| 380 | |
| 381 else if (e->op == TOKdotexp) | |
| 382 { | |
| 383 e->error("expression has no value"); | |
| 384 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
385 |
| 159 | 386 } |
| 387 return e; | |
| 388 } | |
| 389 | |
| 390 /****************************** | |
| 391 * Perform semantic() on an array of Expressions. | |
| 392 */ | |
| 393 | |
| 394 void arrayExpressionSemantic(Expressions *exps, Scope *sc) | |
| 395 { | |
| 396 if (exps) | |
| 397 { | |
| 398 for (size_t i = 0; i < exps->dim; i++) | |
| 399 { Expression *e = (Expression *)exps->data[i]; | |
| 400 | |
| 401 e = e->semantic(sc); | |
| 402 exps->data[i] = (void *)e; | |
| 403 } | |
| 404 } | |
| 405 } | |
| 406 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
407 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
408 /****************************** |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
409 * 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
|
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 #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
|
413 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
|
414 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
415 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
|
416 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
417 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
|
418 { 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
|
419 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
|
420 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
|
421 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
422 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
423 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
|
424 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
425 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
426 |
| 159 | 427 /**************************************** |
| 428 * Expand tuples. | |
| 429 */ | |
| 430 | |
| 431 void expandTuples(Expressions *exps) | |
| 432 { | |
| 433 //printf("expandTuples()\n"); | |
| 434 if (exps) | |
| 435 { | |
| 436 for (size_t i = 0; i < exps->dim; i++) | |
| 437 { Expression *arg = (Expression *)exps->data[i]; | |
| 438 if (!arg) | |
| 439 continue; | |
| 440 | |
| 441 // Look for tuple with 0 members | |
| 442 if (arg->op == TOKtype) | |
| 443 { TypeExp *e = (TypeExp *)arg; | |
| 444 if (e->type->toBasetype()->ty == Ttuple) | |
| 445 { TypeTuple *tt = (TypeTuple *)e->type->toBasetype(); | |
| 446 | |
| 447 if (!tt->arguments || tt->arguments->dim == 0) | |
| 448 { | |
| 449 exps->remove(i); | |
| 450 if (i == exps->dim) | |
| 451 return; | |
| 452 i--; | |
| 453 continue; | |
| 454 } | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 // Inline expand all the tuples | |
| 459 while (arg->op == TOKtuple) | |
| 460 { TupleExp *te = (TupleExp *)arg; | |
| 461 | |
| 462 exps->remove(i); // remove arg | |
| 463 exps->insert(i, te->exps); // replace with tuple contents | |
| 464 if (i == exps->dim) | |
| 465 return; // empty tuple, no more arguments | |
| 466 arg = (Expression *)exps->data[i]; | |
| 467 } | |
| 468 } | |
| 469 } | |
| 470 } | |
| 471 | |
| 472 /**************************************** | |
| 473 * Preprocess arguments to function. | |
| 474 */ | |
| 475 | |
| 476 void preFunctionArguments(Loc loc, Scope *sc, Expressions *exps) | |
| 477 { | |
| 478 if (exps) | |
| 479 { | |
| 480 expandTuples(exps); | |
| 481 | |
| 482 for (size_t i = 0; i < exps->dim; i++) | |
| 483 { Expression *arg = (Expression *)exps->data[i]; | |
| 484 | |
| 485 if (!arg->type) | |
| 486 { | |
| 487 #ifdef DEBUG | |
| 488 if (!global.gag) | |
| 489 printf("1: \n"); | |
| 490 #endif | |
| 491 arg->error("%s is not an expression", arg->toChars()); | |
| 492 arg = new IntegerExp(arg->loc, 0, Type::tint32); | |
| 493 } | |
| 494 | |
| 495 arg = resolveProperties(sc, arg); | |
| 496 exps->data[i] = (void *) arg; | |
| 497 | |
| 498 //arg->rvalue(); | |
| 499 #if 0 | |
| 500 if (arg->type->ty == Tfunction) | |
| 501 { | |
| 502 arg = new AddrExp(arg->loc, arg); | |
| 503 arg = arg->semantic(sc); | |
| 504 exps->data[i] = (void *) arg; | |
| 505 } | |
| 506 #endif | |
| 507 } | |
| 508 } | |
| 509 } | |
| 510 | |
| 336 | 511 /********************************************* |
| 512 * Call copy constructor for struct value argument. | |
| 513 */ | |
| 514 #if DMDV2 | |
| 515 Expression *callCpCtor(Loc loc, Scope *sc, Expression *e) | |
| 516 { | |
| 517 Type *tb = e->type->toBasetype(); | |
| 518 assert(tb->ty == Tstruct); | |
| 519 StructDeclaration *sd = ((TypeStruct *)tb)->sym; | |
| 520 if (sd->cpctor) | |
| 521 { | |
| 522 /* Create a variable tmp, and replace the argument e with: | |
| 523 * (tmp = e),tmp | |
| 524 * and let AssignExp() handle the construction. | |
| 525 * This is not the most efficent, ideally tmp would be constructed | |
| 526 * directly onto the stack. | |
| 527 */ | |
| 528 Identifier *idtmp = Lexer::uniqueId("__tmp"); | |
| 529 VarDeclaration *tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(0, e)); | |
| 530 Expression *ae = new DeclarationExp(loc, tmp); | |
| 531 e = new CommaExp(loc, ae, new VarExp(loc, tmp)); | |
| 532 e = e->semantic(sc); | |
| 533 } | |
| 534 return e; | |
| 535 } | |
| 536 #endif | |
| 159 | 537 |
| 538 /**************************************** | |
| 539 * Now that we know the exact type of the function we're calling, | |
| 540 * 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
|
541 * 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
|
542 * 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
|
543 * 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
|
544 * 4. add hidden _arguments[] argument |
| 159 | 545 */ |
| 546 | |
| 547 void functionArguments(Loc loc, Scope *sc, TypeFunction *tf, Expressions *arguments) | |
| 548 { | |
| 549 unsigned n; | |
| 550 | |
| 551 //printf("functionArguments()\n"); | |
| 552 assert(arguments); | |
| 553 size_t nargs = arguments ? arguments->dim : 0; | |
| 554 size_t nparams = Argument::dim(tf->parameters); | |
| 555 | |
| 556 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
|
557 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 558 |
| 559 n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams) | |
| 560 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
561 int done = 0; |
| 159 | 562 for (size_t i = 0; i < n; i++) |
| 563 { | |
| 564 Expression *arg; | |
| 565 | |
| 566 if (i < nargs) | |
| 567 arg = (Expression *)arguments->data[i]; | |
| 568 else | |
| 569 arg = NULL; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
570 Type *tb; |
| 159 | 571 |
| 572 if (i < nparams) | |
| 573 { | |
| 574 Argument *p = Argument::getNth(tf->parameters, i); | |
| 575 | |
| 576 if (!arg) | |
| 577 { | |
| 578 if (!p->defaultArg) | |
| 579 { | |
| 580 if (tf->varargs == 2 && i + 1 == nparams) | |
| 581 goto L2; | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
582 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 583 break; |
| 584 } | |
| 336 | 585 arg = p->defaultArg; |
| 586 #if DMDV2 | |
| 587 if (arg->op == TOKdefault) | |
| 588 { DefaultInitExp *de = (DefaultInitExp *)arg; | |
| 589 arg = de->resolve(loc, sc); | |
| 590 } | |
| 591 else | |
| 592 #endif | |
| 593 arg = arg->copy(); | |
| 159 | 594 arguments->push(arg); |
| 595 nargs++; | |
| 596 } | |
| 597 | |
| 598 if (tf->varargs == 2 && i + 1 == nparams) | |
| 599 { | |
| 600 //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars()); | |
| 601 if (arg->implicitConvTo(p->type)) | |
| 602 { | |
| 603 if (nargs != nparams) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
604 error(loc, "expected %zu arguments, not %zu", nparams, nargs); |
| 159 | 605 goto L1; |
| 606 } | |
| 607 L2: | |
| 608 Type *tb = p->type->toBasetype(); | |
| 609 Type *tret = p->isLazyArray(); | |
| 610 switch (tb->ty) | |
| 611 { | |
| 612 case Tsarray: | |
| 613 case Tarray: | |
| 614 { // Create a static array variable v of type arg->type | |
| 615 #ifdef IN_GCC | |
| 616 /* GCC 4.0 does not like zero length arrays used like | |
| 617 this; pass a null array value instead. Could also | |
| 618 just make a one-element array. */ | |
| 619 if (nargs - i == 0) | |
| 620 { | |
| 621 arg = new NullExp(loc); | |
| 622 break; | |
| 623 } | |
| 624 #endif | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
625 Identifier *id = Lexer::uniqueId("__arrayArg"); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
626 Type *t = new TypeSArray(((TypeArray *)tb)->next, new IntegerExp(nargs - i)); |
| 159 | 627 t = t->semantic(loc, sc); |
| 628 VarDeclaration *v = new VarDeclaration(loc, t, id, new VoidInitializer(loc)); | |
| 629 v->semantic(sc); | |
| 630 v->parent = sc->parent; | |
| 631 //sc->insert(v); | |
| 632 | |
| 633 Expression *c = new DeclarationExp(0, v); | |
| 634 c->type = v->type; | |
| 635 | |
| 636 for (size_t u = i; u < nargs; u++) | |
| 637 { Expression *a = (Expression *)arguments->data[u]; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
638 if (tret && !((TypeArray *)tb)->next->equals(a->type)) |
| 159 | 639 a = a->toDelegate(sc, tret); |
| 640 | |
| 641 Expression *e = new VarExp(loc, v); | |
| 642 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
|
643 AssignExp *ae = new AssignExp(loc, e, a); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
644 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
645 ae->op = TOKconstruct; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
646 #endif |
| 159 | 647 if (c) |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
648 c = new CommaExp(loc, c, ae); |
| 159 | 649 else |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
650 c = ae; |
| 159 | 651 } |
| 652 arg = new VarExp(loc, v); | |
| 653 if (c) | |
| 654 arg = new CommaExp(loc, c, arg); | |
| 655 break; | |
| 656 } | |
| 657 case Tclass: | |
| 658 { /* Set arg to be: | |
| 659 * new Tclass(arg0, arg1, ..., argn) | |
| 660 */ | |
| 661 Expressions *args = new Expressions(); | |
| 662 args->setDim(nargs - i); | |
| 663 for (size_t u = i; u < nargs; u++) | |
| 664 args->data[u - i] = arguments->data[u]; | |
| 665 arg = new NewExp(loc, NULL, NULL, p->type, args); | |
| 666 break; | |
| 667 } | |
| 668 default: | |
| 669 if (!arg) | |
| 670 { error(loc, "not enough arguments"); | |
| 671 return; | |
| 672 } | |
| 673 break; | |
| 674 } | |
| 675 arg = arg->semantic(sc); | |
| 676 //printf("\targ = '%s'\n", arg->toChars()); | |
| 677 arguments->setDim(i + 1); | |
| 678 done = 1; | |
| 679 } | |
| 680 | |
| 681 L1: | |
| 682 if (!(p->storageClass & STClazy && p->type->ty == Tvoid)) | |
| 683 arg = arg->implicitCastTo(sc, p->type); | |
| 684 if (p->storageClass & (STCout | STCref)) | |
| 685 { | |
| 686 // BUG: should check that argument to ref is type 'invariant' | |
| 687 // BUG: assignments to ref should also be type 'invariant' | |
| 688 arg = arg->modifiableLvalue(sc, arg); | |
| 689 | |
| 690 //if (arg->op == TOKslice) | |
| 691 //arg->error("cannot modify slice %s", arg->toChars()); | |
| 692 } | |
| 693 | |
|
723
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
694 // 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
|
695 #if !IN_LLVM |
| 159 | 696 // Convert static arrays to pointers |
| 697 tb = arg->type->toBasetype(); | |
| 698 if (tb->ty == Tsarray) | |
| 699 { | |
| 700 arg = arg->checkToPointer(); | |
| 701 } | |
|
723
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
702 #endif |
|
55f6c2e454d7
Implemented correct parameter order according to x86-32 ABI documentation.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
717
diff
changeset
|
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 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
|
706 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
707 arg = callCpCtor(loc, sc, arg); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
708 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
709 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
710 |
| 159 | 711 // Convert lazy argument to a delegate |
| 712 if (p->storageClass & STClazy) | |
| 713 { | |
| 714 arg = arg->toDelegate(sc, p->type); | |
| 715 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
716 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
717 /* 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
|
718 * function. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
719 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
720 if (!tf->parameterEscapes(p)) |
|
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 /* 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
|
723 * 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
|
724 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
725 if (arg->op == TOKfunction) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
726 { FuncExp *fe = (FuncExp *)arg; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
727 fe->fd->tookAddressOf = 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
728 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
729 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
730 /* 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
|
731 * 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
|
732 * 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
|
733 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
734 else if (arg->op == TOKdelegate) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
735 { DelegateExp *de = (DelegateExp *)arg; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
736 if (de->e1->op == TOKvar) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
737 { VarExp *ve = (VarExp *)de->e1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
738 FuncDeclaration *f = ve->var->isFuncDeclaration(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
739 if (f) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
740 { f->tookAddressOf--; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
741 //printf("tookAddressOf = %d\n", f->tookAddressOf); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
742 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
743 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
744 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
745 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
746 #endif |
| 159 | 747 } |
| 748 else | |
| 749 { | |
| 750 | |
| 751 // 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
|
752 // 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
|
753 if (tf->linkage != LINKd && tf->linkage != LINKintrinsic) |
| 159 | 754 { |
| 755 // Promote bytes, words, etc., to ints | |
| 756 arg = arg->integralPromotions(sc); | |
| 757 | |
| 758 // Promote floats to doubles | |
| 759 switch (arg->type->ty) | |
| 760 { | |
| 761 case Tfloat32: | |
| 762 arg = arg->castTo(sc, Type::tfloat64); | |
| 763 break; | |
| 764 | |
| 765 case Timaginary32: | |
| 766 arg = arg->castTo(sc, Type::timaginary64); | |
| 767 break; | |
| 768 } | |
| 769 } | |
| 770 | |
| 771 // Convert static arrays to dynamic arrays | |
| 772 tb = arg->type->toBasetype(); | |
| 773 if (tb->ty == Tsarray) | |
| 774 { TypeSArray *ts = (TypeSArray *)tb; | |
| 336 | 775 Type *ta = ts->next->arrayOf(); |
| 159 | 776 if (ts->size(arg->loc) == 0) |
| 777 { arg = new NullExp(arg->loc); | |
| 778 arg->type = ta; | |
| 779 } | |
| 780 else | |
| 781 arg = arg->castTo(sc, ta); | |
| 782 } | |
| 336 | 783 #if DMDV2 |
| 784 if (tb->ty == Tstruct) | |
| 785 { | |
| 786 arg = callCpCtor(loc, sc, arg); | |
| 787 } | |
| 788 | |
| 789 // Give error for overloaded function addresses | |
| 790 if (arg->op == TOKsymoff) | |
| 791 { SymOffExp *se = (SymOffExp *)arg; | |
| 792 if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique()) | |
| 793 arg->error("function %s is overloaded", arg->toChars()); | |
| 794 } | |
| 795 #endif | |
| 159 | 796 arg->rvalue(); |
| 797 } | |
| 798 arg = arg->optimize(WANTvalue); | |
| 799 arguments->data[i] = (void *) arg; | |
| 800 if (done) | |
| 801 break; | |
| 802 } | |
| 803 | |
| 804 #if !IN_LLVM | |
| 805 // If D linkage and variadic, add _arguments[] as first argument | |
| 806 if (tf->linkage == LINKd && tf->varargs == 1) | |
| 807 { | |
| 808 Expression *e; | |
| 809 | |
| 810 e = createTypeInfoArray(sc, (Expression **)&arguments->data[nparams], | |
| 811 arguments->dim - nparams); | |
| 812 arguments->insert(0, e); | |
| 813 } | |
| 814 #endif | |
| 815 } | |
| 816 | |
| 817 /************************************************** | |
| 818 * Write expression out to buf, but wrap it | |
| 819 * in ( ) if its precedence is less than pr. | |
| 820 */ | |
| 821 | |
| 822 void expToCBuffer(OutBuffer *buf, HdrGenState *hgs, Expression *e, enum PREC pr) | |
| 823 { | |
| 336 | 824 //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
|
825 if (precedence[e->op] < pr || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
826 /* 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
|
827 * They must be parenthesized. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
828 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
829 (pr == PREC_rel && precedence[e->op] == pr)) |
| 159 | 830 { |
| 831 buf->writeByte('('); | |
| 832 e->toCBuffer(buf, hgs); | |
| 833 buf->writeByte(')'); | |
| 834 } | |
| 835 else | |
| 836 e->toCBuffer(buf, hgs); | |
| 837 } | |
| 838 | |
| 839 /************************************************** | |
| 840 * Write out argument list to buf. | |
| 841 */ | |
| 842 | |
| 843 void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) | |
| 844 { | |
| 845 if (arguments) | |
| 846 { | |
| 847 for (size_t i = 0; i < arguments->dim; i++) | |
| 848 { Expression *arg = (Expression *)arguments->data[i]; | |
| 849 | |
| 850 if (arg) | |
| 851 { if (i) | |
| 852 buf->writeByte(','); | |
| 853 expToCBuffer(buf, hgs, arg, PREC_assign); | |
| 854 } | |
| 855 } | |
| 856 } | |
| 857 } | |
| 858 | |
| 859 /************************************************** | |
| 860 * Write out argument types to buf. | |
| 861 */ | |
| 862 | |
| 863 void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs) | |
| 864 { | |
| 865 if (arguments) | |
| 866 { OutBuffer argbuf; | |
| 867 | |
| 868 for (size_t i = 0; i < arguments->dim; i++) | |
| 869 { Expression *arg = (Expression *)arguments->data[i]; | |
| 870 | |
| 871 if (i) | |
| 872 buf->writeByte(','); | |
| 873 argbuf.reset(); | |
| 874 arg->type->toCBuffer2(&argbuf, hgs, 0); | |
| 875 buf->write(&argbuf); | |
| 876 } | |
| 877 } | |
| 878 } | |
| 879 | |
| 880 /******************************** Expression **************************/ | |
| 881 | |
| 882 Expression::Expression(Loc loc, enum TOK op, int size) | |
| 883 : loc(loc) | |
| 884 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
885 //printf("Expression::Expression(op = %d) this = %p\n", op, this); |
| 159 | 886 this->loc = loc; |
| 887 this->op = op; | |
| 888 this->size = size; | |
| 889 type = NULL; | |
| 890 } | |
| 891 | |
| 892 Expression *Expression::syntaxCopy() | |
| 893 { | |
| 894 //printf("Expression::syntaxCopy()\n"); | |
| 895 //dump(0); | |
| 896 return copy(); | |
| 897 } | |
| 898 | |
| 899 /********************************* | |
| 900 * Does *not* do a deep copy. | |
| 901 */ | |
| 902 | |
| 903 Expression *Expression::copy() | |
| 904 { | |
| 905 Expression *e; | |
| 906 if (!size) | |
| 907 { | |
| 908 #ifdef DEBUG | |
| 909 fprintf(stdmsg, "No expression copy for: %s\n", toChars()); | |
| 910 printf("op = %d\n", op); | |
| 911 dump(0); | |
| 912 #endif | |
| 913 assert(0); | |
| 914 } | |
| 915 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
|
916 //printf("Expression::copy(op = %d) e = %p\n", op, e); |
| 159 | 917 return (Expression *)memcpy(e, this, size); |
| 918 } | |
| 919 | |
| 920 /************************** | |
| 921 * Semantically analyze Expression. | |
| 922 * Determine types, fold constants, etc. | |
| 923 */ | |
| 924 | |
| 925 Expression *Expression::semantic(Scope *sc) | |
| 926 { | |
| 927 #if LOGSEMANTIC | |
| 336 | 928 printf("Expression::semantic() %s\n", toChars()); |
| 159 | 929 #endif |
| 930 if (type) | |
| 931 type = type->semantic(loc, sc); | |
| 932 else | |
| 933 type = Type::tvoid; | |
| 934 return this; | |
| 935 } | |
| 936 | |
| 937 void Expression::print() | |
| 938 { | |
| 939 fprintf(stdmsg, "%s\n", toChars()); | |
| 940 fflush(stdmsg); | |
| 941 } | |
| 942 | |
| 943 char *Expression::toChars() | |
| 944 { OutBuffer *buf; | |
| 945 HdrGenState hgs; | |
| 946 | |
| 947 memset(&hgs, 0, sizeof(hgs)); | |
| 948 buf = new OutBuffer(); | |
| 949 toCBuffer(buf, &hgs); | |
| 950 return buf->toChars(); | |
| 951 } | |
| 952 | |
| 953 void Expression::error(const char *format, ...) | |
| 954 { | |
| 955 va_list ap; | |
| 956 va_start(ap, format); | |
| 957 ::verror(loc, format, ap); | |
| 958 va_end( ap ); | |
| 959 } | |
| 960 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
961 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
|
962 { |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
963 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
|
964 { |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
965 va_list ap; |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
966 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
|
967 ::vwarning(loc, format, ap); |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
968 va_end( ap ); |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
969 } |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
970 } |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
971 |
| 159 | 972 void Expression::rvalue() |
| 973 { | |
| 974 if (type && type->toBasetype()->ty == Tvoid) | |
| 975 { error("expression %s is void and has no value", toChars()); | |
| 976 #if 0 | |
| 977 dump(0); | |
| 978 halt(); | |
| 979 #endif | |
| 336 | 980 type = Type::tint32; |
| 159 | 981 } |
| 982 } | |
| 983 | |
| 984 Expression *Expression::combine(Expression *e1, Expression *e2) | |
| 985 { | |
| 986 if (e1) | |
| 987 { | |
| 988 if (e2) | |
| 989 { | |
| 990 e1 = new CommaExp(e1->loc, e1, e2); | |
| 991 e1->type = e2->type; | |
| 992 } | |
| 993 } | |
| 994 else | |
| 995 e1 = e2; | |
| 996 return e1; | |
| 997 } | |
| 998 | |
| 999 integer_t Expression::toInteger() | |
| 1000 { | |
| 1001 //printf("Expression %s\n", Token::toChars(op)); | |
| 1002 error("Integer constant expression expected instead of %s", toChars()); | |
| 1003 return 0; | |
| 1004 } | |
| 1005 | |
| 1006 uinteger_t Expression::toUInteger() | |
| 1007 { | |
| 1008 //printf("Expression %s\n", Token::toChars(op)); | |
| 1009 return (uinteger_t)toInteger(); | |
| 1010 } | |
| 1011 | |
| 1012 real_t Expression::toReal() | |
| 1013 { | |
| 1014 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1015 return 0; | |
| 1016 } | |
| 1017 | |
| 1018 real_t Expression::toImaginary() | |
| 1019 { | |
| 1020 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1021 return 0; | |
| 1022 } | |
| 1023 | |
| 1024 complex_t Expression::toComplex() | |
| 1025 { | |
| 1026 error("Floating point constant expression expected instead of %s", toChars()); | |
| 1027 #ifdef IN_GCC | |
| 1028 return complex_t(real_t(0)); // %% nicer | |
| 1029 #else | |
| 1030 return 0; | |
| 1031 #endif | |
| 1032 } | |
| 1033 | |
| 1034 void Expression::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1035 { | |
| 1036 buf->writestring(Token::toChars(op)); | |
| 1037 } | |
| 1038 | |
| 1039 void Expression::toMangleBuffer(OutBuffer *buf) | |
| 1040 { | |
| 1041 error("expression %s is not a valid template value argument", toChars()); | |
| 1042 } | |
| 1043 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1044 /*************************************** |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1045 * Return !=0 if expression is an lvalue. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1046 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1047 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1048 int Expression::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1049 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1050 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1051 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1052 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1053 |
| 159 | 1054 /******************************* |
| 1055 * Give error if we're not an lvalue. | |
| 1056 * If we can, convert expression to be an lvalue. | |
| 1057 */ | |
| 1058 | |
| 1059 Expression *Expression::toLvalue(Scope *sc, Expression *e) | |
| 1060 { | |
| 1061 if (!e) | |
| 1062 e = this; | |
| 1063 else if (!loc.filename) | |
| 1064 loc = e->loc; | |
| 1065 error("%s is not an lvalue", e->toChars()); | |
| 1066 return this; | |
| 1067 } | |
| 1068 | |
| 1069 Expression *Expression::modifiableLvalue(Scope *sc, Expression *e) | |
| 1070 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1071 //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
|
1072 |
| 159 | 1073 // 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
|
1074 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1075 if (type && (!type->isMutable() || !type->isAssignable())) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1076 error("%s is not mutable", e->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1077 #endif |
| 159 | 1078 return toLvalue(sc, e); |
| 1079 } | |
| 1080 | |
| 1081 /************************************ | |
| 1082 * Detect cases where pointers to the stack can 'escape' the | |
| 1083 * lifetime of the stack frame. | |
| 1084 */ | |
| 1085 | |
| 1086 void Expression::checkEscape() | |
| 1087 { | |
| 1088 } | |
| 1089 | |
| 1090 void Expression::checkScalar() | |
| 1091 { | |
| 1092 if (!type->isscalar()) | |
| 1093 error("'%s' is not a scalar, it is a %s", toChars(), type->toChars()); | |
| 1094 } | |
| 1095 | |
| 1096 void Expression::checkNoBool() | |
| 1097 { | |
| 1098 if (type->toBasetype()->ty == Tbool) | |
| 1099 error("operation not allowed on bool '%s'", toChars()); | |
| 1100 } | |
| 1101 | |
| 1102 Expression *Expression::checkIntegral() | |
| 1103 { | |
| 1104 if (!type->isintegral()) | |
| 1105 { error("'%s' is not of integral type, it is a %s", toChars(), type->toChars()); | |
| 1106 return new IntegerExp(0); | |
| 1107 } | |
| 1108 return this; | |
| 1109 } | |
| 1110 | |
| 1111 Expression *Expression::checkArithmetic() | |
| 1112 { | |
| 1113 if (!type->isintegral() && !type->isfloating()) | |
| 1114 { error("'%s' is not of arithmetic type, it is a %s", toChars(), type->toChars()); | |
| 1115 return new IntegerExp(0); | |
| 1116 } | |
| 1117 return this; | |
| 1118 } | |
| 1119 | |
| 1120 void Expression::checkDeprecated(Scope *sc, Dsymbol *s) | |
| 1121 { | |
| 1122 s->checkDeprecated(loc, sc); | |
| 1123 } | |
| 1124 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1125 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1126 void Expression::checkPurity(Scope *sc, FuncDeclaration *f) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1127 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1128 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
|
1129 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
|
1130 sc->func->toChars(), f->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1131 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1132 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1133 |
| 159 | 1134 /******************************** |
| 1135 * Check for expressions that have no use. | |
| 1136 * Input: | |
| 1137 * flag 0 not going to use the result, so issue error message if no | |
| 1138 * side effects | |
| 1139 * 1 the result of the expression is used, but still check | |
| 1140 * for useless subexpressions | |
| 1141 * 2 do not issue error messages, just return !=0 if expression | |
| 1142 * has side effects | |
| 1143 */ | |
| 1144 | |
| 1145 int Expression::checkSideEffect(int flag) | |
| 1146 { | |
| 1147 if (flag == 0) | |
| 1148 { if (op == TOKimport) | |
| 1149 { | |
| 1150 error("%s has no effect", toChars()); | |
| 1151 } | |
| 1152 else | |
| 1153 error("%s has no effect in expression (%s)", | |
| 1154 Token::toChars(op), toChars()); | |
| 1155 } | |
| 1156 return 0; | |
| 1157 } | |
| 1158 | |
| 1159 /***************************** | |
| 1160 * Check that expression can be tested for true or false. | |
| 1161 */ | |
| 1162 | |
| 1163 Expression *Expression::checkToBoolean() | |
| 1164 { | |
| 1165 // Default is 'yes' - do nothing | |
| 1166 | |
| 1167 #ifdef DEBUG | |
| 1168 if (!type) | |
| 1169 dump(0); | |
| 1170 #endif | |
| 1171 | |
| 1172 if (!type->checkBoolean()) | |
| 1173 { | |
| 1174 error("expression %s of type %s does not have a boolean value", toChars(), type->toChars()); | |
| 1175 } | |
| 1176 return this; | |
| 1177 } | |
| 1178 | |
| 1179 /**************************** | |
| 1180 */ | |
| 1181 | |
| 1182 Expression *Expression::checkToPointer() | |
| 1183 { | |
| 1184 Expression *e; | |
| 1185 Type *tb; | |
| 1186 | |
| 1187 //printf("Expression::checkToPointer()\n"); | |
| 1188 e = this; | |
| 1189 | |
| 1190 // If C static array, convert to pointer | |
| 1191 tb = type->toBasetype(); | |
| 1192 if (tb->ty == Tsarray) | |
| 1193 { TypeSArray *ts = (TypeSArray *)tb; | |
| 1194 if (ts->size(loc) == 0) | |
| 1195 e = new NullExp(loc); | |
| 1196 else | |
| 1197 e = new AddrExp(loc, this); | |
| 336 | 1198 e->type = ts->next->pointerTo(); |
| 159 | 1199 } |
| 1200 return e; | |
| 1201 } | |
| 1202 | |
| 1203 /****************************** | |
| 1204 * Take address of expression. | |
| 1205 */ | |
| 1206 | |
| 1207 Expression *Expression::addressOf(Scope *sc) | |
| 1208 { | |
| 1209 Expression *e; | |
| 1210 | |
| 1211 //printf("Expression::addressOf()\n"); | |
| 1212 e = toLvalue(sc, NULL); | |
| 1213 e = new AddrExp(loc, e); | |
| 1214 e->type = type->pointerTo(); | |
| 1215 return e; | |
| 1216 } | |
| 1217 | |
| 1218 /****************************** | |
| 1219 * If this is a reference, dereference it. | |
| 1220 */ | |
| 1221 | |
| 1222 Expression *Expression::deref() | |
| 1223 { | |
| 1224 //printf("Expression::deref()\n"); | |
| 1225 if (type->ty == Treference) | |
| 1226 { Expression *e; | |
| 1227 | |
| 1228 e = new PtrExp(loc, this); | |
| 336 | 1229 e->type = ((TypeReference *)type)->next; |
| 159 | 1230 return e; |
| 1231 } | |
| 1232 return this; | |
| 1233 } | |
| 1234 | |
| 1235 /******************************** | |
| 1236 * Does this expression statically evaluate to a boolean TRUE or FALSE? | |
| 1237 */ | |
| 1238 | |
| 1239 int Expression::isBool(int result) | |
| 1240 { | |
| 1241 return FALSE; | |
| 1242 } | |
| 1243 | |
| 1244 /******************************** | |
| 1245 * Does this expression result in either a 1 or a 0? | |
| 1246 */ | |
| 1247 | |
| 1248 int Expression::isBit() | |
| 1249 { | |
| 1250 return FALSE; | |
| 1251 } | |
| 1252 | |
| 336 | 1253 /******************************** |
| 1254 * Can this expression throw an exception? | |
| 1255 * Valid only after semantic() pass. | |
| 1256 */ | |
| 1257 | |
| 1258 int Expression::canThrow() | |
| 1259 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1260 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1261 return FALSE; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1262 #else |
| 336 | 1263 return TRUE; |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1264 #endif |
| 336 | 1265 } |
| 1266 | |
| 1267 | |
| 1268 | |
| 159 | 1269 Expressions *Expression::arraySyntaxCopy(Expressions *exps) |
| 1270 { Expressions *a = NULL; | |
| 1271 | |
| 1272 if (exps) | |
| 1273 { | |
| 1274 a = new Expressions(); | |
| 1275 a->setDim(exps->dim); | |
| 1276 for (int i = 0; i < a->dim; i++) | |
| 1277 { Expression *e = (Expression *)exps->data[i]; | |
| 1278 | |
| 1279 e = e->syntaxCopy(); | |
| 1280 a->data[i] = e; | |
| 1281 } | |
| 1282 } | |
| 1283 return a; | |
| 1284 } | |
| 1285 | |
| 1286 /******************************** IntegerExp **************************/ | |
| 1287 | |
| 1288 IntegerExp::IntegerExp(Loc loc, integer_t value, Type *type) | |
| 1289 : Expression(loc, TOKint64, sizeof(IntegerExp)) | |
| 1290 { | |
| 1291 //printf("IntegerExp(value = %lld, type = '%s')\n", value, type ? type->toChars() : ""); | |
| 1292 if (type && !type->isscalar()) | |
| 1293 { | |
| 336 | 1294 //printf("%s, loc = %d\n", toChars(), loc.linnum); |
| 159 | 1295 error("integral constant must be scalar type, not %s", type->toChars()); |
| 1296 type = Type::terror; | |
| 1297 } | |
| 1298 this->type = type; | |
| 1299 this->value = value; | |
| 1300 } | |
| 1301 | |
| 1302 IntegerExp::IntegerExp(integer_t value) | |
| 1303 : Expression(0, TOKint64, sizeof(IntegerExp)) | |
| 1304 { | |
| 1305 this->type = Type::tint32; | |
| 1306 this->value = value; | |
| 1307 } | |
| 1308 | |
| 1309 int IntegerExp::equals(Object *o) | |
| 1310 { IntegerExp *ne; | |
| 1311 | |
| 1312 if (this == o || | |
| 1313 (((Expression *)o)->op == TOKint64 && | |
| 1314 ((ne = (IntegerExp *)o), type->equals(ne->type)) && | |
| 1315 value == ne->value)) | |
| 1316 return 1; | |
| 1317 return 0; | |
| 1318 } | |
| 1319 | |
| 1320 char *IntegerExp::toChars() | |
| 1321 { | |
| 1322 #if 1 | |
| 1323 return Expression::toChars(); | |
| 1324 #else | |
| 1325 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
|
1326 |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1327 sprintf(buffer, "%jd", value); |
| 159 | 1328 return buffer; |
| 1329 #endif | |
| 1330 } | |
| 1331 | |
| 1332 integer_t IntegerExp::toInteger() | |
| 1333 { Type *t; | |
| 1334 | |
| 1335 t = type; | |
| 1336 while (t) | |
| 1337 { | |
| 1338 switch (t->ty) | |
| 1339 { | |
| 1340 case Tbit: | |
| 1341 case Tbool: value = (value != 0); break; | |
| 1342 case Tint8: value = (d_int8) value; break; | |
| 1343 case Tchar: | |
| 1344 case Tuns8: value = (d_uns8) value; break; | |
| 1345 case Tint16: value = (d_int16) value; break; | |
| 1346 case Twchar: | |
| 1347 case Tuns16: value = (d_uns16) value; break; | |
| 1348 case Tint32: value = (d_int32) value; break; | |
| 1349 case Tdchar: | |
| 1350 case Tuns32: value = (d_uns32) value; break; | |
| 1351 case Tint64: value = (d_int64) value; break; | |
| 1352 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
|
1353 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
|
1354 // FIXME: Other pointer widths than 32 and 64? |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1355 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
|
1356 value = (d_uns32) value; |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1357 else |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1358 value = (d_uns64) value; |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1359 break; |
| 159 | 1360 |
| 1361 case Tenum: | |
| 1362 { | |
| 1363 TypeEnum *te = (TypeEnum *)t; | |
| 1364 t = te->sym->memtype; | |
| 1365 continue; | |
| 1366 } | |
| 1367 | |
| 1368 case Ttypedef: | |
| 1369 { | |
| 1370 TypeTypedef *tt = (TypeTypedef *)t; | |
| 1371 t = tt->sym->basetype; | |
| 1372 continue; | |
| 1373 } | |
| 1374 | |
| 1375 default: | |
| 336 | 1376 /* This can happen if errors, such as |
| 1377 * the type is painted on like in fromConstInitializer(). | |
| 1378 */ | |
| 1379 if (!global.errors) | |
| 1380 { type->print(); | |
| 1381 assert(0); | |
| 1382 } | |
| 159 | 1383 break; |
| 1384 } | |
| 1385 break; | |
| 1386 } | |
| 1387 return value; | |
| 1388 } | |
| 1389 | |
| 1390 real_t IntegerExp::toReal() | |
| 1391 { | |
| 1392 Type *t; | |
| 1393 | |
| 1394 toInteger(); | |
| 1395 t = type->toBasetype(); | |
| 1396 if (t->ty == Tuns64) | |
| 1397 return (real_t)(d_uns64)value; | |
| 1398 else | |
| 1399 return (real_t)(d_int64)value; | |
| 1400 } | |
| 1401 | |
| 1402 real_t IntegerExp::toImaginary() | |
| 1403 { | |
| 1404 return (real_t) 0; | |
| 1405 } | |
| 1406 | |
| 1407 complex_t IntegerExp::toComplex() | |
| 1408 { | |
| 1409 return toReal(); | |
| 1410 } | |
| 1411 | |
| 1412 int IntegerExp::isBool(int result) | |
| 1413 { | |
| 1414 return result ? value != 0 : value == 0; | |
| 1415 } | |
| 1416 | |
| 1417 Expression *IntegerExp::semantic(Scope *sc) | |
| 1418 { | |
| 1419 if (!type) | |
| 1420 { | |
| 1421 // Determine what the type of this number is | |
| 1422 integer_t number = value; | |
| 1423 | |
| 1424 if (number & 0x8000000000000000LL) | |
| 1425 type = Type::tuns64; | |
| 1426 else if (number & 0xFFFFFFFF80000000LL) | |
| 1427 type = Type::tint64; | |
| 1428 else | |
| 1429 type = Type::tint32; | |
| 1430 } | |
| 1431 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
|
1432 { 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
|
1433 type = type->semantic(loc, sc); |
| 159 | 1434 } |
| 1435 return this; | |
| 1436 } | |
| 1437 | |
| 1438 Expression *IntegerExp::toLvalue(Scope *sc, Expression *e) | |
| 1439 { | |
| 1440 if (!e) | |
| 1441 e = this; | |
| 1442 else if (!loc.filename) | |
| 1443 loc = e->loc; | |
| 1444 e->error("constant %s is not an lvalue", e->toChars()); | |
| 1445 return this; | |
| 1446 } | |
| 1447 | |
| 1448 void IntegerExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1449 { | |
| 1450 integer_t v = toInteger(); | |
| 1451 | |
| 1452 if (type) | |
| 1453 { Type *t = type; | |
| 1454 | |
| 1455 L1: | |
| 1456 switch (t->ty) | |
| 1457 { | |
| 1458 case Tenum: | |
| 1459 { TypeEnum *te = (TypeEnum *)t; | |
| 1460 buf->printf("cast(%s)", te->sym->toChars()); | |
| 1461 t = te->sym->memtype; | |
| 1462 goto L1; | |
| 1463 } | |
| 1464 | |
| 1465 case Ttypedef: | |
| 1466 { TypeTypedef *tt = (TypeTypedef *)t; | |
| 1467 buf->printf("cast(%s)", tt->sym->toChars()); | |
| 1468 t = tt->sym->basetype; | |
| 1469 goto L1; | |
| 1470 } | |
| 1471 | |
| 1472 case Twchar: // BUG: need to cast(wchar) | |
| 1473 case Tdchar: // BUG: need to cast(dchar) | |
| 1474 if ((uinteger_t)v > 0xFF) | |
| 1475 { | |
| 1476 buf->printf("'\\U%08x'", v); | |
| 1477 break; | |
| 1478 } | |
| 1479 case Tchar: | |
| 1480 if (v == '\'') | |
| 1481 buf->writestring("'\\''"); | |
| 1482 else if (isprint(v) && v != '\\') | |
| 1483 buf->printf("'%c'", (int)v); | |
| 1484 else | |
| 1485 buf->printf("'\\x%02x'", (int)v); | |
| 1486 break; | |
| 1487 | |
| 1488 case Tint8: | |
| 1489 buf->writestring("cast(byte)"); | |
| 1490 goto L2; | |
| 1491 | |
| 1492 case Tint16: | |
| 1493 buf->writestring("cast(short)"); | |
| 1494 goto L2; | |
| 1495 | |
| 1496 case Tint32: | |
| 1497 L2: | |
| 1498 buf->printf("%d", (int)v); | |
| 1499 break; | |
| 1500 | |
| 1501 case Tuns8: | |
| 1502 buf->writestring("cast(ubyte)"); | |
| 1503 goto L3; | |
| 1504 | |
| 1505 case Tuns16: | |
| 1506 buf->writestring("cast(ushort)"); | |
| 1507 goto L3; | |
| 1508 | |
| 1509 case Tuns32: | |
| 1510 L3: | |
| 1511 buf->printf("%du", (unsigned)v); | |
| 1512 break; | |
| 1513 | |
| 1514 case Tint64: | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1515 buf->printf("%jdL", v); |
| 159 | 1516 break; |
| 1517 | |
| 1518 case Tuns64: | |
|
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
|
1519 L4: |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1520 buf->printf("%juLU", v); |
| 159 | 1521 break; |
| 1522 | |
| 1523 case Tbit: | |
| 1524 case Tbool: | |
| 1525 buf->writestring((char *)(v ? "true" : "false")); | |
| 1526 break; | |
| 1527 | |
| 1528 case Tpointer: | |
| 1529 buf->writestring("cast("); | |
| 1530 buf->writestring(t->toChars()); | |
| 1531 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
|
1532 // FIXME: Other pointer widths than 32 and 64? |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1533 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
|
1534 goto L3; |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1535 else |
|
0d38fa5a0b46
Another "pointers are 32 bits" issue in the frontend. long/ulong constants cast
Frits van Bommel <fvbommel wxs.nl>
parents:
1103
diff
changeset
|
1536 goto L4; |
| 159 | 1537 |
| 1538 default: | |
| 336 | 1539 /* This can happen if errors, such as |
| 1540 * the type is painted on like in fromConstInitializer(). | |
| 1541 */ | |
| 1542 if (!global.errors) | |
| 1543 { | |
| 159 | 1544 #ifdef DEBUG |
| 336 | 1545 t->print(); |
| 159 | 1546 #endif |
| 336 | 1547 assert(0); |
| 1548 } | |
| 1549 break; | |
| 159 | 1550 } |
| 1551 } | |
| 1552 else if (v & 0x8000000000000000LL) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1553 buf->printf("0x%jx", v); |
| 159 | 1554 else |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1555 buf->printf("%jd", v); |
| 159 | 1556 } |
| 1557 | |
| 1558 void IntegerExp::toMangleBuffer(OutBuffer *buf) | |
| 1559 { | |
| 1560 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
|
1561 buf->printf("N%jd", -value); |
| 159 | 1562 else |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1563 buf->printf("%jd", value); |
| 159 | 1564 } |
| 1565 | |
| 1566 /******************************** RealExp **************************/ | |
| 1567 | |
| 1568 RealExp::RealExp(Loc loc, real_t value, Type *type) | |
| 1569 : Expression(loc, TOKfloat64, sizeof(RealExp)) | |
| 1570 { | |
| 1571 //printf("RealExp::RealExp(%Lg)\n", value); | |
| 1572 this->value = value; | |
| 1573 this->type = type; | |
| 1574 } | |
| 1575 | |
| 1576 char *RealExp::toChars() | |
| 1577 { | |
| 1578 char buffer[sizeof(value) * 3 + 8 + 1 + 1]; | |
| 1579 | |
| 1580 #ifdef IN_GCC | |
| 1581 value.format(buffer, sizeof(buffer)); | |
| 1582 if (type->isimaginary()) | |
| 1583 strcat(buffer, "i"); | |
| 1584 #else | |
| 1585 sprintf(buffer, type->isimaginary() ? "%Lgi" : "%Lg", value); | |
| 1586 #endif | |
| 1587 assert(strlen(buffer) < sizeof(buffer)); | |
| 1588 return mem.strdup(buffer); | |
| 1589 } | |
| 1590 | |
| 1591 integer_t RealExp::toInteger() | |
| 1592 { | |
| 1593 #ifdef IN_GCC | |
| 1594 return toReal().toInt(); | |
| 1595 #else | |
| 1596 return (sinteger_t) toReal(); | |
| 1597 #endif | |
| 1598 } | |
| 1599 | |
| 1600 uinteger_t RealExp::toUInteger() | |
| 1601 { | |
| 1602 #ifdef IN_GCC | |
| 1603 return (uinteger_t) toReal().toInt(); | |
| 1604 #else | |
| 1605 return (uinteger_t) toReal(); | |
| 1606 #endif | |
| 1607 } | |
| 1608 | |
| 1609 real_t RealExp::toReal() | |
| 1610 { | |
| 1611 return type->isreal() ? value : 0; | |
| 1612 } | |
| 1613 | |
| 1614 real_t RealExp::toImaginary() | |
| 1615 { | |
| 1616 return type->isreal() ? 0 : value; | |
| 1617 } | |
| 1618 | |
| 1619 complex_t RealExp::toComplex() | |
| 1620 { | |
| 1621 #ifdef __DMC__ | |
| 1622 return toReal() + toImaginary() * I; | |
| 1623 #else | |
| 1624 return complex_t(toReal(), toImaginary()); | |
| 1625 #endif | |
| 1626 } | |
| 1627 | |
| 1628 /******************************** | |
| 1629 * Test to see if two reals are the same. | |
| 1630 * Regard NaN's as equivalent. | |
| 1631 * Regard +0 and -0 as different. | |
| 1632 */ | |
| 1633 | |
| 1634 int RealEquals(real_t x1, real_t x2) | |
| 1635 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1636 #if __APPLE__ |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1637 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
|
1638 #else |
|
421
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1639 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
|
1640 (isnan(x1) && isnan(x2)) || |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1641 #endif |
|
421
1c65b5477eaa
Fix real comparison for real: allow +0 to be distinguished from -0.
Christian Kamm <kamm incasoftware de>
parents:
420
diff
changeset
|
1642 // 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
|
1643 (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
|
1644 // 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
|
1645 (x1 != 0. && x1 == x2); |
| 159 | 1646 } |
| 1647 | |
| 1648 int RealExp::equals(Object *o) | |
| 1649 { RealExp *ne; | |
| 1650 | |
| 1651 if (this == o || | |
| 1652 (((Expression *)o)->op == TOKfloat64 && | |
| 1653 ((ne = (RealExp *)o), type->equals(ne->type)) && | |
| 1654 RealEquals(value, ne->value) | |
| 1655 ) | |
| 1656 ) | |
| 1657 return 1; | |
| 1658 return 0; | |
| 1659 } | |
| 1660 | |
| 1661 Expression *RealExp::semantic(Scope *sc) | |
| 1662 { | |
| 1663 if (!type) | |
| 1664 type = Type::tfloat64; | |
| 1665 else | |
| 1666 type = type->semantic(loc, sc); | |
| 1667 return this; | |
| 1668 } | |
| 1669 | |
| 1670 int RealExp::isBool(int result) | |
| 1671 { | |
| 1672 #ifdef IN_GCC | |
| 1673 return result ? (! value.isZero()) : (value.isZero()); | |
| 1674 #else | |
| 1675 return result ? (value != 0) | |
| 1676 : (value == 0); | |
| 1677 #endif | |
| 1678 } | |
| 1679 | |
| 1680 void floatToBuffer(OutBuffer *buf, Type *type, real_t value) | |
| 1681 { | |
| 1682 /* In order to get an exact representation, try converting it | |
| 1683 * to decimal then back again. If it matches, use it. | |
| 1684 * If it doesn't, fall back to hex, which is | |
| 1685 * always exact. | |
| 1686 */ | |
| 1687 char buffer[25]; | |
| 1688 sprintf(buffer, "%Lg", value); | |
| 1689 assert(strlen(buffer) < sizeof(buffer)); | |
| 1690 #if _WIN32 && __DMC__ | |
| 1691 char *save = __locale_decpoint; | |
| 1692 __locale_decpoint = "."; | |
| 1693 real_t r = strtold(buffer, NULL); | |
| 1694 __locale_decpoint = save; | |
| 1695 #else | |
| 1696 real_t r = strtold(buffer, NULL); | |
| 1697 #endif | |
| 1698 if (r == value) // if exact duplication | |
| 1699 buf->writestring(buffer); | |
| 1700 else | |
| 1701 buf->printf("%La", value); // ensure exact duplication | |
| 1702 | |
| 1703 if (type) | |
| 1704 { | |
| 1705 Type *t = type->toBasetype(); | |
| 1706 switch (t->ty) | |
| 1707 { | |
| 1708 case Tfloat32: | |
| 1709 case Timaginary32: | |
| 1710 case Tcomplex32: | |
| 1711 buf->writeByte('F'); | |
| 1712 break; | |
| 1713 | |
| 1714 case Tfloat80: | |
| 1715 case Timaginary80: | |
| 1716 case Tcomplex80: | |
| 1717 buf->writeByte('L'); | |
| 1718 break; | |
| 1719 | |
| 1720 default: | |
| 1721 break; | |
| 1722 } | |
| 1723 if (t->isimaginary()) | |
| 1724 buf->writeByte('i'); | |
| 1725 } | |
| 1726 } | |
| 1727 | |
| 1728 void RealExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1729 { | |
| 1730 floatToBuffer(buf, type, value); | |
| 1731 } | |
| 1732 | |
| 1733 void realToMangleBuffer(OutBuffer *buf, real_t value) | |
| 1734 { | |
| 1735 /* Rely on %A to get portable mangling. | |
| 1736 * Must munge result to get only identifier characters. | |
| 1737 * | |
| 1738 * Possible values from %A => mangled result | |
| 1739 * NAN => NAN | |
| 1740 * -INF => NINF | |
| 1741 * INF => INF | |
| 1742 * -0X1.1BC18BA997B95P+79 => N11BC18BA997B95P79 | |
| 1743 * 0X1.9P+2 => 19P2 | |
| 1744 */ | |
| 1745 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1746 #if __APPLE__ |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1747 if (__inline_isnan(value)) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1748 #else |
| 159 | 1749 if (isnan(value)) |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
1750 #endif |
| 159 | 1751 buf->writestring("NAN"); // no -NAN bugs |
| 1752 else | |
| 1753 { | |
| 1754 char buffer[32]; | |
| 1755 int n = sprintf(buffer, "%LA", value); | |
| 1756 assert(n > 0 && n < sizeof(buffer)); | |
| 1757 for (int i = 0; i < n; i++) | |
| 1758 { char c = buffer[i]; | |
| 1759 | |
| 1760 switch (c) | |
| 1761 { | |
| 1762 case '-': | |
| 1763 buf->writeByte('N'); | |
| 1764 break; | |
| 1765 | |
| 1766 case '+': | |
| 1767 case 'X': | |
| 1768 case '.': | |
| 1769 break; | |
| 1770 | |
| 1771 case '0': | |
| 1772 if (i < 2) | |
| 1773 break; // skip leading 0X | |
| 1774 default: | |
| 1775 buf->writeByte(c); | |
| 1776 break; | |
| 1777 } | |
| 1778 } | |
| 1779 } | |
| 1780 } | |
| 1781 | |
| 1782 void RealExp::toMangleBuffer(OutBuffer *buf) | |
| 1783 { | |
| 1784 buf->writeByte('e'); | |
| 1785 realToMangleBuffer(buf, value); | |
| 1786 } | |
| 1787 | |
| 1788 | |
| 1789 /******************************** ComplexExp **************************/ | |
| 1790 | |
| 1791 ComplexExp::ComplexExp(Loc loc, complex_t value, Type *type) | |
| 1792 : Expression(loc, TOKcomplex80, sizeof(ComplexExp)) | |
| 1793 { | |
| 1794 this->value = value; | |
| 1795 this->type = type; | |
| 1796 //printf("ComplexExp::ComplexExp(%s)\n", toChars()); | |
| 1797 } | |
| 1798 | |
| 1799 char *ComplexExp::toChars() | |
| 1800 { | |
| 1801 char buffer[sizeof(value) * 3 + 8 + 1]; | |
| 1802 | |
| 1803 #ifdef IN_GCC | |
| 1804 char buf1[sizeof(value) * 3 + 8 + 1]; | |
| 1805 char buf2[sizeof(value) * 3 + 8 + 1]; | |
| 1806 creall(value).format(buf1, sizeof(buf1)); | |
| 1807 cimagl(value).format(buf2, sizeof(buf2)); | |
| 1808 sprintf(buffer, "(%s+%si)", buf1, buf2); | |
| 1809 #else | |
| 1810 sprintf(buffer, "(%Lg+%Lgi)", creall(value), cimagl(value)); | |
| 1811 assert(strlen(buffer) < sizeof(buffer)); | |
| 1812 #endif | |
| 1813 return mem.strdup(buffer); | |
| 1814 } | |
| 1815 | |
| 1816 integer_t ComplexExp::toInteger() | |
| 1817 { | |
| 1818 #ifdef IN_GCC | |
| 1819 return (sinteger_t) toReal().toInt(); | |
| 1820 #else | |
| 1821 return (sinteger_t) toReal(); | |
| 1822 #endif | |
| 1823 } | |
| 1824 | |
| 1825 uinteger_t ComplexExp::toUInteger() | |
| 1826 { | |
| 1827 #ifdef IN_GCC | |
| 1828 return (uinteger_t) toReal().toInt(); | |
| 1829 #else | |
| 1830 return (uinteger_t) toReal(); | |
| 1831 #endif | |
| 1832 } | |
| 1833 | |
| 1834 real_t ComplexExp::toReal() | |
| 1835 { | |
| 1836 return creall(value); | |
| 1837 } | |
| 1838 | |
| 1839 real_t ComplexExp::toImaginary() | |
| 1840 { | |
| 1841 return cimagl(value); | |
| 1842 } | |
| 1843 | |
| 1844 complex_t ComplexExp::toComplex() | |
| 1845 { | |
| 1846 return value; | |
| 1847 } | |
| 1848 | |
| 1849 int ComplexExp::equals(Object *o) | |
| 1850 { ComplexExp *ne; | |
| 1851 | |
| 1852 if (this == o || | |
| 1853 (((Expression *)o)->op == TOKcomplex80 && | |
| 1854 ((ne = (ComplexExp *)o), type->equals(ne->type)) && | |
| 1855 RealEquals(creall(value), creall(ne->value)) && | |
| 1856 RealEquals(cimagl(value), cimagl(ne->value)) | |
| 1857 ) | |
| 1858 ) | |
| 1859 return 1; | |
| 1860 return 0; | |
| 1861 } | |
| 1862 | |
| 1863 Expression *ComplexExp::semantic(Scope *sc) | |
| 1864 { | |
| 1865 if (!type) | |
| 1866 type = Type::tcomplex80; | |
| 1867 else | |
| 1868 type = type->semantic(loc, sc); | |
| 1869 return this; | |
| 1870 } | |
| 1871 | |
| 1872 int ComplexExp::isBool(int result) | |
| 1873 { | |
| 1874 if (result) | |
| 1875 return (bool)(value); | |
| 1876 else | |
| 1877 return !value; | |
| 1878 } | |
| 1879 | |
| 1880 void ComplexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1881 { | |
| 1882 /* Print as: | |
| 1883 * (re+imi) | |
| 1884 */ | |
| 1885 #ifdef IN_GCC | |
| 1886 char buf1[sizeof(value) * 3 + 8 + 1]; | |
| 1887 char buf2[sizeof(value) * 3 + 8 + 1]; | |
| 1888 creall(value).format(buf1, sizeof(buf1)); | |
| 1889 cimagl(value).format(buf2, sizeof(buf2)); | |
| 1890 buf->printf("(%s+%si)", buf1, buf2); | |
| 1891 #else | |
| 1892 buf->writeByte('('); | |
| 1893 floatToBuffer(buf, type, creall(value)); | |
| 1894 buf->writeByte('+'); | |
| 1895 floatToBuffer(buf, type, cimagl(value)); | |
| 1896 buf->writestring("i)"); | |
| 1897 #endif | |
| 1898 } | |
| 1899 | |
| 1900 void ComplexExp::toMangleBuffer(OutBuffer *buf) | |
| 1901 { | |
| 1902 buf->writeByte('c'); | |
| 1903 real_t r = toReal(); | |
| 1904 realToMangleBuffer(buf, r); | |
| 1905 buf->writeByte('c'); // separate the two | |
| 1906 r = toImaginary(); | |
| 1907 realToMangleBuffer(buf, r); | |
| 1908 } | |
| 1909 | |
| 1910 /******************************** IdentifierExp **************************/ | |
| 1911 | |
| 1912 IdentifierExp::IdentifierExp(Loc loc, Identifier *ident) | |
| 1913 : Expression(loc, TOKidentifier, sizeof(IdentifierExp)) | |
| 1914 { | |
| 1915 this->ident = ident; | |
| 1916 } | |
| 1917 | |
| 1918 Expression *IdentifierExp::semantic(Scope *sc) | |
| 1919 { | |
| 1920 Dsymbol *s; | |
| 1921 Dsymbol *scopesym; | |
| 1922 | |
| 1923 #if LOGSEMANTIC | |
| 1924 printf("IdentifierExp::semantic('%s')\n", ident->toChars()); | |
| 1925 #endif | |
| 1926 s = sc->search(loc, ident, &scopesym); | |
| 1927 if (s) | |
| 1928 { Expression *e; | |
| 1929 WithScopeSymbol *withsym; | |
| 1930 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
1931 /* 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
|
1932 */ |
| 159 | 1933 withsym = scopesym->isWithScopeSymbol(); |
| 1934 if (withsym) | |
| 1935 { | |
| 1936 s = s->toAlias(); | |
| 1937 | |
| 1938 // Same as wthis.ident | |
| 1939 if (s->needThis() || s->isTemplateDeclaration()) | |
| 1940 { | |
| 1941 e = new VarExp(loc, withsym->withstate->wthis); | |
| 1942 e = new DotIdExp(loc, e, ident); | |
| 1943 } | |
| 1944 else | |
| 1945 { Type *t = withsym->withstate->wthis->type; | |
| 1946 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
|
1947 t = ((TypePointer *)t)->next; |
| 159 | 1948 e = new TypeDotIdExp(loc, t, ident); |
| 1949 } | |
| 1950 } | |
| 1951 else | |
| 1952 { | |
| 1953 if (!s->parent && scopesym->isArrayScopeSymbol()) | |
| 1954 { // Kludge to run semantic() here because | |
| 1955 // ArrayScopeSymbol::search() doesn't have access to sc. | |
| 1956 s->semantic(sc); | |
| 1957 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1958 /* If f is really a function template, |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
1959 * 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
|
1960 */ |
| 159 | 1961 FuncDeclaration *f = s->isFuncDeclaration(); |
| 1962 if (f && f->parent) | |
| 1963 { TemplateInstance *ti = f->parent->isTemplateInstance(); | |
| 1964 | |
| 1965 if (ti && | |
| 1966 !ti->isTemplateMixin() && | |
| 1967 (ti->name == f->ident || | |
| 1968 ti->toAlias()->ident == f->ident) | |
| 1969 && | |
| 1970 ti->tempdecl && ti->tempdecl->onemember) | |
| 1971 { | |
| 1972 TemplateDeclaration *tempdecl = ti->tempdecl; | |
| 1973 if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's | |
| 1974 tempdecl = tempdecl->overroot; // then get the start | |
| 1975 e = new TemplateExp(loc, tempdecl); | |
| 1976 e = e->semantic(sc); | |
| 1977 return e; | |
| 1978 } | |
| 1979 } | |
| 1980 e = new DsymbolExp(loc, s); | |
| 1981 } | |
| 1982 return e->semantic(sc); | |
| 1983 } | |
| 1984 error("undefined identifier %s", ident->toChars()); | |
| 1985 type = Type::terror; | |
| 1986 return this; | |
| 1987 } | |
| 1988 | |
| 1989 char *IdentifierExp::toChars() | |
| 1990 { | |
| 1991 return ident->toChars(); | |
| 1992 } | |
| 1993 | |
| 1994 void IdentifierExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 1995 { | |
| 1996 if (hgs->hdrgen) | |
| 1997 buf->writestring(ident->toHChars2()); | |
| 1998 else | |
| 1999 buf->writestring(ident->toChars()); | |
| 2000 } | |
| 2001 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2002 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2003 int IdentifierExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2004 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2005 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2006 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2007 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2008 |
| 159 | 2009 Expression *IdentifierExp::toLvalue(Scope *sc, Expression *e) |
| 2010 { | |
| 2011 #if 0 | |
| 2012 tym = tybasic(e1->ET->Tty); | |
| 2013 if (!(tyscalar(tym) || | |
| 2014 tym == TYstruct || | |
| 2015 tym == TYarray && e->Eoper == TOKaddr)) | |
| 2016 synerr(EM_lvalue); // lvalue expected | |
| 2017 #endif | |
| 2018 return this; | |
| 2019 } | |
| 2020 | |
| 2021 /******************************** DollarExp **************************/ | |
| 2022 | |
| 2023 DollarExp::DollarExp(Loc loc) | |
| 2024 : IdentifierExp(loc, Id::dollar) | |
| 2025 { | |
| 2026 } | |
| 2027 | |
| 2028 /******************************** DsymbolExp **************************/ | |
| 2029 | |
| 2030 DsymbolExp::DsymbolExp(Loc loc, Dsymbol *s) | |
| 2031 : Expression(loc, TOKdsymbol, sizeof(DsymbolExp)) | |
| 2032 { | |
| 2033 this->s = s; | |
| 2034 } | |
| 2035 | |
| 2036 Expression *DsymbolExp::semantic(Scope *sc) | |
| 2037 { | |
| 2038 #if LOGSEMANTIC | |
| 2039 printf("DsymbolExp::semantic('%s')\n", s->toChars()); | |
| 2040 #endif | |
| 2041 | |
| 2042 Lagain: | |
| 2043 EnumMember *em; | |
| 2044 Expression *e; | |
| 2045 VarDeclaration *v; | |
| 2046 FuncDeclaration *f; | |
| 2047 FuncLiteralDeclaration *fld; | |
| 2048 Declaration *d; | |
| 2049 ClassDeclaration *cd; | |
| 2050 ClassDeclaration *thiscd = NULL; | |
| 2051 Import *imp; | |
| 2052 Package *pkg; | |
| 2053 Type *t; | |
| 2054 | |
| 2055 //printf("DsymbolExp:: %p '%s' is a symbol\n", this, toChars()); | |
| 2056 //printf("s = '%s', s->kind = '%s'\n", s->toChars(), s->kind()); | |
| 2057 if (type) | |
| 2058 return this; | |
| 2059 if (!s->isFuncDeclaration()) // functions are checked after overloading | |
| 2060 checkDeprecated(sc, s); | |
| 2061 s = s->toAlias(); | |
| 2062 //printf("s = '%s', s->kind = '%s', s->needThis() = %p\n", s->toChars(), s->kind(), s->needThis()); | |
| 2063 if (!s->isFuncDeclaration()) | |
| 2064 checkDeprecated(sc, s); | |
| 2065 | |
| 2066 if (sc->func) | |
| 2067 thiscd = sc->func->parent->isClassDeclaration(); | |
| 2068 | |
| 2069 // BUG: This should happen after overload resolution for functions, not before | |
| 2070 if (s->needThis()) | |
| 2071 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2072 if (hasThis(sc) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2073 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2074 && !s->isFuncDeclaration() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2075 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2076 ) |
| 159 | 2077 { |
| 2078 // Supply an implicit 'this', as in | |
| 2079 // this.ident | |
| 2080 | |
| 2081 DotVarExp *de; | |
| 2082 | |
| 2083 de = new DotVarExp(loc, new ThisExp(loc), s->isDeclaration()); | |
| 2084 return de->semantic(sc); | |
| 2085 } | |
| 2086 } | |
| 2087 | |
| 2088 em = s->isEnumMember(); | |
| 2089 if (em) | |
| 2090 { | |
| 2091 e = em->value->copy(); | |
| 2092 e = e->semantic(sc); | |
| 2093 return e; | |
| 2094 } | |
| 2095 v = s->isVarDeclaration(); | |
| 2096 if (v) | |
| 2097 { | |
| 2098 //printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); | |
| 2099 if (!type) | |
| 2100 { type = v->type; | |
| 2101 if (!v->type) | |
| 2102 { error("forward reference of %s", v->toChars()); | |
| 2103 type = Type::terror; | |
| 2104 } | |
| 2105 } | |
| 2106 if (v->isConst() && type->toBasetype()->ty != Tsarray) | |
| 2107 { | |
| 2108 if (v->init) | |
| 2109 { | |
| 2110 if (v->inuse) | |
| 2111 { | |
| 2112 error("circular reference to '%s'", v->toChars()); | |
| 2113 type = Type::tint32; | |
| 2114 return this; | |
| 2115 } | |
| 2116 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 2117 if (ei) | |
| 2118 { | |
| 2119 e = ei->exp->copy(); // make copy so we can change loc | |
| 2120 if (e->op == TOKstring || !e->type) | |
| 2121 e = e->semantic(sc); | |
| 2122 e = e->implicitCastTo(sc, type); | |
| 2123 e->loc = loc; | |
| 2124 return e; | |
| 2125 } | |
| 2126 } | |
| 2127 else | |
| 2128 { | |
| 2129 e = type->defaultInit(); | |
| 2130 e->loc = loc; | |
| 2131 return e; | |
| 2132 } | |
| 2133 } | |
| 2134 e = new VarExp(loc, v); | |
| 2135 e->type = type; | |
| 2136 e = e->semantic(sc); | |
| 2137 return e->deref(); | |
| 2138 } | |
| 2139 fld = s->isFuncLiteralDeclaration(); | |
| 2140 if (fld) | |
| 2141 { //printf("'%s' is a function literal\n", fld->toChars()); | |
| 2142 e = new FuncExp(loc, fld); | |
| 2143 return e->semantic(sc); | |
| 2144 } | |
| 2145 f = s->isFuncDeclaration(); | |
| 2146 if (f) | |
| 2147 { //printf("'%s' is a function\n", f->toChars()); | |
| 2148 return new VarExp(loc, f); | |
| 2149 } | |
| 2150 cd = s->isClassDeclaration(); | |
| 2151 if (cd && thiscd && cd->isBaseOf(thiscd, NULL) && sc->func->needThis()) | |
| 2152 { | |
| 2153 // We need to add an implicit 'this' if cd is this class or a base class. | |
| 2154 DotTypeExp *dte; | |
| 2155 | |
| 2156 dte = new DotTypeExp(loc, new ThisExp(loc), s); | |
| 2157 return dte->semantic(sc); | |
| 2158 } | |
| 2159 imp = s->isImport(); | |
| 2160 if (imp) | |
| 2161 { | |
| 2162 ScopeExp *ie; | |
| 2163 | |
| 2164 ie = new ScopeExp(loc, imp->pkg); | |
| 2165 return ie->semantic(sc); | |
| 2166 } | |
| 2167 pkg = s->isPackage(); | |
| 2168 if (pkg) | |
| 2169 { | |
| 2170 ScopeExp *ie; | |
| 2171 | |
| 2172 ie = new ScopeExp(loc, pkg); | |
| 2173 return ie->semantic(sc); | |
| 2174 } | |
| 2175 Module *mod = s->isModule(); | |
| 2176 if (mod) | |
| 2177 { | |
| 2178 ScopeExp *ie; | |
| 2179 | |
| 2180 ie = new ScopeExp(loc, mod); | |
| 2181 return ie->semantic(sc); | |
| 2182 } | |
| 2183 | |
| 2184 t = s->getType(); | |
| 2185 if (t) | |
| 2186 { | |
| 2187 return new TypeExp(loc, t); | |
| 2188 } | |
| 2189 | |
| 2190 TupleDeclaration *tup = s->isTupleDeclaration(); | |
| 2191 if (tup) | |
| 2192 { | |
| 2193 e = new TupleExp(loc, tup); | |
| 2194 e = e->semantic(sc); | |
| 2195 return e; | |
| 2196 } | |
| 2197 | |
| 2198 TemplateInstance *ti = s->isTemplateInstance(); | |
| 2199 if (ti && !global.errors) | |
| 2200 { if (!ti->semanticdone) | |
| 2201 ti->semantic(sc); | |
| 2202 s = ti->inst->toAlias(); | |
| 2203 if (!s->isTemplateInstance()) | |
| 2204 goto Lagain; | |
| 2205 e = new ScopeExp(loc, ti); | |
| 2206 e = e->semantic(sc); | |
| 2207 return e; | |
| 2208 } | |
| 2209 | |
| 2210 TemplateDeclaration *td = s->isTemplateDeclaration(); | |
| 2211 if (td) | |
| 2212 { | |
| 2213 e = new TemplateExp(loc, td); | |
| 2214 e = e->semantic(sc); | |
| 2215 return e; | |
| 2216 } | |
| 2217 | |
| 2218 Lerr: | |
| 2219 error("%s '%s' is not a variable", s->kind(), s->toChars()); | |
| 2220 type = Type::terror; | |
| 2221 return this; | |
| 2222 } | |
| 2223 | |
| 2224 char *DsymbolExp::toChars() | |
| 2225 { | |
| 2226 return s->toChars(); | |
| 2227 } | |
| 2228 | |
| 2229 void DsymbolExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2230 { | |
| 2231 buf->writestring(s->toChars()); | |
| 2232 } | |
| 2233 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2234 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2235 int DsymbolExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2236 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2237 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2238 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2239 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2240 |
| 159 | 2241 Expression *DsymbolExp::toLvalue(Scope *sc, Expression *e) |
| 2242 { | |
| 2243 #if 0 | |
| 2244 tym = tybasic(e1->ET->Tty); | |
| 2245 if (!(tyscalar(tym) || | |
| 2246 tym == TYstruct || | |
| 2247 tym == TYarray && e->Eoper == TOKaddr)) | |
| 2248 synerr(EM_lvalue); // lvalue expected | |
| 2249 #endif | |
| 2250 return this; | |
| 2251 } | |
| 2252 | |
| 2253 /******************************** ThisExp **************************/ | |
| 2254 | |
| 2255 ThisExp::ThisExp(Loc loc) | |
| 2256 : Expression(loc, TOKthis, sizeof(ThisExp)) | |
| 2257 { | |
| 2258 var = NULL; | |
| 2259 } | |
| 2260 | |
| 2261 Expression *ThisExp::semantic(Scope *sc) | |
| 2262 { FuncDeclaration *fd; | |
| 2263 FuncDeclaration *fdthis; | |
| 2264 int nested = 0; | |
| 2265 | |
| 2266 #if LOGSEMANTIC | |
| 2267 printf("ThisExp::semantic()\n"); | |
| 2268 #endif | |
| 2269 if (type) | |
| 2270 { //assert(global.errors || var); | |
| 2271 return this; | |
| 2272 } | |
| 2273 | |
| 2274 /* Special case for typeof(this) and typeof(super) since both | |
| 2275 * should work even if they are not inside a non-static member function | |
| 2276 */ | |
| 2277 if (sc->intypeof) | |
| 2278 { | |
| 2279 // Find enclosing struct or class | |
| 2280 for (Dsymbol *s = sc->parent; 1; s = s->parent) | |
| 2281 { | |
| 2282 ClassDeclaration *cd; | |
| 2283 StructDeclaration *sd; | |
| 2284 | |
| 2285 if (!s) | |
| 2286 { | |
| 2287 error("%s is not in a struct or class scope", toChars()); | |
| 2288 goto Lerr; | |
| 2289 } | |
| 2290 cd = s->isClassDeclaration(); | |
| 2291 if (cd) | |
| 2292 { | |
| 2293 type = cd->type; | |
| 2294 return this; | |
| 2295 } | |
| 2296 sd = s->isStructDeclaration(); | |
| 2297 if (sd) | |
| 2298 { | |
| 2299 type = sd->type->pointerTo(); | |
| 2300 return this; | |
| 2301 } | |
| 2302 } | |
| 2303 } | |
| 2304 | |
| 2305 fdthis = sc->parent->isFuncDeclaration(); | |
| 2306 fd = hasThis(sc); // fd is the uplevel function with the 'this' variable | |
| 2307 if (!fd) | |
| 2308 goto Lerr; | |
| 2309 | |
| 2310 assert(fd->vthis); | |
| 2311 var = fd->vthis; | |
| 2312 assert(var->parent); | |
| 2313 type = var->type; | |
| 2314 var->isVarDeclaration()->checkNestedReference(sc, loc); | |
| 2315 #if 0 | |
| 2316 if (fd != fdthis) // if nested | |
| 2317 { | |
| 2318 fdthis->getLevel(loc, fd); | |
| 2319 fd->vthis->nestedref = 1; | |
| 2320 fd->nestedFrameRef = 1; | |
| 2321 } | |
| 2322 #endif | |
| 336 | 2323 if (!sc->intypeof) |
| 2324 sc->callSuper |= CSXthis; | |
| 159 | 2325 return this; |
| 2326 | |
| 2327 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
|
2328 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
|
2329 type = Type::terror; |
| 159 | 2330 return this; |
| 2331 } | |
| 2332 | |
| 2333 int ThisExp::isBool(int result) | |
| 2334 { | |
| 2335 return result ? TRUE : FALSE; | |
| 2336 } | |
| 2337 | |
| 2338 void ThisExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2339 { | |
| 2340 buf->writestring("this"); | |
| 2341 } | |
| 2342 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2343 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2344 int ThisExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2345 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2346 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2347 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2348 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2349 |
| 159 | 2350 Expression *ThisExp::toLvalue(Scope *sc, Expression *e) |
| 2351 { | |
| 2352 return this; | |
| 2353 } | |
| 2354 | |
| 2355 /******************************** SuperExp **************************/ | |
| 2356 | |
| 2357 SuperExp::SuperExp(Loc loc) | |
| 2358 : ThisExp(loc) | |
| 2359 { | |
| 2360 op = TOKsuper; | |
| 2361 } | |
| 2362 | |
| 2363 Expression *SuperExp::semantic(Scope *sc) | |
| 2364 { FuncDeclaration *fd; | |
| 2365 FuncDeclaration *fdthis; | |
| 2366 ClassDeclaration *cd; | |
| 2367 Dsymbol *s; | |
| 2368 | |
| 2369 #if LOGSEMANTIC | |
| 2370 printf("SuperExp::semantic('%s')\n", toChars()); | |
| 2371 #endif | |
| 2372 if (type) | |
| 2373 return this; | |
| 2374 | |
| 2375 /* Special case for typeof(this) and typeof(super) since both | |
| 2376 * should work even if they are not inside a non-static member function | |
| 2377 */ | |
| 2378 if (sc->intypeof) | |
| 2379 { | |
| 2380 // Find enclosing class | |
| 2381 for (Dsymbol *s = sc->parent; 1; s = s->parent) | |
| 2382 { | |
| 2383 ClassDeclaration *cd; | |
| 2384 | |
| 2385 if (!s) | |
| 2386 { | |
| 2387 error("%s is not in a class scope", toChars()); | |
| 2388 goto Lerr; | |
| 2389 } | |
| 2390 cd = s->isClassDeclaration(); | |
| 2391 if (cd) | |
| 2392 { | |
| 2393 cd = cd->baseClass; | |
| 2394 if (!cd) | |
| 2395 { error("class %s has no 'super'", s->toChars()); | |
| 2396 goto Lerr; | |
| 2397 } | |
| 2398 type = cd->type; | |
| 2399 return this; | |
| 2400 } | |
| 2401 } | |
| 2402 } | |
| 2403 | |
| 2404 fdthis = sc->parent->isFuncDeclaration(); | |
| 2405 fd = hasThis(sc); | |
| 2406 if (!fd) | |
| 2407 goto Lerr; | |
| 2408 assert(fd->vthis); | |
| 2409 var = fd->vthis; | |
| 2410 assert(var->parent); | |
| 2411 | |
| 2412 s = fd->toParent(); | |
| 2413 while (s && s->isTemplateInstance()) | |
| 2414 s = s->toParent(); | |
| 2415 assert(s); | |
| 2416 cd = s->isClassDeclaration(); | |
| 2417 //printf("parent is %s %s\n", fd->toParent()->kind(), fd->toParent()->toChars()); | |
| 2418 if (!cd) | |
| 2419 goto Lerr; | |
| 2420 if (!cd->baseClass) | |
| 2421 { | |
| 2422 error("no base class for %s", cd->toChars()); | |
| 2423 type = fd->vthis->type; | |
| 2424 } | |
| 2425 else | |
| 2426 { | |
| 2427 type = cd->baseClass->type; | |
| 2428 } | |
| 2429 | |
| 2430 var->isVarDeclaration()->checkNestedReference(sc, loc); | |
| 2431 #if 0 | |
| 2432 if (fd != fdthis) | |
| 2433 { | |
| 2434 fdthis->getLevel(loc, fd); | |
| 2435 fd->vthis->nestedref = 1; | |
| 2436 fd->nestedFrameRef = 1; | |
| 2437 } | |
| 2438 #endif | |
| 2439 | |
| 336 | 2440 if (!sc->intypeof) |
| 2441 sc->callSuper |= CSXsuper; | |
| 159 | 2442 return this; |
| 2443 | |
| 2444 | |
| 2445 Lerr: | |
| 2446 error("'super' is only allowed in non-static class member functions"); | |
| 2447 type = Type::tint32; | |
| 2448 return this; | |
| 2449 } | |
| 2450 | |
| 2451 void SuperExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2452 { | |
| 2453 buf->writestring("super"); | |
| 2454 } | |
| 2455 | |
| 2456 | |
| 2457 /******************************** NullExp **************************/ | |
| 2458 | |
| 2459 NullExp::NullExp(Loc loc) | |
| 2460 : Expression(loc, TOKnull, sizeof(NullExp)) | |
| 2461 { | |
| 2462 committed = 0; | |
| 2463 } | |
| 2464 | |
| 2465 Expression *NullExp::semantic(Scope *sc) | |
| 2466 { | |
| 2467 #if LOGSEMANTIC | |
| 2468 printf("NullExp::semantic('%s')\n", toChars()); | |
| 2469 #endif | |
| 2470 // NULL is the same as (void *)0 | |
| 2471 if (!type) | |
| 2472 type = Type::tvoid->pointerTo(); | |
| 2473 return this; | |
| 2474 } | |
| 2475 | |
| 2476 int NullExp::isBool(int result) | |
| 2477 { | |
| 2478 return result ? FALSE : TRUE; | |
| 2479 } | |
| 2480 | |
| 2481 void NullExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2482 { | |
| 2483 buf->writestring("null"); | |
| 2484 } | |
| 2485 | |
| 2486 void NullExp::toMangleBuffer(OutBuffer *buf) | |
| 2487 { | |
| 2488 buf->writeByte('n'); | |
| 2489 } | |
| 2490 | |
| 2491 /******************************** StringExp **************************/ | |
| 2492 | |
| 2493 StringExp::StringExp(Loc loc, char *string) | |
| 2494 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2495 { | |
| 2496 this->string = string; | |
| 2497 this->len = strlen(string); | |
| 2498 this->sz = 1; | |
| 2499 this->committed = 0; | |
| 2500 this->postfix = 0; | |
| 2501 } | |
| 2502 | |
| 2503 StringExp::StringExp(Loc loc, void *string, size_t len) | |
| 2504 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2505 { | |
| 2506 this->string = string; | |
| 2507 this->len = len; | |
| 2508 this->sz = 1; | |
| 2509 this->committed = 0; | |
| 2510 this->postfix = 0; | |
| 2511 } | |
| 2512 | |
| 2513 StringExp::StringExp(Loc loc, void *string, size_t len, unsigned char postfix) | |
| 2514 : Expression(loc, TOKstring, sizeof(StringExp)) | |
| 2515 { | |
| 2516 this->string = string; | |
| 2517 this->len = len; | |
| 2518 this->sz = 1; | |
| 2519 this->committed = 0; | |
| 2520 this->postfix = postfix; | |
| 2521 } | |
| 2522 | |
| 2523 #if 0 | |
| 2524 Expression *StringExp::syntaxCopy() | |
| 2525 { | |
| 2526 printf("StringExp::syntaxCopy() %s\n", toChars()); | |
| 2527 return copy(); | |
| 2528 } | |
| 2529 #endif | |
| 2530 | |
| 2531 int StringExp::equals(Object *o) | |
| 2532 { | |
| 2533 //printf("StringExp::equals('%s')\n", o->toChars()); | |
| 2534 if (o && o->dyncast() == DYNCAST_EXPRESSION) | |
| 2535 { Expression *e = (Expression *)o; | |
| 2536 | |
| 2537 if (e->op == TOKstring) | |
| 2538 { | |
| 2539 return compare(o) == 0; | |
| 2540 } | |
| 2541 } | |
| 2542 return FALSE; | |
| 2543 } | |
| 2544 | |
| 2545 char *StringExp::toChars() | |
| 2546 { | |
| 2547 OutBuffer buf; | |
| 2548 HdrGenState hgs; | |
| 2549 char *p; | |
| 2550 | |
| 2551 memset(&hgs, 0, sizeof(hgs)); | |
| 2552 toCBuffer(&buf, &hgs); | |
| 2553 buf.writeByte(0); | |
| 2554 p = (char *)buf.data; | |
| 2555 buf.data = NULL; | |
| 2556 return p; | |
| 2557 } | |
| 2558 | |
| 2559 Expression *StringExp::semantic(Scope *sc) | |
| 2560 { | |
| 2561 #if LOGSEMANTIC | |
| 2562 printf("StringExp::semantic() %s\n", toChars()); | |
| 2563 #endif | |
| 2564 if (!type) | |
| 2565 { OutBuffer buffer; | |
| 2566 size_t newlen = 0; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2567 const char *p; |
| 159 | 2568 size_t u; |
| 2569 unsigned c; | |
| 2570 | |
| 2571 switch (postfix) | |
| 2572 { | |
| 2573 case 'd': | |
| 2574 for (u = 0; u < len;) | |
| 2575 { | |
| 2576 p = utf_decodeChar((unsigned char *)string, len, &u, &c); | |
| 2577 if (p) | |
| 2578 { error("%s", p); | |
| 2579 break; | |
| 2580 } | |
| 2581 else | |
| 2582 { buffer.write4(c); | |
| 2583 newlen++; | |
| 2584 } | |
| 2585 } | |
| 2586 buffer.write4(0); | |
| 2587 string = buffer.extractData(); | |
| 2588 len = newlen; | |
| 2589 sz = 4; | |
| 2590 type = new TypeSArray(Type::tdchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2591 committed = 1; | |
| 2592 break; | |
| 2593 | |
| 2594 case 'w': | |
| 2595 for (u = 0; u < len;) | |
| 2596 { | |
| 2597 p = utf_decodeChar((unsigned char *)string, len, &u, &c); | |
| 2598 if (p) | |
| 2599 { error("%s", p); | |
| 2600 break; | |
| 2601 } | |
| 2602 else | |
| 2603 { buffer.writeUTF16(c); | |
| 2604 newlen++; | |
| 2605 if (c >= 0x10000) | |
| 2606 newlen++; | |
| 2607 } | |
| 2608 } | |
| 2609 buffer.writeUTF16(0); | |
| 2610 string = buffer.extractData(); | |
| 2611 len = newlen; | |
| 2612 sz = 2; | |
| 2613 type = new TypeSArray(Type::twchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2614 committed = 1; | |
| 2615 break; | |
| 2616 | |
| 2617 case 'c': | |
| 2618 committed = 1; | |
| 2619 default: | |
| 2620 type = new TypeSArray(Type::tchar, new IntegerExp(loc, len, Type::tindex)); | |
| 2621 break; | |
| 2622 } | |
| 2623 type = type->semantic(loc, sc); | |
| 2624 } | |
| 2625 return this; | |
| 2626 } | |
| 2627 | |
| 2628 /**************************************** | |
| 2629 * Convert string to char[]. | |
| 2630 */ | |
| 2631 | |
| 2632 StringExp *StringExp::toUTF8(Scope *sc) | |
| 2633 { | |
| 2634 if (sz != 1) | |
| 2635 { // Convert to UTF-8 string | |
| 2636 committed = 0; | |
| 2637 Expression *e = castTo(sc, Type::tchar->arrayOf()); | |
| 2638 e = e->optimize(WANTvalue); | |
| 2639 assert(e->op == TOKstring); | |
| 2640 StringExp *se = (StringExp *)e; | |
| 2641 assert(se->sz == 1); | |
| 2642 return se; | |
| 2643 } | |
| 2644 return this; | |
| 2645 } | |
| 2646 | |
| 2647 int StringExp::compare(Object *obj) | |
| 2648 { | |
| 2649 // Used to sort case statement expressions so we can do an efficient lookup | |
| 2650 StringExp *se2 = (StringExp *)(obj); | |
| 2651 | |
| 2652 // This is a kludge so isExpression() in template.c will return 5 | |
| 2653 // for StringExp's. | |
| 2654 if (!se2) | |
| 2655 return 5; | |
| 2656 | |
| 2657 assert(se2->op == TOKstring); | |
| 2658 | |
| 2659 int len1 = len; | |
| 2660 int len2 = se2->len; | |
| 2661 | |
| 2662 if (len1 == len2) | |
| 2663 { | |
| 2664 switch (sz) | |
| 2665 { | |
| 2666 case 1: | |
| 2667 return strcmp((char *)string, (char *)se2->string); | |
| 2668 | |
| 2669 case 2: | |
| 2670 { unsigned u; | |
| 2671 d_wchar *s1 = (d_wchar *)string; | |
| 2672 d_wchar *s2 = (d_wchar *)se2->string; | |
| 2673 | |
| 2674 for (u = 0; u < len; u++) | |
| 2675 { | |
| 2676 if (s1[u] != s2[u]) | |
| 2677 return s1[u] - s2[u]; | |
| 2678 } | |
| 2679 } | |
| 2680 | |
| 2681 case 4: | |
| 2682 { unsigned u; | |
| 2683 d_dchar *s1 = (d_dchar *)string; | |
| 2684 d_dchar *s2 = (d_dchar *)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 break; | |
| 2693 | |
| 2694 default: | |
| 2695 assert(0); | |
| 2696 } | |
| 2697 } | |
| 2698 return len1 - len2; | |
| 2699 } | |
| 2700 | |
| 2701 int StringExp::isBool(int result) | |
| 2702 { | |
| 2703 return result ? TRUE : FALSE; | |
| 2704 } | |
| 2705 | |
| 2706 unsigned StringExp::charAt(size_t i) | |
| 2707 { unsigned value; | |
| 2708 | |
| 2709 switch (sz) | |
| 2710 { | |
| 2711 case 1: | |
| 2712 value = ((unsigned char *)string)[i]; | |
| 2713 break; | |
| 2714 | |
| 2715 case 2: | |
| 2716 value = ((unsigned short *)string)[i]; | |
| 2717 break; | |
| 2718 | |
| 2719 case 4: | |
| 2720 value = ((unsigned int *)string)[i]; | |
| 2721 break; | |
| 2722 | |
| 2723 default: | |
| 2724 assert(0); | |
| 2725 break; | |
| 2726 } | |
| 2727 return value; | |
| 2728 } | |
| 2729 | |
| 2730 void StringExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 2731 { | |
| 2732 buf->writeByte('"'); | |
| 2733 for (size_t i = 0; i < len; i++) | |
| 2734 { unsigned c = charAt(i); | |
| 2735 | |
| 2736 switch (c) | |
| 2737 { | |
| 2738 case '"': | |
| 2739 case '\\': | |
| 2740 if (!hgs->console) | |
| 2741 buf->writeByte('\\'); | |
| 2742 default: | |
| 2743 if (c <= 0xFF) | |
| 2744 { if (c <= 0x7F && (isprint(c) || hgs->console)) | |
| 2745 buf->writeByte(c); | |
| 2746 else | |
| 2747 buf->printf("\\x%02x", c); | |
| 2748 } | |
| 2749 else if (c <= 0xFFFF) | |
| 2750 buf->printf("\\x%02x\\x%02x", c & 0xFF, c >> 8); | |
| 2751 else | |
| 2752 buf->printf("\\x%02x\\x%02x\\x%02x\\x%02x", | |
| 2753 c & 0xFF, (c >> 8) & 0xFF, (c >> 16) & 0xFF, c >> 24); | |
| 2754 break; | |
| 2755 } | |
| 2756 } | |
| 2757 buf->writeByte('"'); | |
| 2758 if (postfix) | |
| 2759 buf->writeByte(postfix); | |
| 2760 } | |
| 2761 | |
| 2762 void StringExp::toMangleBuffer(OutBuffer *buf) | |
| 2763 { char m; | |
| 2764 OutBuffer tmp; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2765 const char *p; |
| 159 | 2766 unsigned c; |
| 2767 size_t u; | |
| 2768 unsigned char *q; | |
| 2769 unsigned qlen; | |
| 2770 | |
| 2771 /* Write string in UTF-8 format | |
| 2772 */ | |
| 2773 switch (sz) | |
| 2774 { case 1: | |
| 2775 m = 'a'; | |
| 2776 q = (unsigned char *)string; | |
| 2777 qlen = len; | |
| 2778 break; | |
| 2779 case 2: | |
| 2780 m = 'w'; | |
| 2781 for (u = 0; u < len; ) | |
| 2782 { | |
| 2783 p = utf_decodeWchar((unsigned short *)string, len, &u, &c); | |
| 2784 if (p) | |
| 2785 error("%s", p); | |
| 2786 else | |
| 2787 tmp.writeUTF8(c); | |
| 2788 } | |
| 2789 q = tmp.data; | |
| 2790 qlen = tmp.offset; | |
| 2791 break; | |
| 2792 case 4: | |
| 2793 m = 'd'; | |
| 2794 for (u = 0; u < len; u++) | |
| 2795 { | |
| 2796 c = ((unsigned *)string)[u]; | |
| 2797 if (!utf_isValidDchar(c)) | |
| 2798 error("invalid UCS-32 char \\U%08x", c); | |
| 2799 else | |
| 2800 tmp.writeUTF8(c); | |
| 2801 } | |
| 2802 q = tmp.data; | |
| 2803 qlen = tmp.offset; | |
| 2804 break; | |
| 2805 default: | |
| 2806 assert(0); | |
| 2807 } | |
| 2808 buf->writeByte(m); | |
| 2809 buf->printf("%d_", qlen); | |
| 2810 for (size_t i = 0; i < qlen; i++) | |
| 2811 buf->printf("%02x", q[i]); | |
| 2812 } | |
| 2813 | |
| 2814 /************************ ArrayLiteralExp ************************************/ | |
| 2815 | |
| 2816 // [ e1, e2, e3, ... ] | |
| 2817 | |
| 2818 ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expressions *elements) | |
| 2819 : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) | |
| 2820 { | |
| 2821 this->elements = elements; | |
| 2822 } | |
| 2823 | |
| 2824 ArrayLiteralExp::ArrayLiteralExp(Loc loc, Expression *e) | |
| 2825 : Expression(loc, TOKarrayliteral, sizeof(ArrayLiteralExp)) | |
| 2826 { | |
| 2827 elements = new Expressions; | |
| 2828 elements->push(e); | |
| 2829 } | |
| 2830 | |
| 2831 Expression *ArrayLiteralExp::syntaxCopy() | |
| 2832 { | |
| 2833 return new ArrayLiteralExp(loc, arraySyntaxCopy(elements)); | |
| 2834 } | |
| 2835 | |
| 2836 Expression *ArrayLiteralExp::semantic(Scope *sc) | |
| 2837 { Expression *e; | |
| 2838 Type *t0 = NULL; | |
| 2839 | |
| 2840 #if LOGSEMANTIC | |
| 2841 printf("ArrayLiteralExp::semantic('%s')\n", toChars()); | |
| 2842 #endif | |
| 2843 if (type) | |
| 2844 return this; | |
| 2845 | |
| 2846 // Run semantic() on each element | |
| 2847 for (int i = 0; i < elements->dim; i++) | |
| 2848 { e = (Expression *)elements->data[i]; | |
| 2849 e = e->semantic(sc); | |
| 2850 elements->data[i] = (void *)e; | |
| 2851 } | |
| 2852 expandTuples(elements); | |
| 2853 for (int i = 0; i < elements->dim; i++) | |
| 2854 { e = (Expression *)elements->data[i]; | |
| 2855 | |
| 2856 if (!e->type) | |
| 2857 error("%s has no value", e->toChars()); | |
| 2858 e = resolveProperties(sc, e); | |
| 2859 | |
| 2860 unsigned char committed = 1; | |
| 2861 if (e->op == TOKstring) | |
| 2862 committed = ((StringExp *)e)->committed; | |
| 2863 | |
| 2864 if (!t0) | |
| 2865 { t0 = e->type; | |
| 2866 // Convert any static arrays to dynamic arrays | |
| 2867 if (t0->ty == Tsarray) | |
| 2868 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
2869 t0 = ((TypeSArray *)t0)->next->arrayOf(); |
| 159 | 2870 e = e->implicitCastTo(sc, t0); |
| 2871 } | |
| 2872 } | |
| 2873 else | |
| 2874 e = e->implicitCastTo(sc, t0); | |
| 2875 if (!committed && e->op == TOKstring) | |
| 2876 { StringExp *se = (StringExp *)e; | |
| 2877 se->committed = 0; | |
| 2878 } | |
| 2879 elements->data[i] = (void *)e; | |
| 2880 } | |
| 2881 | |
| 2882 if (!t0) | |
| 2883 t0 = Type::tvoid; | |
| 2884 type = new TypeSArray(t0, new IntegerExp(elements->dim)); | |
| 2885 type = type->semantic(loc, sc); | |
| 2886 return this; | |
| 2887 } | |
| 2888 | |
| 2889 int ArrayLiteralExp::checkSideEffect(int flag) | |
| 2890 { int f = 0; | |
| 2891 | |
| 2892 for (size_t i = 0; i < elements->dim; i++) | |
| 2893 { Expression *e = (Expression *)elements->data[i]; | |
| 2894 | |
| 2895 f |= e->checkSideEffect(2); | |
| 2896 } | |
| 2897 if (flag == 0 && f == 0) | |
| 2898 Expression::checkSideEffect(0); | |
| 2899 return f; | |
| 2900 } | |
| 2901 | |
| 2902 int ArrayLiteralExp::isBool(int result) | |
| 2903 { | |
| 2904 size_t dim = elements ? elements->dim : 0; | |
| 2905 return result ? (dim != 0) : (dim == 0); | |
| 2906 } | |
| 2907 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2908 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2909 int ArrayLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2910 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2911 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
|
2912 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2913 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
2914 |
| 159 | 2915 void ArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 2916 { | |
| 2917 buf->writeByte('['); | |
| 2918 argsToCBuffer(buf, elements, hgs); | |
| 2919 buf->writeByte(']'); | |
| 2920 } | |
| 2921 | |
| 2922 void ArrayLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 2923 { | |
| 2924 size_t dim = elements ? elements->dim : 0; | |
| 2925 buf->printf("A%u", dim); | |
| 2926 for (size_t i = 0; i < dim; i++) | |
| 2927 { Expression *e = (Expression *)elements->data[i]; | |
| 2928 e->toMangleBuffer(buf); | |
| 2929 } | |
| 2930 } | |
| 2931 | |
| 2932 /************************ AssocArrayLiteralExp ************************************/ | |
| 2933 | |
| 2934 // [ key0 : value0, key1 : value1, ... ] | |
| 2935 | |
| 2936 AssocArrayLiteralExp::AssocArrayLiteralExp(Loc loc, | |
| 2937 Expressions *keys, Expressions *values) | |
| 2938 : Expression(loc, TOKassocarrayliteral, sizeof(AssocArrayLiteralExp)) | |
| 2939 { | |
| 2940 assert(keys->dim == values->dim); | |
| 2941 this->keys = keys; | |
| 2942 this->values = values; | |
| 2943 } | |
| 2944 | |
| 2945 Expression *AssocArrayLiteralExp::syntaxCopy() | |
| 2946 { | |
| 2947 return new AssocArrayLiteralExp(loc, | |
| 2948 arraySyntaxCopy(keys), arraySyntaxCopy(values)); | |
| 2949 } | |
| 2950 | |
| 2951 Expression *AssocArrayLiteralExp::semantic(Scope *sc) | |
| 2952 { Expression *e; | |
| 2953 Type *tkey = NULL; | |
| 2954 Type *tvalue = NULL; | |
| 2955 | |
| 2956 #if LOGSEMANTIC | |
| 2957 printf("AssocArrayLiteralExp::semantic('%s')\n", toChars()); | |
| 2958 #endif | |
| 2959 | |
| 2960 // Run semantic() on each element | |
| 2961 for (size_t i = 0; i < keys->dim; i++) | |
| 2962 { Expression *key = (Expression *)keys->data[i]; | |
| 2963 Expression *value = (Expression *)values->data[i]; | |
| 2964 | |
| 2965 key = key->semantic(sc); | |
| 2966 value = value->semantic(sc); | |
| 2967 | |
| 2968 keys->data[i] = (void *)key; | |
| 2969 values->data[i] = (void *)value; | |
| 2970 } | |
| 2971 expandTuples(keys); | |
| 2972 expandTuples(values); | |
| 2973 if (keys->dim != values->dim) | |
| 2974 { | |
| 2975 error("number of keys is %u, must match number of values %u", keys->dim, values->dim); | |
| 2976 keys->setDim(0); | |
| 2977 values->setDim(0); | |
| 2978 } | |
| 2979 for (size_t i = 0; i < keys->dim; i++) | |
| 2980 { Expression *key = (Expression *)keys->data[i]; | |
| 2981 Expression *value = (Expression *)values->data[i]; | |
| 2982 | |
| 2983 if (!key->type) | |
| 2984 error("%s has no value", key->toChars()); | |
| 2985 if (!value->type) | |
| 2986 error("%s has no value", value->toChars()); | |
| 2987 key = resolveProperties(sc, key); | |
| 2988 value = resolveProperties(sc, value); | |
| 2989 | |
| 2990 if (!tkey) | |
| 2991 tkey = key->type; | |
| 2992 else | |
| 2993 key = key->implicitCastTo(sc, tkey); | |
| 2994 keys->data[i] = (void *)key; | |
| 2995 | |
| 2996 if (!tvalue) | |
| 2997 tvalue = value->type; | |
| 2998 else | |
| 2999 value = value->implicitCastTo(sc, tvalue); | |
| 3000 values->data[i] = (void *)value; | |
| 3001 } | |
| 3002 | |
| 3003 if (!tkey) | |
| 3004 tkey = Type::tvoid; | |
| 3005 if (!tvalue) | |
| 3006 tvalue = Type::tvoid; | |
| 3007 type = new TypeAArray(tvalue, tkey); | |
| 3008 type = type->semantic(loc, sc); | |
| 3009 return this; | |
| 3010 } | |
| 3011 | |
| 3012 int AssocArrayLiteralExp::checkSideEffect(int flag) | |
| 3013 { int f = 0; | |
| 3014 | |
| 3015 for (size_t i = 0; i < keys->dim; i++) | |
| 3016 { Expression *key = (Expression *)keys->data[i]; | |
| 3017 Expression *value = (Expression *)values->data[i]; | |
| 3018 | |
| 3019 f |= key->checkSideEffect(2); | |
| 3020 f |= value->checkSideEffect(2); | |
| 3021 } | |
| 3022 if (flag == 0 && f == 0) | |
| 3023 Expression::checkSideEffect(0); | |
| 3024 return f; | |
| 3025 } | |
| 3026 | |
| 3027 int AssocArrayLiteralExp::isBool(int result) | |
| 3028 { | |
| 3029 size_t dim = keys->dim; | |
| 3030 return result ? (dim != 0) : (dim == 0); | |
| 3031 } | |
| 3032 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3033 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3034 int AssocArrayLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3035 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3036 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3037 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3038 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3039 |
| 159 | 3040 void AssocArrayLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3041 { | |
| 3042 buf->writeByte('['); | |
| 3043 for (size_t i = 0; i < keys->dim; i++) | |
| 3044 { Expression *key = (Expression *)keys->data[i]; | |
| 3045 Expression *value = (Expression *)values->data[i]; | |
| 3046 | |
| 3047 if (i) | |
| 3048 buf->writeByte(','); | |
| 3049 expToCBuffer(buf, hgs, key, PREC_assign); | |
| 3050 buf->writeByte(':'); | |
| 3051 expToCBuffer(buf, hgs, value, PREC_assign); | |
| 3052 } | |
| 3053 buf->writeByte(']'); | |
| 3054 } | |
| 3055 | |
| 3056 void AssocArrayLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 3057 { | |
| 3058 size_t dim = keys->dim; | |
| 3059 buf->printf("A%u", dim); | |
| 3060 for (size_t i = 0; i < dim; i++) | |
| 3061 { Expression *key = (Expression *)keys->data[i]; | |
| 3062 Expression *value = (Expression *)values->data[i]; | |
| 3063 | |
| 3064 key->toMangleBuffer(buf); | |
| 3065 value->toMangleBuffer(buf); | |
| 3066 } | |
| 3067 } | |
| 3068 | |
| 3069 /************************ StructLiteralExp ************************************/ | |
| 3070 | |
| 3071 // sd( e1, e2, e3, ... ) | |
| 3072 | |
| 3073 StructLiteralExp::StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements) | |
| 3074 : Expression(loc, TOKstructliteral, sizeof(StructLiteralExp)) | |
| 3075 { | |
| 3076 this->sd = sd; | |
| 3077 this->elements = elements; | |
| 3078 this->sym = NULL; | |
| 3079 this->soffset = 0; | |
| 3080 this->fillHoles = 1; | |
| 3081 } | |
| 3082 | |
| 3083 Expression *StructLiteralExp::syntaxCopy() | |
| 3084 { | |
| 3085 return new StructLiteralExp(loc, sd, arraySyntaxCopy(elements)); | |
| 3086 } | |
| 3087 | |
| 3088 Expression *StructLiteralExp::semantic(Scope *sc) | |
| 3089 { Expression *e; | |
| 3090 | |
| 3091 #if LOGSEMANTIC | |
| 3092 printf("StructLiteralExp::semantic('%s')\n", toChars()); | |
| 3093 #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
|
3094 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
|
3095 return this; |
| 159 | 3096 |
| 3097 // Run semantic() on each element | |
| 3098 for (size_t i = 0; i < elements->dim; i++) | |
| 3099 { e = (Expression *)elements->data[i]; | |
| 3100 if (!e) | |
| 3101 continue; | |
| 3102 e = e->semantic(sc); | |
| 3103 elements->data[i] = (void *)e; | |
| 3104 } | |
| 3105 expandTuples(elements); | |
| 3106 size_t offset = 0; | |
| 3107 for (size_t i = 0; i < elements->dim; i++) | |
| 3108 { e = (Expression *)elements->data[i]; | |
| 3109 if (!e) | |
| 3110 continue; | |
| 3111 | |
| 3112 if (!e->type) | |
| 3113 error("%s has no value", e->toChars()); | |
| 3114 e = resolveProperties(sc, e); | |
| 3115 if (i >= sd->fields.dim) | |
| 3116 { error("more initializers than fields of %s", sd->toChars()); | |
| 3117 break; | |
| 3118 } | |
| 3119 Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3120 VarDeclaration *v = s->isVarDeclaration(); | |
| 3121 assert(v); | |
| 3122 if (v->offset < offset) | |
| 3123 error("overlapping initialization for %s", v->toChars()); | |
| 3124 offset = v->offset + v->type->size(); | |
| 3125 | |
| 3126 Type *telem = v->type; | |
| 3127 while (!e->implicitConvTo(telem) && telem->toBasetype()->ty == Tsarray) | |
| 3128 { /* Static array initialization, as in: | |
| 3129 * T[3][5] = e; | |
| 3130 */ | |
| 3131 telem = telem->toBasetype()->nextOf(); | |
| 3132 } | |
| 3133 | |
| 3134 e = e->implicitCastTo(sc, telem); | |
| 3135 | |
| 3136 elements->data[i] = (void *)e; | |
| 3137 } | |
| 3138 | |
| 3139 /* Fill out remainder of elements[] with default initializers for fields[] | |
| 3140 */ | |
| 3141 for (size_t i = elements->dim; i < sd->fields.dim; i++) | |
| 3142 { Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3143 VarDeclaration *v = s->isVarDeclaration(); | |
| 3144 assert(v); | |
| 3145 | |
| 3146 if (v->offset < offset) | |
| 3147 { e = NULL; | |
| 3148 sd->hasUnions = 1; | |
| 3149 } | |
| 3150 else | |
| 3151 { | |
| 3152 if (v->init) | |
| 3153 { e = v->init->toExpression(); | |
| 3154 if (!e) | |
| 3155 error("cannot make expression out of initializer for %s", v->toChars()); | |
| 3156 } | |
| 3157 else | |
| 3158 { e = v->type->defaultInit(); | |
| 3159 e->loc = loc; | |
| 3160 } | |
| 3161 offset = v->offset + v->type->size(); | |
| 3162 } | |
| 3163 elements->push(e); | |
| 3164 } | |
| 3165 | |
| 3166 type = sd->type; | |
| 3167 return this; | |
| 3168 } | |
| 3169 | |
| 3170 /************************************** | |
| 3171 * Gets expression at offset of type. | |
| 3172 * Returns NULL if not found. | |
| 3173 */ | |
| 3174 | |
| 3175 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
|
3176 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3177 //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
|
3178 // /*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
|
3179 Expression *e = NULL; |
| 159 | 3180 int i = getFieldIndex(type, offset); |
| 3181 | |
| 3182 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
|
3183 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3184 //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
|
3185 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
|
3186 e = (Expression *)elements->data[i]; |
| 159 | 3187 if (e) |
| 3188 { | |
| 3189 e = e->copy(); | |
| 3190 e->type = type; | |
| 3191 } | |
| 3192 } | |
| 3193 return e; | |
| 3194 } | |
| 3195 | |
| 3196 /************************************ | |
| 3197 * Get index of field. | |
| 3198 * Returns -1 if not found. | |
| 3199 */ | |
| 3200 | |
| 3201 int StructLiteralExp::getFieldIndex(Type *type, unsigned offset) | |
| 3202 { | |
| 3203 /* Find which field offset is by looking at the field offsets | |
| 3204 */ | |
| 3205 for (size_t i = 0; i < sd->fields.dim; i++) | |
| 3206 { | |
| 3207 Dsymbol *s = (Dsymbol *)sd->fields.data[i]; | |
| 3208 VarDeclaration *v = s->isVarDeclaration(); | |
| 3209 assert(v); | |
| 3210 | |
| 3211 if (offset == v->offset && | |
| 3212 type->size() == v->type->size()) | |
| 3213 { Expression *e = (Expression *)elements->data[i]; | |
| 3214 if (e) | |
| 3215 { | |
| 3216 return i; | |
| 3217 } | |
| 3218 break; | |
| 3219 } | |
| 3220 } | |
| 3221 return -1; | |
| 3222 } | |
| 3223 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3224 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3225 int StructLiteralExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3226 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3227 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3228 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3229 #endif |
| 159 | 3230 |
| 3231 Expression *StructLiteralExp::toLvalue(Scope *sc, Expression *e) | |
| 3232 { | |
| 3233 return this; | |
| 3234 } | |
| 3235 | |
| 3236 | |
| 3237 int StructLiteralExp::checkSideEffect(int flag) | |
| 3238 { int f = 0; | |
| 3239 | |
| 3240 for (size_t i = 0; i < elements->dim; i++) | |
| 3241 { Expression *e = (Expression *)elements->data[i]; | |
| 3242 if (!e) | |
| 3243 continue; | |
| 3244 | |
| 3245 f |= e->checkSideEffect(2); | |
| 3246 } | |
| 3247 if (flag == 0 && f == 0) | |
| 3248 Expression::checkSideEffect(0); | |
| 3249 return f; | |
| 3250 } | |
| 3251 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3252 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3253 int StructLiteralExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3254 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3255 return arrayExpressionCanThrow(elements); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3256 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3257 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3258 |
| 159 | 3259 void StructLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3260 { | |
| 3261 buf->writestring(sd->toChars()); | |
| 3262 buf->writeByte('('); | |
| 3263 argsToCBuffer(buf, elements, hgs); | |
| 3264 buf->writeByte(')'); | |
| 3265 } | |
| 3266 | |
| 3267 void StructLiteralExp::toMangleBuffer(OutBuffer *buf) | |
| 3268 { | |
| 3269 size_t dim = elements ? elements->dim : 0; | |
| 3270 buf->printf("S%u", dim); | |
| 3271 for (size_t i = 0; i < dim; i++) | |
| 3272 { Expression *e = (Expression *)elements->data[i]; | |
| 3273 if (e) | |
| 3274 e->toMangleBuffer(buf); | |
| 3275 else | |
| 3276 buf->writeByte('v'); // 'v' for void | |
| 3277 } | |
| 3278 } | |
| 3279 | |
| 3280 /************************ TypeDotIdExp ************************************/ | |
| 3281 | |
| 3282 /* Things like: | |
| 3283 * int.size | |
| 3284 * foo.size | |
| 3285 * (foo).size | |
| 3286 * cast(foo).size | |
| 3287 */ | |
| 3288 | |
| 3289 TypeDotIdExp::TypeDotIdExp(Loc loc, Type *type, Identifier *ident) | |
| 3290 : Expression(loc, TOKtypedot, sizeof(TypeDotIdExp)) | |
| 3291 { | |
| 3292 this->type = type; | |
| 3293 this->ident = ident; | |
| 3294 } | |
| 3295 | |
| 3296 Expression *TypeDotIdExp::syntaxCopy() | |
| 3297 { | |
| 3298 TypeDotIdExp *te = new TypeDotIdExp(loc, type->syntaxCopy(), ident); | |
| 3299 return te; | |
| 3300 } | |
| 3301 | |
| 3302 Expression *TypeDotIdExp::semantic(Scope *sc) | |
| 3303 { Expression *e; | |
| 3304 | |
| 3305 #if LOGSEMANTIC | |
| 3306 printf("TypeDotIdExp::semantic()\n"); | |
| 3307 #endif | |
| 3308 e = new DotIdExp(loc, new TypeExp(loc, type), ident); | |
| 3309 e = e->semantic(sc); | |
| 3310 return e; | |
| 3311 } | |
| 3312 | |
| 3313 void TypeDotIdExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3314 { | |
| 3315 buf->writeByte('('); | |
| 3316 type->toCBuffer(buf, NULL, hgs); | |
| 3317 buf->writeByte(')'); | |
| 3318 buf->writeByte('.'); | |
| 3319 buf->writestring(ident->toChars()); | |
| 3320 } | |
| 3321 | |
| 3322 /************************************************************/ | |
| 3323 | |
| 3324 // Mainly just a placeholder | |
| 3325 | |
| 3326 TypeExp::TypeExp(Loc loc, Type *type) | |
| 3327 : Expression(loc, TOKtype, sizeof(TypeExp)) | |
| 3328 { | |
| 3329 //printf("TypeExp::TypeExp(%s)\n", type->toChars()); | |
| 3330 this->type = type; | |
| 3331 } | |
| 3332 | |
|
876
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3333 Expression *TypeExp::syntaxCopy() |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3334 { |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3335 //printf("TypeExp::syntaxCopy()\n"); |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3336 return new TypeExp(loc, type->syntaxCopy()); |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3337 } |
|
27a379f288bf
Merged DMD 1.039
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
875
diff
changeset
|
3338 |
| 159 | 3339 Expression *TypeExp::semantic(Scope *sc) |
| 3340 { | |
| 3341 //printf("TypeExp::semantic(%s)\n", type->toChars()); | |
| 3342 type = type->semantic(loc, sc); | |
| 3343 return this; | |
| 3344 } | |
| 3345 | |
| 3346 void TypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3347 { | |
| 3348 type->toCBuffer(buf, NULL, hgs); | |
| 3349 } | |
| 3350 | |
| 3351 /************************************************************/ | |
| 3352 | |
| 3353 // Mainly just a placeholder | |
| 3354 | |
| 3355 ScopeExp::ScopeExp(Loc loc, ScopeDsymbol *pkg) | |
| 3356 : Expression(loc, TOKimport, sizeof(ScopeExp)) | |
| 3357 { | |
| 3358 //printf("ScopeExp::ScopeExp(pkg = '%s')\n", pkg->toChars()); | |
| 3359 //static int count; if (++count == 38) *(char*)0=0; | |
| 3360 this->sds = pkg; | |
| 3361 } | |
| 3362 | |
| 3363 Expression *ScopeExp::syntaxCopy() | |
| 3364 { | |
| 3365 ScopeExp *se = new ScopeExp(loc, (ScopeDsymbol *)sds->syntaxCopy(NULL)); | |
| 3366 return se; | |
| 3367 } | |
| 3368 | |
| 3369 Expression *ScopeExp::semantic(Scope *sc) | |
| 3370 { | |
| 3371 TemplateInstance *ti; | |
| 3372 ScopeDsymbol *sds2; | |
| 3373 | |
| 3374 #if LOGSEMANTIC | |
| 3375 printf("+ScopeExp::semantic('%s')\n", toChars()); | |
| 3376 #endif | |
| 3377 Lagain: | |
| 3378 ti = sds->isTemplateInstance(); | |
| 3379 if (ti && !global.errors) | |
| 3380 { Dsymbol *s; | |
| 3381 if (!ti->semanticdone) | |
| 3382 ti->semantic(sc); | |
| 3383 s = ti->inst->toAlias(); | |
| 3384 sds2 = s->isScopeDsymbol(); | |
| 3385 if (!sds2) | |
| 3386 { Expression *e; | |
| 3387 | |
| 3388 //printf("s = %s, '%s'\n", s->kind(), s->toChars()); | |
| 3389 if (ti->withsym) | |
| 3390 { | |
| 3391 // Same as wthis.s | |
| 3392 e = new VarExp(loc, ti->withsym->withstate->wthis); | |
| 3393 e = new DotVarExp(loc, e, s->isDeclaration()); | |
| 3394 } | |
| 3395 else | |
| 3396 e = new DsymbolExp(loc, s); | |
| 3397 e = e->semantic(sc); | |
| 3398 //printf("-1ScopeExp::semantic()\n"); | |
| 3399 return e; | |
| 3400 } | |
| 3401 if (sds2 != sds) | |
| 3402 { | |
| 3403 sds = sds2; | |
| 3404 goto Lagain; | |
| 3405 } | |
| 3406 //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); | |
| 3407 } | |
| 3408 else | |
| 3409 { | |
| 3410 //printf("sds = %s, '%s'\n", sds->kind(), sds->toChars()); | |
| 3411 //printf("\tparent = '%s'\n", sds->parent->toChars()); | |
| 3412 sds->semantic(sc); | |
| 3413 } | |
| 3414 type = Type::tvoid; | |
| 3415 //printf("-2ScopeExp::semantic() %s\n", toChars()); | |
| 3416 return this; | |
| 3417 } | |
| 3418 | |
| 3419 void ScopeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3420 { | |
| 3421 if (sds->isTemplateInstance()) | |
| 3422 { | |
| 3423 sds->toCBuffer(buf, hgs); | |
| 3424 } | |
| 3425 else | |
| 3426 { | |
| 3427 buf->writestring(sds->kind()); | |
| 3428 buf->writestring(" "); | |
| 3429 buf->writestring(sds->toChars()); | |
| 3430 } | |
| 3431 } | |
| 3432 | |
| 3433 /********************** TemplateExp **************************************/ | |
| 3434 | |
| 3435 // Mainly just a placeholder | |
| 3436 | |
| 3437 TemplateExp::TemplateExp(Loc loc, TemplateDeclaration *td) | |
| 3438 : Expression(loc, TOKtemplate, sizeof(TemplateExp)) | |
| 3439 { | |
| 3440 //printf("TemplateExp(): %s\n", td->toChars()); | |
| 3441 this->td = td; | |
| 3442 } | |
| 3443 | |
| 3444 void TemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3445 { | |
| 3446 buf->writestring(td->toChars()); | |
| 3447 } | |
| 3448 | |
| 3449 void TemplateExp::rvalue() | |
| 3450 { | |
| 3451 error("template %s has no value", toChars()); | |
| 3452 } | |
| 3453 | |
| 3454 /********************** NewExp **************************************/ | |
| 3455 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3456 /* thisexp.new(newargs) newtype(arguments) */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3457 |
| 159 | 3458 NewExp::NewExp(Loc loc, Expression *thisexp, Expressions *newargs, |
| 3459 Type *newtype, Expressions *arguments) | |
| 3460 : Expression(loc, TOKnew, sizeof(NewExp)) | |
| 3461 { | |
| 3462 this->thisexp = thisexp; | |
| 3463 this->newargs = newargs; | |
| 3464 this->newtype = newtype; | |
| 3465 this->arguments = arguments; | |
| 3466 member = NULL; | |
| 3467 allocator = NULL; | |
| 3468 onstack = 0; | |
| 3469 } | |
| 3470 | |
| 3471 Expression *NewExp::syntaxCopy() | |
| 3472 { | |
| 3473 return new NewExp(loc, | |
| 3474 thisexp ? thisexp->syntaxCopy() : NULL, | |
| 3475 arraySyntaxCopy(newargs), | |
| 3476 newtype->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 3477 } | |
| 3478 | |
| 3479 | |
| 3480 Expression *NewExp::semantic(Scope *sc) | |
| 3481 { int i; | |
| 3482 Type *tb; | |
| 3483 ClassDeclaration *cdthis = NULL; | |
| 3484 | |
| 3485 #if LOGSEMANTIC | |
| 3486 printf("NewExp::semantic() %s\n", toChars()); | |
| 3487 if (thisexp) | |
| 3488 printf("\tthisexp = %s\n", thisexp->toChars()); | |
| 3489 printf("\tnewtype: %s\n", newtype->toChars()); | |
| 3490 #endif | |
| 3491 if (type) // if semantic() already run | |
| 3492 return this; | |
| 3493 | |
| 3494 Lagain: | |
| 3495 if (thisexp) | |
| 3496 { thisexp = thisexp->semantic(sc); | |
| 3497 cdthis = thisexp->type->isClassHandle(); | |
| 3498 if (cdthis) | |
| 3499 { | |
| 3500 sc = sc->push(cdthis); | |
| 3501 type = newtype->semantic(loc, sc); | |
| 3502 sc = sc->pop(); | |
| 3503 } | |
| 3504 else | |
| 3505 { | |
| 3506 error("'this' for nested class must be a class type, not %s", thisexp->type->toChars()); | |
| 3507 type = newtype->semantic(loc, sc); | |
| 3508 } | |
| 3509 } | |
| 3510 else | |
| 3511 type = newtype->semantic(loc, sc); | |
| 3512 newtype = type; // in case type gets cast to something else | |
| 3513 tb = type->toBasetype(); | |
| 3514 //printf("tb: %s, deco = %s\n", tb->toChars(), tb->deco); | |
| 3515 | |
| 3516 arrayExpressionSemantic(newargs, sc); | |
| 3517 preFunctionArguments(loc, sc, newargs); | |
| 3518 arrayExpressionSemantic(arguments, sc); | |
| 3519 preFunctionArguments(loc, sc, arguments); | |
| 3520 | |
| 3521 if (thisexp && tb->ty != Tclass) | |
| 3522 error("e.new is only for allocating nested classes, not %s", tb->toChars()); | |
| 3523 | |
| 3524 if (tb->ty == Tclass) | |
| 3525 { TypeFunction *tf; | |
| 3526 | |
| 3527 TypeClass *tc = (TypeClass *)(tb); | |
| 3528 ClassDeclaration *cd = tc->sym->isClassDeclaration(); | |
| 3529 if (cd->isInterfaceDeclaration()) | |
| 3530 error("cannot create instance of interface %s", cd->toChars()); | |
| 3531 else if (cd->isAbstract()) | |
| 3532 { error("cannot create instance of abstract class %s", cd->toChars()); | |
| 3533 for (int i = 0; i < cd->vtbl.dim; i++) | |
| 3534 { FuncDeclaration *fd = ((Dsymbol *)cd->vtbl.data[i])->isFuncDeclaration(); | |
| 3535 if (fd && fd->isAbstract()) | |
| 3536 error("function %s is abstract", fd->toChars()); | |
| 3537 } | |
| 3538 } | |
| 3539 checkDeprecated(sc, cd); | |
| 3540 if (cd->isNested()) | |
| 3541 { /* We need a 'this' pointer for the nested class. | |
| 3542 * Ensure we have the right one. | |
| 3543 */ | |
| 3544 Dsymbol *s = cd->toParent2(); | |
| 3545 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
|
3546 FuncDeclaration *fdn = s->isFuncDeclaration(); |
| 159 | 3547 |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
3548 //printf("cd isNested, cdn = %s\n", cdn ? cdn->toChars() : "null"); |
| 159 | 3549 if (cdn) |
| 3550 { | |
| 3551 if (!cdthis) | |
| 3552 { | |
| 3553 // Supply an implicit 'this' and try again | |
| 3554 thisexp = new ThisExp(loc); | |
| 3555 for (Dsymbol *sp = sc->parent; 1; sp = sp->parent) | |
| 3556 { if (!sp) | |
| 3557 { | |
| 3558 error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); | |
| 3559 break; | |
| 3560 } | |
| 3561 ClassDeclaration *cdp = sp->isClassDeclaration(); | |
| 3562 if (!cdp) | |
| 3563 continue; | |
| 3564 if (cdp == cdn || cdn->isBaseOf(cdp, NULL)) | |
| 3565 break; | |
| 3566 // Add a '.outer' and try again | |
| 3567 thisexp = new DotIdExp(loc, thisexp, Id::outer); | |
| 3568 } | |
| 3569 if (!global.errors) | |
| 3570 goto Lagain; | |
| 3571 } | |
| 3572 if (cdthis) | |
| 3573 { | |
| 3574 //printf("cdthis = %s\n", cdthis->toChars()); | |
| 3575 if (cdthis != cdn && !cdn->isBaseOf(cdthis, NULL)) | |
| 3576 error("'this' for nested class must be of type %s, not %s", cdn->toChars(), thisexp->type->toChars()); | |
| 3577 } | |
| 3578 #if 0 | |
| 3579 else | |
| 3580 { | |
| 3581 for (Dsymbol *sf = sc->func; 1; sf= sf->toParent2()->isFuncDeclaration()) | |
| 3582 { | |
| 3583 if (!sf) | |
| 3584 { | |
| 3585 error("outer class %s 'this' needed to 'new' nested class %s", cdn->toChars(), cd->toChars()); | |
| 3586 break; | |
| 3587 } | |
| 3588 printf("sf = %s\n", sf->toChars()); | |
| 3589 AggregateDeclaration *ad = sf->isThis(); | |
| 3590 if (ad && (ad == cdn || cdn->isBaseOf(ad->isClassDeclaration(), NULL))) | |
| 3591 break; | |
| 3592 } | |
| 3593 } | |
| 3594 #endif | |
| 3595 } | |
| 3596 else if (thisexp) | |
| 3597 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
|
3598 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
|
3599 { |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3600 // 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
|
3601 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
|
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 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
|
3604 break; |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3605 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
|
3606 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
|
3607 { |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3608 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
|
3609 break; |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3610 } |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3611 } |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3612 |
|
8aebdf56c455
Move check for access of context for nested class from backend into frontend.
Christian Kamm <kamm incasoftware de>
parents:
599
diff
changeset
|
3613 } |
| 159 | 3614 } |
| 3615 else if (thisexp) | |
| 3616 error("e.new is only for allocating nested classes"); | |
| 3617 | |
| 3618 FuncDeclaration *f = cd->ctor; | |
| 3619 if (f) | |
| 3620 { | |
| 3621 assert(f); | |
| 3622 f = f->overloadResolve(loc, arguments); | |
| 3623 checkDeprecated(sc, f); | |
| 3624 member = f->isCtorDeclaration(); | |
| 3625 assert(member); | |
| 3626 | |
| 3627 cd->accessCheck(loc, sc, member); | |
| 3628 | |
| 3629 tf = (TypeFunction *)f->type; | |
| 3630 type = tf->next; | |
| 3631 | |
| 3632 if (!arguments) | |
| 3633 arguments = new Expressions(); | |
| 3634 functionArguments(loc, sc, tf, arguments); | |
| 3635 } | |
| 3636 else | |
| 3637 { | |
| 3638 if (arguments && arguments->dim) | |
| 3639 error("no constructor for %s", cd->toChars()); | |
| 3640 } | |
| 3641 | |
| 3642 if (cd->aggNew) | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3643 { |
|
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
|
3644 // Prepend the size_t size argument to newargs[] |
|
ea82e2077f9d
Change custom allocator new size argument to size_t instead of uint. See #175.
Christian Kamm <kamm incasoftware de>
parents:
876
diff
changeset
|
3645 Expression *e = new IntegerExp(loc, cd->size(loc), Type::tsize_t); |
| 159 | 3646 if (!newargs) |
| 3647 newargs = new Expressions(); | |
| 3648 newargs->shift(e); | |
| 3649 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3650 f = cd->aggNew->overloadResolve(loc, newargs); |
| 159 | 3651 allocator = f->isNewDeclaration(); |
| 3652 assert(allocator); | |
| 3653 | |
| 3654 tf = (TypeFunction *)f->type; | |
| 3655 functionArguments(loc, sc, tf, newargs); | |
| 3656 } | |
| 3657 else | |
| 3658 { | |
| 3659 if (newargs && newargs->dim) | |
| 3660 error("no allocator for %s", cd->toChars()); | |
| 3661 } | |
| 3662 } | |
| 3663 else if (tb->ty == Tstruct) | |
| 3664 { | |
| 3665 TypeStruct *ts = (TypeStruct *)tb; | |
| 3666 StructDeclaration *sd = ts->sym; | |
| 3667 FuncDeclaration *f = sd->aggNew; | |
| 3668 TypeFunction *tf; | |
| 3669 | |
| 3670 if (arguments && arguments->dim) | |
| 3671 error("no constructor for %s", type->toChars()); | |
| 3672 | |
| 3673 if (f) | |
| 3674 { | |
| 3675 Expression *e; | |
| 3676 | |
| 3677 // Prepend the uint size argument to newargs[] | |
| 3678 e = new IntegerExp(loc, sd->size(loc), Type::tuns32); | |
| 3679 if (!newargs) | |
| 3680 newargs = new Expressions(); | |
| 3681 newargs->shift(e); | |
| 3682 | |
| 3683 f = f->overloadResolve(loc, newargs); | |
| 3684 allocator = f->isNewDeclaration(); | |
| 3685 assert(allocator); | |
| 3686 | |
| 3687 tf = (TypeFunction *)f->type; | |
| 3688 functionArguments(loc, sc, tf, newargs); | |
| 3689 | |
| 3690 e = new VarExp(loc, f); | |
| 3691 e = new CallExp(loc, e, newargs); | |
| 3692 e = e->semantic(sc); | |
| 3693 e->type = type->pointerTo(); | |
| 3694 return e; | |
| 3695 } | |
| 3696 | |
| 3697 type = type->pointerTo(); | |
| 3698 } | |
| 3699 else if (tb->ty == Tarray && (arguments && arguments->dim)) | |
| 3700 { | |
| 3701 for (size_t i = 0; i < arguments->dim; i++) | |
| 3702 { | |
| 3703 if (tb->ty != Tarray) | |
| 3704 { error("too many arguments for array"); | |
| 3705 arguments->dim = i; | |
| 3706 break; | |
| 3707 } | |
| 3708 | |
| 3709 Expression *arg = (Expression *)arguments->data[i]; | |
| 3710 arg = resolveProperties(sc, arg); | |
| 3711 arg = arg->implicitCastTo(sc, Type::tsize_t); | |
| 3712 if (arg->op == TOKint64 && (long long)arg->toInteger() < 0) | |
| 3713 error("negative array index %s", arg->toChars()); | |
| 3714 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
|
3715 tb = ((TypeDArray *)tb)->next->toBasetype(); |
| 159 | 3716 } |
| 3717 } | |
| 3718 else if (tb->isscalar()) | |
| 3719 { | |
| 3720 if (arguments && arguments->dim) | |
| 3721 error("no constructor for %s", type->toChars()); | |
| 3722 | |
| 3723 type = type->pointerTo(); | |
| 3724 } | |
| 3725 else | |
| 3726 { | |
| 3727 error("new can only create structs, dynamic arrays or class objects, not %s's", type->toChars()); | |
| 3728 type = type->pointerTo(); | |
| 3729 } | |
| 3730 | |
| 3731 //printf("NewExp: '%s'\n", toChars()); | |
| 3732 //printf("NewExp:type '%s'\n", type->toChars()); | |
| 3733 | |
| 3734 return this; | |
| 3735 } | |
| 3736 | |
| 3737 int NewExp::checkSideEffect(int flag) | |
| 3738 { | |
| 3739 return 1; | |
| 3740 } | |
| 3741 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3742 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3743 int NewExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3744 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3745 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3746 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3747 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3748 |
| 159 | 3749 void NewExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3750 { int i; | |
| 3751 | |
| 3752 if (thisexp) | |
| 3753 { expToCBuffer(buf, hgs, thisexp, PREC_primary); | |
| 3754 buf->writeByte('.'); | |
| 3755 } | |
| 3756 buf->writestring("new "); | |
| 3757 if (newargs && newargs->dim) | |
| 3758 { | |
| 3759 buf->writeByte('('); | |
| 3760 argsToCBuffer(buf, newargs, hgs); | |
| 3761 buf->writeByte(')'); | |
| 3762 } | |
| 3763 newtype->toCBuffer(buf, NULL, hgs); | |
| 3764 if (arguments && arguments->dim) | |
| 3765 { | |
| 3766 buf->writeByte('('); | |
| 3767 argsToCBuffer(buf, arguments, hgs); | |
| 3768 buf->writeByte(')'); | |
| 3769 } | |
| 3770 } | |
| 3771 | |
| 3772 /********************** NewAnonClassExp **************************************/ | |
| 3773 | |
| 3774 NewAnonClassExp::NewAnonClassExp(Loc loc, Expression *thisexp, | |
| 3775 Expressions *newargs, ClassDeclaration *cd, Expressions *arguments) | |
| 3776 : Expression(loc, TOKnewanonclass, sizeof(NewAnonClassExp)) | |
| 3777 { | |
| 3778 this->thisexp = thisexp; | |
| 3779 this->newargs = newargs; | |
| 3780 this->cd = cd; | |
| 3781 this->arguments = arguments; | |
| 3782 } | |
| 3783 | |
| 3784 Expression *NewAnonClassExp::syntaxCopy() | |
| 3785 { | |
| 3786 return new NewAnonClassExp(loc, | |
| 3787 thisexp ? thisexp->syntaxCopy() : NULL, | |
| 3788 arraySyntaxCopy(newargs), | |
| 3789 (ClassDeclaration *)cd->syntaxCopy(NULL), | |
| 3790 arraySyntaxCopy(arguments)); | |
| 3791 } | |
| 3792 | |
| 3793 | |
| 3794 Expression *NewAnonClassExp::semantic(Scope *sc) | |
| 3795 { | |
| 3796 #if LOGSEMANTIC | |
| 3797 printf("NewAnonClassExp::semantic() %s\n", toChars()); | |
| 336 | 3798 //printf("thisexp = %p\n", thisexp); |
| 159 | 3799 //printf("type: %s\n", type->toChars()); |
| 3800 #endif | |
| 3801 | |
| 3802 Expression *d = new DeclarationExp(loc, cd); | |
| 3803 d = d->semantic(sc); | |
| 3804 | |
| 3805 Expression *n = new NewExp(loc, thisexp, newargs, cd->type, arguments); | |
| 3806 | |
| 3807 Expression *c = new CommaExp(loc, d, n); | |
| 3808 return c->semantic(sc); | |
| 3809 } | |
| 3810 | |
| 3811 int NewAnonClassExp::checkSideEffect(int flag) | |
| 3812 { | |
| 3813 return 1; | |
| 3814 } | |
| 3815 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3816 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3817 int NewAnonClassExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3818 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3819 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3820 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3821 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3822 |
| 159 | 3823 void NewAnonClassExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 3824 { int i; | |
| 3825 | |
| 3826 if (thisexp) | |
| 3827 { expToCBuffer(buf, hgs, thisexp, PREC_primary); | |
| 3828 buf->writeByte('.'); | |
| 3829 } | |
| 3830 buf->writestring("new"); | |
| 3831 if (newargs && newargs->dim) | |
| 3832 { | |
| 3833 buf->writeByte('('); | |
| 3834 argsToCBuffer(buf, newargs, hgs); | |
| 3835 buf->writeByte(')'); | |
| 3836 } | |
| 3837 buf->writestring(" class "); | |
| 3838 if (arguments && arguments->dim) | |
| 3839 { | |
| 3840 buf->writeByte('('); | |
| 3841 argsToCBuffer(buf, arguments, hgs); | |
| 3842 buf->writeByte(')'); | |
| 3843 } | |
| 3844 //buf->writestring(" { }"); | |
| 3845 if (cd) | |
| 3846 { | |
| 3847 cd->toCBuffer(buf, hgs); | |
| 3848 } | |
| 3849 } | |
| 3850 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3851 /********************** SymbolExp **************************************/ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3852 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3853 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3854 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
|
3855 : Expression(loc, op, size) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3856 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3857 assert(var); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3858 this->var = var; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3859 this->hasOverloads = hasOverloads; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3860 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3861 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3862 |
| 159 | 3863 /********************** SymOffExp **************************************/ |
| 3864 | |
| 3865 SymOffExp::SymOffExp(Loc loc, Declaration *var, unsigned offset) | |
| 3866 : Expression(loc, TOKsymoff, sizeof(SymOffExp)) | |
| 3867 { | |
| 3868 assert(var); | |
| 3869 this->var = var; | |
| 3870 this->offset = offset; | |
| 3871 VarDeclaration *v = var->isVarDeclaration(); | |
| 3872 if (v && v->needThis()) | |
| 3873 error("need 'this' for address of %s", v->toChars()); | |
| 3874 } | |
| 3875 | |
| 3876 Expression *SymOffExp::semantic(Scope *sc) | |
| 3877 { | |
| 3878 #if LOGSEMANTIC | |
| 3879 printf("SymOffExp::semantic('%s')\n", toChars()); | |
| 3880 #endif | |
| 3881 //var->semantic(sc); | |
| 3882 if (!type) | |
| 3883 type = var->type->pointerTo(); | |
| 3884 VarDeclaration *v = var->isVarDeclaration(); | |
| 3885 if (v) | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
3886 v->checkNestedReference(sc, loc); |
| 159 | 3887 return this; |
| 3888 } | |
| 3889 | |
| 3890 int SymOffExp::isBool(int result) | |
| 3891 { | |
| 3892 return result ? TRUE : FALSE; | |
| 3893 } | |
| 3894 | |
| 3895 void SymOffExp::checkEscape() | |
| 3896 { | |
| 3897 VarDeclaration *v = var->isVarDeclaration(); | |
| 3898 if (v) | |
| 3899 { | |
| 3900 if (!v->isDataseg()) | |
| 3901 error("escaping reference to local variable %s", v->toChars()); | |
| 3902 } | |
| 3903 } | |
| 3904 | |
| 3905 void SymOffExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3906 { | |
| 3907 if (offset) | |
| 3908 buf->printf("(& %s+%u)", var->toChars(), offset); | |
| 3909 else | |
| 3910 buf->printf("& %s", var->toChars()); | |
| 3911 } | |
| 3912 | |
| 3913 /******************************** VarExp **************************/ | |
| 3914 | |
| 3915 VarExp::VarExp(Loc loc, Declaration *var) | |
| 3916 : Expression(loc, TOKvar, sizeof(VarExp)) | |
| 3917 { | |
| 3918 //printf("VarExp(this = %p, '%s')\n", this, var->toChars()); | |
| 3919 this->var = var; | |
| 3920 this->type = var->type; | |
| 3921 } | |
| 3922 | |
| 3923 int VarExp::equals(Object *o) | |
| 3924 { VarExp *ne; | |
| 3925 | |
| 3926 if (this == o || | |
| 3927 (((Expression *)o)->op == TOKvar && | |
| 3928 ((ne = (VarExp *)o), type->equals(ne->type)) && | |
| 3929 var == ne->var)) | |
| 3930 return 1; | |
| 3931 return 0; | |
| 3932 } | |
| 3933 | |
| 3934 Expression *VarExp::semantic(Scope *sc) | |
| 3935 { FuncLiteralDeclaration *fd; | |
| 3936 | |
| 3937 #if LOGSEMANTIC | |
| 3938 printf("VarExp::semantic(%s)\n", toChars()); | |
| 3939 #endif | |
| 3940 if (!type) | |
| 3941 { type = var->type; | |
| 3942 #if 0 | |
| 3943 if (var->storage_class & STClazy) | |
| 3944 { | |
| 3945 TypeFunction *tf = new TypeFunction(NULL, type, 0, LINKd); | |
| 3946 type = new TypeDelegate(tf); | |
| 3947 type = type->semantic(loc, sc); | |
| 3948 } | |
| 3949 #endif | |
| 3950 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3951 /* 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
|
3952 * problems when instantiating imported templates passing private |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3953 * variables as alias template parameters. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3954 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3955 //accessCheck(loc, sc, NULL, var); |
| 159 | 3956 |
| 3957 VarDeclaration *v = var->isVarDeclaration(); | |
| 3958 if (v) | |
| 3959 { | |
| 3960 if (v->isConst() && type->toBasetype()->ty != Tsarray && v->init) | |
| 3961 { | |
| 3962 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 3963 if (ei) | |
| 3964 { | |
| 3965 //ei->exp->implicitCastTo(sc, type)->print(); | |
| 3966 return ei->exp->implicitCastTo(sc, type); | |
| 3967 } | |
| 3968 } | |
| 3969 v->checkNestedReference(sc, loc); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3970 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3971 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
|
3972 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3973 if (v->isDataseg() && !v->isInvariant()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3974 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
|
3975 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
3976 #endif |
| 159 | 3977 } |
| 3978 #if 0 | |
| 3979 else if ((fd = var->isFuncLiteralDeclaration()) != NULL) | |
| 3980 { Expression *e; | |
| 3981 e = new FuncExp(loc, fd); | |
| 3982 e->type = type; | |
| 3983 return e; | |
| 3984 } | |
| 3985 #endif | |
| 3986 return this; | |
| 3987 } | |
| 3988 | |
| 3989 char *VarExp::toChars() | |
| 3990 { | |
| 3991 return var->toChars(); | |
| 3992 } | |
| 3993 | |
| 3994 void VarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 3995 { | |
| 3996 buf->writestring(var->toChars()); | |
| 3997 } | |
| 3998 | |
| 3999 void VarExp::checkEscape() | |
| 4000 { | |
| 4001 VarDeclaration *v = var->isVarDeclaration(); | |
| 4002 if (v) | |
| 4003 { Type *tb = v->type->toBasetype(); | |
| 4004 // if reference type | |
| 4005 if (tb->ty == Tarray || tb->ty == Tsarray || tb->ty == Tclass) | |
| 4006 { | |
| 4007 if ((v->isAuto() || v->isScope()) && !v->noauto) | |
| 4008 error("escaping reference to auto local %s", v->toChars()); | |
| 4009 else if (v->storage_class & STCvariadic) | |
| 4010 error("escaping reference to variadic parameter %s", v->toChars()); | |
| 4011 } | |
| 4012 } | |
| 4013 } | |
| 4014 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4015 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4016 int VarExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4017 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4018 if (var->storage_class & STClazy) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4019 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4020 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4021 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4022 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4023 |
| 159 | 4024 Expression *VarExp::toLvalue(Scope *sc, Expression *e) |
| 4025 { | |
| 4026 #if 0 | |
| 4027 tym = tybasic(e1->ET->Tty); | |
| 4028 if (!(tyscalar(tym) || | |
| 4029 tym == TYstruct || | |
| 4030 tym == TYarray && e->Eoper == TOKaddr)) | |
| 4031 synerr(EM_lvalue); // lvalue expected | |
| 4032 #endif | |
| 4033 if (var->storage_class & STClazy) | |
| 4034 error("lazy variables cannot be lvalues"); | |
| 4035 return this; | |
| 4036 } | |
| 4037 | |
| 4038 Expression *VarExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 4039 { | |
| 4040 //printf("VarExp::modifiableLvalue('%s')\n", var->toChars()); | |
| 4041 if (sc->incontract && var->isParameter()) | |
| 4042 error("cannot modify parameter '%s' in contract", var->toChars()); | |
| 4043 | |
| 4044 if (type && type->toBasetype()->ty == Tsarray) | |
| 4045 error("cannot change reference to static array '%s'", var->toChars()); | |
| 4046 | |
| 4047 VarDeclaration *v = var->isVarDeclaration(); | |
| 4048 if (v && v->canassign == 0 && | |
| 4049 (var->isConst() || (global.params.Dversion > 1 && var->isFinal()))) | |
| 4050 error("cannot modify final variable '%s'", var->toChars()); | |
| 4051 | |
| 4052 if (var->isCtorinit()) | |
| 4053 { // It's only modifiable if inside the right constructor | |
| 4054 Dsymbol *s = sc->func; | |
| 4055 while (1) | |
| 4056 { | |
| 4057 FuncDeclaration *fd = NULL; | |
| 4058 if (s) | |
| 4059 fd = s->isFuncDeclaration(); | |
| 4060 if (fd && | |
| 4061 ((fd->isCtorDeclaration() && var->storage_class & STCfield) || | |
| 4062 (fd->isStaticCtorDeclaration() && !(var->storage_class & STCfield))) && | |
| 4063 fd->toParent() == var->toParent() | |
| 4064 ) | |
| 4065 { | |
| 4066 VarDeclaration *v = var->isVarDeclaration(); | |
| 4067 assert(v); | |
| 4068 v->ctorinit = 1; | |
| 4069 //printf("setting ctorinit\n"); | |
| 4070 } | |
| 4071 else | |
| 4072 { | |
| 4073 if (s) | |
| 4074 { s = s->toParent2(); | |
| 4075 continue; | |
| 4076 } | |
| 4077 else | |
| 4078 { | |
| 4079 const char *p = var->isStatic() ? "static " : ""; | |
| 4080 error("can only initialize %sconst %s inside %sconstructor", | |
| 4081 p, var->toChars(), p); | |
| 4082 } | |
| 4083 } | |
| 4084 break; | |
| 4085 } | |
| 4086 } | |
| 4087 | |
| 4088 // See if this expression is a modifiable lvalue (i.e. not const) | |
| 4089 return toLvalue(sc, e); | |
| 4090 } | |
| 4091 | |
| 4092 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4093 /******************************** OverExp **************************/ |
|
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 #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
|
4096 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
|
4097 : 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
|
4098 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4099 //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
|
4100 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
|
4101 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
|
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 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4104 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
|
4105 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4106 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
|
4107 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4108 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4109 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
|
4110 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4111 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
|
4112 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4113 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4114 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4115 |
| 159 | 4116 /******************************** TupleExp **************************/ |
| 4117 | |
| 4118 TupleExp::TupleExp(Loc loc, Expressions *exps) | |
| 4119 : Expression(loc, TOKtuple, sizeof(TupleExp)) | |
| 4120 { | |
| 4121 //printf("TupleExp(this = %p)\n", this); | |
| 4122 this->exps = exps; | |
| 4123 this->type = NULL; | |
| 4124 } | |
| 4125 | |
| 4126 | |
| 4127 TupleExp::TupleExp(Loc loc, TupleDeclaration *tup) | |
| 4128 : Expression(loc, TOKtuple, sizeof(TupleExp)) | |
| 4129 { | |
| 4130 exps = new Expressions(); | |
| 4131 type = NULL; | |
| 4132 | |
| 4133 exps->reserve(tup->objects->dim); | |
| 4134 for (size_t i = 0; i < tup->objects->dim; i++) | |
| 4135 { Object *o = (Object *)tup->objects->data[i]; | |
| 4136 if (o->dyncast() == DYNCAST_EXPRESSION) | |
| 4137 { | |
| 4138 Expression *e = (Expression *)o; | |
| 4139 e = e->syntaxCopy(); | |
| 4140 exps->push(e); | |
| 4141 } | |
| 4142 else if (o->dyncast() == DYNCAST_DSYMBOL) | |
| 4143 { | |
| 4144 Dsymbol *s = (Dsymbol *)o; | |
| 4145 Expression *e = new DsymbolExp(loc, s); | |
| 4146 exps->push(e); | |
| 4147 } | |
| 4148 else if (o->dyncast() == DYNCAST_TYPE) | |
| 4149 { | |
| 4150 Type *t = (Type *)o; | |
| 4151 Expression *e = new TypeExp(loc, t); | |
| 4152 exps->push(e); | |
| 4153 } | |
| 4154 else | |
| 4155 { | |
| 4156 error("%s is not an expression", o->toChars()); | |
| 4157 } | |
| 4158 } | |
| 4159 } | |
| 4160 | |
| 4161 int TupleExp::equals(Object *o) | |
| 4162 { TupleExp *ne; | |
| 4163 | |
| 4164 if (this == o) | |
| 4165 return 1; | |
| 4166 if (((Expression *)o)->op == TOKtuple) | |
| 4167 { | |
| 4168 TupleExp *te = (TupleExp *)o; | |
| 4169 if (exps->dim != te->exps->dim) | |
| 4170 return 0; | |
| 4171 for (size_t i = 0; i < exps->dim; i++) | |
| 4172 { Expression *e1 = (Expression *)exps->data[i]; | |
| 4173 Expression *e2 = (Expression *)te->exps->data[i]; | |
| 4174 | |
| 4175 if (!e1->equals(e2)) | |
| 4176 return 0; | |
| 4177 } | |
| 4178 return 1; | |
| 4179 } | |
| 4180 return 0; | |
| 4181 } | |
| 4182 | |
| 4183 Expression *TupleExp::syntaxCopy() | |
| 4184 { | |
| 4185 return new TupleExp(loc, arraySyntaxCopy(exps)); | |
| 4186 } | |
| 4187 | |
| 4188 Expression *TupleExp::semantic(Scope *sc) | |
| 4189 { | |
| 4190 #if LOGSEMANTIC | |
| 4191 printf("+TupleExp::semantic(%s)\n", toChars()); | |
| 4192 #endif | |
| 4193 if (type) | |
| 4194 return this; | |
| 4195 | |
| 4196 // Run semantic() on each argument | |
| 4197 for (size_t i = 0; i < exps->dim; i++) | |
| 4198 { Expression *e = (Expression *)exps->data[i]; | |
| 4199 | |
| 4200 e = e->semantic(sc); | |
| 4201 if (!e->type) | |
| 4202 { error("%s has no value", e->toChars()); | |
| 4203 e->type = Type::terror; | |
| 4204 } | |
| 4205 exps->data[i] = (void *)e; | |
| 4206 } | |
| 4207 | |
| 4208 expandTuples(exps); | |
| 4209 if (0 && exps->dim == 1) | |
| 4210 { | |
| 4211 return (Expression *)exps->data[0]; | |
| 4212 } | |
| 4213 type = new TypeTuple(exps); | |
| 4214 //printf("-TupleExp::semantic(%s)\n", toChars()); | |
| 4215 return this; | |
| 4216 } | |
| 4217 | |
| 4218 void TupleExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4219 { | |
| 4220 buf->writestring("tuple("); | |
| 4221 argsToCBuffer(buf, exps, hgs); | |
| 4222 buf->writeByte(')'); | |
| 4223 } | |
| 4224 | |
| 4225 int TupleExp::checkSideEffect(int flag) | |
| 4226 { int f = 0; | |
| 4227 | |
| 4228 for (int i = 0; i < exps->dim; i++) | |
| 4229 { Expression *e = (Expression *)exps->data[i]; | |
| 4230 | |
| 4231 f |= e->checkSideEffect(2); | |
| 4232 } | |
| 4233 if (flag == 0 && f == 0) | |
| 4234 Expression::checkSideEffect(0); | |
| 4235 return f; | |
| 4236 } | |
| 4237 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4238 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4239 int TupleExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4240 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4241 return arrayExpressionCanThrow(exps); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4242 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4243 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4244 |
| 159 | 4245 void TupleExp::checkEscape() |
| 4246 { | |
| 4247 for (size_t i = 0; i < exps->dim; i++) | |
| 4248 { Expression *e = (Expression *)exps->data[i]; | |
| 4249 e->checkEscape(); | |
| 4250 } | |
| 4251 } | |
| 4252 | |
| 4253 /******************************** FuncExp *********************************/ | |
| 4254 | |
| 4255 FuncExp::FuncExp(Loc loc, FuncLiteralDeclaration *fd) | |
| 4256 : Expression(loc, TOKfunction, sizeof(FuncExp)) | |
| 4257 { | |
| 4258 this->fd = fd; | |
| 4259 } | |
| 4260 | |
| 4261 Expression *FuncExp::syntaxCopy() | |
| 4262 { | |
| 4263 return new FuncExp(loc, (FuncLiteralDeclaration *)fd->syntaxCopy(NULL)); | |
| 4264 } | |
| 4265 | |
| 4266 Expression *FuncExp::semantic(Scope *sc) | |
| 4267 { | |
| 4268 #if LOGSEMANTIC | |
| 4269 printf("FuncExp::semantic(%s)\n", toChars()); | |
| 4270 #endif | |
| 4271 if (!type) | |
| 4272 { | |
| 4273 fd->semantic(sc); | |
| 4274 fd->parent = sc->parent; | |
| 4275 if (global.errors) | |
| 4276 { | |
| 4277 if (!fd->type->next) | |
| 4278 fd->type->next = Type::terror; | |
| 4279 } | |
| 4280 else | |
| 4281 { | |
| 4282 fd->semantic2(sc); | |
| 4283 if (!global.errors) | |
| 4284 { | |
| 4285 fd->semantic3(sc); | |
| 4286 | |
| 4287 if (!global.errors && global.params.useInline) | |
| 4288 fd->inlineScan(); | |
| 4289 } | |
| 4290 } | |
| 4291 | |
| 4292 // Type is a "delegate to" or "pointer to" the function literal | |
| 4293 if (fd->isNested()) | |
| 4294 { | |
| 4295 type = new TypeDelegate(fd->type); | |
| 4296 type = type->semantic(loc, sc); | |
| 4297 } | |
| 4298 else | |
| 4299 { | |
| 4300 type = fd->type->pointerTo(); | |
| 4301 } | |
| 4302 } | |
| 4303 return this; | |
| 4304 } | |
| 4305 | |
| 4306 char *FuncExp::toChars() | |
| 4307 { | |
| 4308 return fd->toChars(); | |
| 4309 } | |
| 4310 | |
| 4311 void FuncExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4312 { | |
| 4313 buf->writestring(fd->toChars()); | |
| 4314 } | |
| 4315 | |
| 4316 | |
| 4317 /******************************** DeclarationExp **************************/ | |
| 4318 | |
| 4319 DeclarationExp::DeclarationExp(Loc loc, Dsymbol *declaration) | |
| 4320 : Expression(loc, TOKdeclaration, sizeof(DeclarationExp)) | |
| 4321 { | |
| 4322 this->declaration = declaration; | |
| 4323 } | |
| 4324 | |
| 4325 Expression *DeclarationExp::syntaxCopy() | |
| 4326 { | |
| 4327 return new DeclarationExp(loc, declaration->syntaxCopy(NULL)); | |
| 4328 } | |
| 4329 | |
| 4330 Expression *DeclarationExp::semantic(Scope *sc) | |
| 4331 { | |
| 4332 if (type) | |
| 4333 return this; | |
| 4334 | |
| 4335 #if LOGSEMANTIC | |
| 4336 printf("DeclarationExp::semantic() %s\n", toChars()); | |
| 4337 #endif | |
| 4338 | |
| 4339 /* This is here to support extern(linkage) declaration, | |
| 4340 * where the extern(linkage) winds up being an AttribDeclaration | |
| 4341 * wrapper. | |
| 4342 */ | |
| 4343 Dsymbol *s = declaration; | |
| 4344 | |
| 4345 AttribDeclaration *ad = declaration->isAttribDeclaration(); | |
| 4346 if (ad) | |
| 4347 { | |
| 4348 if (ad->decl && ad->decl->dim == 1) | |
| 4349 s = (Dsymbol *)ad->decl->data[0]; | |
| 4350 } | |
| 4351 | |
| 4352 if (s->isVarDeclaration()) | |
| 4353 { // Do semantic() on initializer first, so: | |
| 4354 // int a = a; | |
| 4355 // will be illegal. | |
| 4356 declaration->semantic(sc); | |
| 4357 s->parent = sc->parent; | |
| 4358 } | |
| 4359 | |
| 4360 //printf("inserting '%s' %p into sc = %p\n", s->toChars(), s, sc); | |
| 4361 // Insert into both local scope and function scope. | |
| 4362 // Must be unique in both. | |
| 4363 if (s->ident) | |
| 4364 { | |
| 4365 if (!sc->insert(s)) | |
| 4366 error("declaration %s is already defined", s->toPrettyChars()); | |
| 4367 else if (sc->func) | |
| 4368 { VarDeclaration *v = s->isVarDeclaration(); | |
| 4369 if ((s->isFuncDeclaration() /*|| v && v->storage_class & STCstatic*/) && | |
| 4370 !sc->func->localsymtab->insert(s)) | |
| 4371 error("declaration %s is already defined in another scope in %s", s->toPrettyChars(), sc->func->toChars()); | |
| 4372 else if (!global.params.useDeprecated) | |
| 4373 { // Disallow shadowing | |
| 4374 | |
| 4375 for (Scope *scx = sc->enclosing; scx && scx->func == sc->func; scx = scx->enclosing) | |
| 4376 { Dsymbol *s2; | |
| 4377 | |
| 4378 if (scx->scopesym && scx->scopesym->symtab && | |
| 4379 (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL && | |
| 4380 s != s2) | |
| 4381 { | |
| 4382 error("shadowing declaration %s is deprecated", s->toPrettyChars()); | |
| 4383 } | |
| 4384 } | |
| 4385 } | |
| 4386 } | |
| 4387 } | |
| 4388 if (!s->isVarDeclaration()) | |
| 4389 { | |
| 4390 declaration->semantic(sc); | |
| 4391 s->parent = sc->parent; | |
| 4392 } | |
| 4393 if (!global.errors) | |
| 4394 { | |
| 4395 declaration->semantic2(sc); | |
| 4396 if (!global.errors) | |
| 4397 { | |
| 4398 declaration->semantic3(sc); | |
| 4399 | |
| 4400 if (!global.errors && global.params.useInline) | |
| 4401 declaration->inlineScan(); | |
| 4402 } | |
| 4403 } | |
| 4404 | |
| 4405 type = Type::tvoid; | |
| 4406 return this; | |
| 4407 } | |
| 4408 | |
| 4409 int DeclarationExp::checkSideEffect(int flag) | |
| 4410 { | |
| 4411 return 1; | |
| 4412 } | |
| 4413 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4414 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4415 int DeclarationExp::canThrow() |
|
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 VarDeclaration *v = declaration->isVarDeclaration(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4418 if (v && v->init) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4419 { ExpInitializer *ie = v->init->isExpInitializer(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4420 return ie && ie->exp->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4421 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4422 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4423 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4424 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4425 |
| 159 | 4426 void DeclarationExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 4427 { | |
| 4428 declaration->toCBuffer(buf, hgs); | |
| 4429 } | |
| 4430 | |
| 4431 | |
| 4432 /************************ TypeidExp ************************************/ | |
| 4433 | |
| 4434 /* | |
| 4435 * typeid(int) | |
| 4436 */ | |
| 4437 | |
| 4438 TypeidExp::TypeidExp(Loc loc, Type *typeidType) | |
| 4439 : Expression(loc, TOKtypeid, sizeof(TypeidExp)) | |
| 4440 { | |
| 4441 this->typeidType = typeidType; | |
| 4442 } | |
| 4443 | |
| 4444 | |
| 4445 Expression *TypeidExp::syntaxCopy() | |
| 4446 { | |
| 4447 return new TypeidExp(loc, typeidType->syntaxCopy()); | |
| 4448 } | |
| 4449 | |
| 4450 | |
| 4451 Expression *TypeidExp::semantic(Scope *sc) | |
| 4452 { Expression *e; | |
| 4453 | |
| 4454 #if LOGSEMANTIC | |
| 4455 printf("TypeidExp::semantic()\n"); | |
| 4456 #endif | |
| 4457 typeidType = typeidType->semantic(loc, sc); | |
| 4458 e = typeidType->getTypeInfo(sc); | |
| 336 | 4459 if (e->loc.linnum == 0) |
| 4460 e->loc = loc; // so there's at least some line number info | |
| 159 | 4461 return e; |
| 4462 } | |
| 4463 | |
| 4464 void TypeidExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4465 { | |
| 4466 buf->writestring("typeid("); | |
| 4467 typeidType->toCBuffer(buf, NULL, hgs); | |
| 4468 buf->writeByte(')'); | |
| 4469 } | |
| 4470 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4471 /************************ 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 #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
|
4473 /* |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4474 * __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
|
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 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
|
4478 : 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
|
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 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
|
4481 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
|
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 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4485 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
|
4486 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4487 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
|
4488 } |
|
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 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4491 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
|
4492 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4493 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
|
4494 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
|
4495 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
|
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 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
|
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 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
|
4500 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
|
4501 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
|
4502 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4503 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4504 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
|
4505 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4506 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4507 |
| 159 | 4508 /************************************************************/ |
| 4509 | |
| 4510 HaltExp::HaltExp(Loc loc) | |
| 4511 : Expression(loc, TOKhalt, sizeof(HaltExp)) | |
| 4512 { | |
| 4513 } | |
| 4514 | |
| 4515 Expression *HaltExp::semantic(Scope *sc) | |
| 4516 { | |
| 4517 #if LOGSEMANTIC | |
| 4518 printf("HaltExp::semantic()\n"); | |
| 4519 #endif | |
| 4520 type = Type::tvoid; | |
| 4521 return this; | |
| 4522 } | |
| 4523 | |
| 4524 int HaltExp::checkSideEffect(int flag) | |
| 4525 { | |
| 4526 return 1; | |
| 4527 } | |
| 4528 | |
| 4529 void HaltExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4530 { | |
| 4531 buf->writestring("halt"); | |
| 4532 } | |
| 4533 | |
| 4534 /************************************************************/ | |
| 4535 | |
| 4536 IsExp::IsExp(Loc loc, Type *targ, Identifier *id, enum TOK tok, | |
| 4537 Type *tspec, enum TOK tok2) | |
| 4538 : Expression(loc, TOKis, sizeof(IsExp)) | |
| 4539 { | |
| 4540 this->targ = targ; | |
| 4541 this->id = id; | |
| 4542 this->tok = tok; | |
| 4543 this->tspec = tspec; | |
| 4544 this->tok2 = tok2; | |
| 4545 } | |
| 4546 | |
| 4547 Expression *IsExp::syntaxCopy() | |
| 4548 { | |
| 4549 return new IsExp(loc, | |
| 4550 targ->syntaxCopy(), | |
| 4551 id, | |
| 4552 tok, | |
| 4553 tspec ? tspec->syntaxCopy() : NULL, | |
| 4554 tok2); | |
| 4555 } | |
| 4556 | |
| 4557 Expression *IsExp::semantic(Scope *sc) | |
| 4558 { Type *tded; | |
| 4559 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4560 /* 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
|
4561 * 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
|
4562 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4563 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4564 //printf("IsExp::semantic(%s)\n", toChars()); |
| 159 | 4565 if (id && !(sc->flags & SCOPEstaticif)) |
| 4566 error("can only declare type aliases within static if conditionals"); | |
| 4567 | |
| 4568 unsigned errors_save = global.errors; | |
| 4569 global.errors = 0; | |
| 4570 global.gag++; // suppress printing of error messages | |
| 4571 targ = targ->semantic(loc, sc); | |
| 4572 global.gag--; | |
| 4573 unsigned gerrors = global.errors; | |
| 4574 global.errors = errors_save; | |
| 4575 | |
| 4576 if (gerrors) // if any errors happened | |
| 4577 { // then condition is false | |
| 4578 goto Lno; | |
| 4579 } | |
| 4580 else if (tok2 != TOKreserved) | |
| 4581 { | |
| 4582 switch (tok2) | |
| 4583 { | |
| 4584 case TOKtypedef: | |
| 4585 if (targ->ty != Ttypedef) | |
| 4586 goto Lno; | |
| 4587 tded = ((TypeTypedef *)targ)->sym->basetype; | |
| 4588 break; | |
| 4589 | |
| 4590 case TOKstruct: | |
| 4591 if (targ->ty != Tstruct) | |
| 4592 goto Lno; | |
| 4593 if (((TypeStruct *)targ)->sym->isUnionDeclaration()) | |
| 4594 goto Lno; | |
| 4595 tded = targ; | |
| 4596 break; | |
| 4597 | |
| 4598 case TOKunion: | |
| 4599 if (targ->ty != Tstruct) | |
| 4600 goto Lno; | |
| 4601 if (!((TypeStruct *)targ)->sym->isUnionDeclaration()) | |
| 4602 goto Lno; | |
| 4603 tded = targ; | |
| 4604 break; | |
| 4605 | |
| 4606 case TOKclass: | |
| 4607 if (targ->ty != Tclass) | |
| 4608 goto Lno; | |
| 4609 if (((TypeClass *)targ)->sym->isInterfaceDeclaration()) | |
| 4610 goto Lno; | |
| 4611 tded = targ; | |
| 4612 break; | |
| 4613 | |
| 4614 case TOKinterface: | |
| 4615 if (targ->ty != Tclass) | |
| 4616 goto Lno; | |
| 4617 if (!((TypeClass *)targ)->sym->isInterfaceDeclaration()) | |
| 4618 goto Lno; | |
| 4619 tded = targ; | |
| 4620 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
|
4621 #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
|
4622 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
|
4623 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
|
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 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4628 case TOKinvariant: |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4629 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
|
4630 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
|
4631 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
|
4632 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
|
4633 break; |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4634 #endif |
| 159 | 4635 |
| 4636 case TOKsuper: | |
| 4637 // If class or interface, get the base class and interfaces | |
| 4638 if (targ->ty != Tclass) | |
| 4639 goto Lno; | |
| 4640 else | |
| 4641 { ClassDeclaration *cd = ((TypeClass *)targ)->sym; | |
| 4642 Arguments *args = new Arguments; | |
| 4643 args->reserve(cd->baseclasses.dim); | |
| 4644 for (size_t i = 0; i < cd->baseclasses.dim; i++) | |
| 4645 { BaseClass *b = (BaseClass *)cd->baseclasses.data[i]; | |
| 4646 args->push(new Argument(STCin, b->type, NULL, NULL)); | |
| 4647 } | |
| 4648 tded = new TypeTuple(args); | |
| 4649 } | |
| 4650 break; | |
| 4651 | |
| 4652 case TOKenum: | |
| 4653 if (targ->ty != Tenum) | |
| 4654 goto Lno; | |
| 4655 tded = ((TypeEnum *)targ)->sym->memtype; | |
| 4656 break; | |
| 4657 | |
| 4658 case TOKdelegate: | |
| 4659 if (targ->ty != Tdelegate) | |
| 4660 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
|
4661 tded = ((TypeDelegate *)targ)->next; // the underlying function type |
| 159 | 4662 break; |
| 4663 | |
| 4664 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
|
4665 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4666 if (targ->ty != Tfunction) |
| 159 | 4667 goto Lno; |
| 4668 tded = targ; | |
| 4669 | |
| 4670 /* Generate tuple from function parameter types. | |
| 4671 */ | |
| 4672 assert(tded->ty == Tfunction); | |
| 4673 Arguments *params = ((TypeFunction *)tded)->parameters; | |
| 4674 size_t dim = Argument::dim(params); | |
| 4675 Arguments *args = new Arguments; | |
| 4676 args->reserve(dim); | |
| 4677 for (size_t i = 0; i < dim; i++) | |
| 4678 { Argument *arg = Argument::getNth(params, i); | |
| 4679 assert(arg && arg->type); | |
| 4680 args->push(new Argument(arg->storageClass, arg->type, NULL, NULL)); | |
| 4681 } | |
| 4682 tded = new TypeTuple(args); | |
| 4683 break; | |
| 4684 } | |
| 4685 case TOKreturn: | |
| 4686 /* Get the 'return type' for the function, | |
| 4687 * delegate, or pointer to function. | |
| 4688 */ | |
| 4689 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
|
4690 tded = ((TypeFunction *)targ)->next; |
| 159 | 4691 else if (targ->ty == Tdelegate) |
| 4692 tded = targ->next->next; | |
| 4693 else if (targ->ty == Tpointer && targ->next->ty == Tfunction) | |
| 4694 tded = targ->next->next; | |
| 4695 else | |
| 4696 goto Lno; | |
| 4697 break; | |
| 4698 | |
| 4699 default: | |
| 4700 assert(0); | |
| 4701 } | |
| 4702 goto Lyes; | |
| 4703 } | |
| 4704 else if (id && tspec) | |
| 4705 { | |
| 4706 /* Evaluate to TRUE if targ matches tspec. | |
| 4707 * If TRUE, declare id as an alias for the specialized type. | |
| 4708 */ | |
| 4709 | |
| 4710 MATCH m; | |
| 4711 TemplateTypeParameter tp(loc, id, NULL, NULL); | |
| 4712 | |
| 4713 TemplateParameters parameters; | |
| 4714 parameters.setDim(1); | |
| 4715 parameters.data[0] = (void *)&tp; | |
| 4716 | |
| 4717 Objects dedtypes; | |
| 4718 dedtypes.setDim(1); | |
| 4719 dedtypes.data[0] = NULL; | |
| 4720 | |
| 4721 m = targ->deduceType(NULL, tspec, ¶meters, &dedtypes); | |
| 4722 if (m == MATCHnomatch || | |
| 4723 (m != MATCHexact && tok == TOKequal)) | |
| 4724 goto Lno; | |
| 4725 else | |
| 4726 { | |
| 4727 assert(dedtypes.dim == 1); | |
| 4728 tded = (Type *)dedtypes.data[0]; | |
| 4729 if (!tded) | |
| 4730 tded = targ; | |
| 4731 goto Lyes; | |
| 4732 } | |
| 4733 } | |
| 4734 else if (id) | |
| 4735 { | |
| 4736 /* Declare id as an alias for type targ. Evaluate to TRUE | |
| 4737 */ | |
| 4738 tded = targ; | |
| 4739 goto Lyes; | |
| 4740 } | |
| 4741 else if (tspec) | |
| 4742 { | |
| 4743 /* Evaluate to TRUE if targ matches tspec | |
| 4744 */ | |
| 4745 tspec = tspec->semantic(loc, sc); | |
| 4746 //printf("targ = %s\n", targ->toChars()); | |
| 4747 //printf("tspec = %s\n", tspec->toChars()); | |
| 4748 if (tok == TOKcolon) | |
| 4749 { if (targ->implicitConvTo(tspec)) | |
| 4750 goto Lyes; | |
| 4751 else | |
| 4752 goto Lno; | |
| 4753 } | |
| 4754 else /* == */ | |
| 4755 { if (targ->equals(tspec)) | |
| 4756 goto Lyes; | |
| 4757 else | |
| 4758 goto Lno; | |
| 4759 } | |
| 4760 } | |
| 4761 | |
| 4762 Lyes: | |
| 4763 if (id) | |
| 4764 { | |
| 4765 Dsymbol *s = new AliasDeclaration(loc, id, tded); | |
| 4766 s->semantic(sc); | |
| 4767 sc->insert(s); | |
| 4768 if (sc->sd) | |
| 4769 s->addMember(sc, sc->sd, 1); | |
| 4770 } | |
| 4771 return new IntegerExp(1); | |
| 4772 | |
| 4773 Lno: | |
| 4774 return new IntegerExp(0); | |
| 4775 } | |
| 4776 | |
| 4777 void IsExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4778 { | |
| 4779 buf->writestring("is("); | |
| 4780 targ->toCBuffer(buf, id, hgs); | |
| 4781 if (tok2 != TOKreserved) | |
| 4782 { | |
| 4783 buf->printf(" %s %s", Token::toChars(tok), Token::toChars(tok2)); | |
| 4784 } | |
| 4785 else if (tspec) | |
| 4786 { | |
| 4787 if (tok == TOKcolon) | |
| 4788 buf->writestring(" : "); | |
| 4789 else | |
| 4790 buf->writestring(" == "); | |
| 4791 tspec->toCBuffer(buf, NULL, hgs); | |
| 4792 } | |
| 336 | 4793 #if DMDV2 |
| 159 | 4794 if (parameters) |
| 4795 { // First parameter is already output, so start with second | |
| 4796 for (int i = 1; i < parameters->dim; i++) | |
| 4797 { | |
| 4798 buf->writeByte(','); | |
| 4799 TemplateParameter *tp = (TemplateParameter *)parameters->data[i]; | |
| 4800 tp->toCBuffer(buf, hgs); | |
| 4801 } | |
| 4802 } | |
| 4803 #endif | |
| 4804 buf->writeByte(')'); | |
| 4805 } | |
| 4806 | |
| 4807 | |
| 4808 /************************************************************/ | |
| 4809 | |
| 4810 UnaExp::UnaExp(Loc loc, enum TOK op, int size, Expression *e1) | |
| 4811 : Expression(loc, op, size) | |
| 4812 { | |
| 4813 this->e1 = e1; | |
| 4814 } | |
| 4815 | |
| 4816 Expression *UnaExp::syntaxCopy() | |
| 4817 { UnaExp *e; | |
| 4818 | |
| 4819 e = (UnaExp *)copy(); | |
| 4820 e->type = NULL; | |
| 4821 e->e1 = e->e1->syntaxCopy(); | |
| 4822 return e; | |
| 4823 } | |
| 4824 | |
| 4825 Expression *UnaExp::semantic(Scope *sc) | |
| 4826 { | |
| 4827 #if LOGSEMANTIC | |
| 4828 printf("UnaExp::semantic('%s')\n", toChars()); | |
| 4829 #endif | |
| 4830 e1 = e1->semantic(sc); | |
| 4831 // if (!e1->type) | |
| 4832 // error("%s has no value", e1->toChars()); | |
| 4833 return this; | |
| 4834 } | |
| 4835 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4836 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4837 int UnaExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4838 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4839 return e1->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4840 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4841 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
4842 |
| 159 | 4843 void UnaExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 4844 { | |
| 4845 buf->writestring(Token::toChars(op)); | |
| 4846 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 4847 } | |
| 4848 | |
| 4849 /************************************************************/ | |
| 4850 | |
| 4851 BinExp::BinExp(Loc loc, enum TOK op, int size, Expression *e1, Expression *e2) | |
| 4852 : Expression(loc, op, size) | |
| 4853 { | |
| 4854 this->e1 = e1; | |
| 4855 this->e2 = e2; | |
| 4856 } | |
| 4857 | |
| 4858 Expression *BinExp::syntaxCopy() | |
| 4859 { BinExp *e; | |
| 4860 | |
| 4861 e = (BinExp *)copy(); | |
| 4862 e->type = NULL; | |
| 4863 e->e1 = e->e1->syntaxCopy(); | |
| 4864 e->e2 = e->e2->syntaxCopy(); | |
| 4865 return e; | |
| 4866 } | |
| 4867 | |
| 4868 Expression *BinExp::semantic(Scope *sc) | |
| 4869 { | |
| 4870 #if LOGSEMANTIC | |
| 4871 printf("BinExp::semantic('%s')\n", toChars()); | |
| 4872 #endif | |
| 4873 e1 = e1->semantic(sc); | |
|
717
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
4874 if (!e1->type && |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
4875 !(op == TOKassign && e1->op == TOKdottd)) // a.template = e2 |
| 159 | 4876 { |
| 4877 error("%s has no value", e1->toChars()); | |
| 4878 e1->type = Type::terror; | |
| 4879 } | |
| 4880 e2 = e2->semantic(sc); | |
| 4881 if (!e2->type) | |
| 4882 { | |
| 4883 error("%s has no value", e2->toChars()); | |
| 4884 e2->type = Type::terror; | |
| 4885 } | |
| 4886 return this; | |
| 4887 } | |
| 4888 | |
| 4889 Expression *BinExp::semanticp(Scope *sc) | |
| 4890 { | |
| 4891 BinExp::semantic(sc); | |
| 4892 e1 = resolveProperties(sc, e1); | |
| 4893 e2 = resolveProperties(sc, e2); | |
| 4894 return this; | |
| 4895 } | |
| 4896 | |
| 4897 /*************************** | |
| 4898 * Common semantic routine for some xxxAssignExp's. | |
| 4899 */ | |
| 4900 | |
| 4901 Expression *BinExp::commonSemanticAssign(Scope *sc) | |
| 4902 { Expression *e; | |
| 4903 | |
| 4904 if (!type) | |
| 4905 { | |
| 4906 BinExp::semantic(sc); | |
| 4907 e2 = resolveProperties(sc, e2); | |
| 4908 | |
| 4909 e = op_overload(sc); | |
| 4910 if (e) | |
| 4911 return e; | |
| 4912 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4913 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
|
4914 { // 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
|
4915 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
|
4916 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
|
4917 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
|
4918 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4919 |
| 159 | 4920 e1 = e1->modifiableLvalue(sc, e1); |
| 4921 e1->checkScalar(); | |
| 4922 type = e1->type; | |
| 4923 if (type->toBasetype()->ty == Tbool) | |
| 4924 { | |
| 4925 error("operator not allowed on bool expression %s", toChars()); | |
| 4926 } | |
| 4927 typeCombine(sc); | |
| 4928 e1->checkArithmetic(); | |
| 4929 e2->checkArithmetic(); | |
| 4930 | |
| 4931 if (op == TOKmodass && e2->type->iscomplex()) | |
| 4932 { error("cannot perform modulo complex arithmetic"); | |
| 4933 return new IntegerExp(0); | |
| 4934 } | |
| 4935 } | |
| 4936 return this; | |
| 4937 } | |
| 4938 | |
| 4939 Expression *BinExp::commonSemanticAssignIntegral(Scope *sc) | |
| 4940 { Expression *e; | |
| 4941 | |
| 4942 if (!type) | |
| 4943 { | |
| 4944 BinExp::semantic(sc); | |
| 4945 e2 = resolveProperties(sc, e2); | |
| 4946 | |
| 4947 e = op_overload(sc); | |
| 4948 if (e) | |
| 4949 return e; | |
| 4950 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4951 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
|
4952 { // 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
|
4953 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
|
4954 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
|
4955 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
|
4956 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
4957 |
| 159 | 4958 e1 = e1->modifiableLvalue(sc, e1); |
| 4959 e1->checkScalar(); | |
| 4960 type = e1->type; | |
| 4961 if (type->toBasetype()->ty == Tbool) | |
| 4962 { | |
| 4963 e2 = e2->implicitCastTo(sc, type); | |
| 4964 } | |
| 4965 | |
| 4966 typeCombine(sc); | |
| 4967 e1->checkIntegral(); | |
| 4968 e2->checkIntegral(); | |
| 4969 } | |
| 4970 return this; | |
| 4971 } | |
| 4972 | |
| 4973 int BinExp::checkSideEffect(int flag) | |
| 4974 { | |
| 4975 if (op == TOKplusplus || | |
| 4976 op == TOKminusminus || | |
| 4977 op == TOKassign || | |
| 4978 op == TOKconstruct || | |
| 4979 op == TOKblit || | |
| 4980 op == TOKaddass || | |
| 4981 op == TOKminass || | |
| 4982 op == TOKcatass || | |
| 4983 op == TOKmulass || | |
| 4984 op == TOKdivass || | |
| 4985 op == TOKmodass || | |
| 4986 op == TOKshlass || | |
| 4987 op == TOKshrass || | |
| 4988 op == TOKushrass || | |
| 4989 op == TOKandass || | |
| 4990 op == TOKorass || | |
| 4991 op == TOKxorass || | |
| 4992 op == TOKin || | |
| 4993 op == TOKremove) | |
| 4994 return 1; | |
| 4995 return Expression::checkSideEffect(flag); | |
| 4996 } | |
| 4997 | |
| 4998 void BinExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 4999 { | |
| 5000 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 5001 buf->writeByte(' '); | |
| 5002 buf->writestring(Token::toChars(op)); | |
| 5003 buf->writeByte(' '); | |
| 5004 expToCBuffer(buf, hgs, e2, (enum PREC)(precedence[op] + 1)); | |
| 5005 } | |
| 5006 | |
| 5007 int BinExp::isunsigned() | |
| 5008 { | |
| 5009 return e1->type->isunsigned() || e2->type->isunsigned(); | |
| 5010 } | |
| 5011 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5012 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5013 int BinExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5014 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5015 return e1->canThrow() || e2->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5016 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5017 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5018 |
| 159 | 5019 void BinExp::incompatibleTypes() |
| 5020 { | |
| 5021 error("incompatible types for ((%s) %s (%s)): '%s' and '%s'", | |
| 5022 e1->toChars(), Token::toChars(op), e2->toChars(), | |
| 5023 e1->type->toChars(), e2->type->toChars()); | |
| 5024 } | |
| 5025 | |
| 5026 /************************************************************/ | |
| 5027 | |
| 5028 CompileExp::CompileExp(Loc loc, Expression *e) | |
| 5029 : UnaExp(loc, TOKmixin, sizeof(CompileExp), e) | |
| 5030 { | |
| 5031 } | |
| 5032 | |
| 5033 Expression *CompileExp::semantic(Scope *sc) | |
| 5034 { | |
| 5035 #if LOGSEMANTIC | |
| 5036 printf("CompileExp::semantic('%s')\n", toChars()); | |
| 5037 #endif | |
| 5038 UnaExp::semantic(sc); | |
| 5039 e1 = resolveProperties(sc, e1); | |
| 5040 e1 = e1->optimize(WANTvalue | WANTinterpret); | |
| 5041 if (e1->op != TOKstring) | |
| 5042 { error("argument to mixin must be a string, not (%s)", e1->toChars()); | |
| 5043 type = Type::terror; | |
| 5044 return this; | |
| 5045 } | |
| 5046 StringExp *se = (StringExp *)e1; | |
| 5047 se = se->toUTF8(sc); | |
| 5048 Parser p(sc->module, (unsigned char *)se->string, se->len, 0); | |
| 5049 p.loc = loc; | |
| 5050 p.nextToken(); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5051 //printf("p.loc.linnum = %d\n", p.loc.linnum); |
| 159 | 5052 Expression *e = p.parseExpression(); |
| 5053 if (p.token.value != TOKeof) | |
| 5054 error("incomplete mixin expression (%s)", se->toChars()); | |
| 5055 return e->semantic(sc); | |
| 5056 } | |
| 5057 | |
| 5058 void CompileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5059 { | |
| 5060 buf->writestring("mixin("); | |
| 5061 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5062 buf->writeByte(')'); | |
| 5063 } | |
| 5064 | |
| 5065 /************************************************************/ | |
| 5066 | |
| 5067 FileExp::FileExp(Loc loc, Expression *e) | |
| 5068 : UnaExp(loc, TOKmixin, sizeof(FileExp), e) | |
| 5069 { | |
| 5070 } | |
| 5071 | |
| 5072 Expression *FileExp::semantic(Scope *sc) | |
| 5073 { char *name; | |
| 5074 StringExp *se; | |
| 5075 | |
| 5076 #if LOGSEMANTIC | |
| 5077 printf("FileExp::semantic('%s')\n", toChars()); | |
| 5078 #endif | |
| 5079 UnaExp::semantic(sc); | |
| 5080 e1 = resolveProperties(sc, e1); | |
| 5081 e1 = e1->optimize(WANTvalue); | |
| 5082 if (e1->op != TOKstring) | |
| 5083 { error("file name argument must be a string, not (%s)", e1->toChars()); | |
| 5084 goto Lerror; | |
| 5085 } | |
| 5086 se = (StringExp *)e1; | |
| 5087 se = se->toUTF8(sc); | |
| 5088 name = (char *)se->string; | |
| 5089 | |
| 5090 if (!global.params.fileImppath) | |
| 5091 { error("need -Jpath switch to import text file %s", name); | |
| 5092 goto Lerror; | |
| 5093 } | |
| 5094 | |
| 5095 if (name != FileName::name(name)) | |
| 5096 { error("use -Jpath switch to provide path for filename %s", name); | |
| 5097 goto Lerror; | |
| 5098 } | |
| 5099 | |
| 5100 name = FileName::searchPath(global.filePath, name, 0); | |
| 5101 if (!name) | |
| 5102 { error("file %s cannot be found, check -Jpath", se->toChars()); | |
| 5103 goto Lerror; | |
| 5104 } | |
| 5105 | |
| 5106 if (global.params.verbose) | |
|
794
661384d6a936
Fix warnings on x86-64. By fvbommel.
Christian Kamm <kamm incasoftware de>
parents:
779
diff
changeset
|
5107 printf("file %s\t(%s)\n", (char*)se->string, name); |
| 159 | 5108 |
| 5109 { File f(name); | |
| 5110 if (f.read()) | |
| 5111 { error("cannot read file %s", f.toChars()); | |
| 5112 goto Lerror; | |
| 5113 } | |
| 5114 else | |
| 5115 { | |
| 5116 f.ref = 1; | |
| 5117 se = new StringExp(loc, f.buffer, f.len); | |
| 5118 } | |
| 5119 } | |
| 5120 Lret: | |
| 5121 return se->semantic(sc); | |
| 5122 | |
| 5123 Lerror: | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5124 se = new StringExp(loc, (char *)""); |
| 159 | 5125 goto Lret; |
| 5126 } | |
| 5127 | |
| 5128 void FileExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5129 { | |
| 5130 buf->writestring("import("); | |
| 5131 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5132 buf->writeByte(')'); | |
| 5133 } | |
| 5134 | |
| 5135 /************************************************************/ | |
| 5136 | |
| 5137 AssertExp::AssertExp(Loc loc, Expression *e, Expression *msg) | |
| 5138 : UnaExp(loc, TOKassert, sizeof(AssertExp), e) | |
| 5139 { | |
| 5140 this->msg = msg; | |
| 5141 } | |
| 5142 | |
| 5143 Expression *AssertExp::syntaxCopy() | |
| 5144 { | |
| 5145 AssertExp *ae = new AssertExp(loc, e1->syntaxCopy(), | |
| 5146 msg ? msg->syntaxCopy() : NULL); | |
| 5147 return ae; | |
| 5148 } | |
| 5149 | |
| 5150 Expression *AssertExp::semantic(Scope *sc) | |
| 5151 { | |
| 5152 #if LOGSEMANTIC | |
| 5153 printf("AssertExp::semantic('%s')\n", toChars()); | |
| 5154 #endif | |
| 5155 UnaExp::semantic(sc); | |
| 5156 e1 = resolveProperties(sc, e1); | |
| 5157 // BUG: see if we can do compile time elimination of the Assert | |
| 5158 e1 = e1->optimize(WANTvalue); | |
| 5159 e1 = e1->checkToBoolean(); | |
| 5160 if (msg) | |
| 5161 { | |
| 5162 msg = msg->semantic(sc); | |
| 5163 msg = resolveProperties(sc, msg); | |
| 5164 msg = msg->implicitCastTo(sc, Type::tchar->arrayOf()); | |
| 5165 msg = msg->optimize(WANTvalue); | |
| 5166 } | |
| 5167 if (e1->isBool(FALSE)) | |
| 5168 { | |
| 5169 FuncDeclaration *fd = sc->parent->isFuncDeclaration(); | |
| 5170 fd->hasReturnExp |= 4; | |
| 5171 | |
| 5172 if (!global.params.useAssert) | |
| 5173 { Expression *e = new HaltExp(loc); | |
| 5174 e = e->semantic(sc); | |
| 5175 return e; | |
| 5176 } | |
| 5177 } | |
| 5178 type = Type::tvoid; | |
| 5179 return this; | |
| 5180 } | |
| 5181 | |
| 5182 int AssertExp::checkSideEffect(int flag) | |
| 5183 { | |
| 5184 return 1; | |
| 5185 } | |
| 5186 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5187 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5188 int AssertExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5189 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5190 return (global.params.useAssert != 0); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5191 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5192 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5193 |
| 159 | 5194 void AssertExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 5195 { | |
| 5196 buf->writestring("assert("); | |
| 5197 expToCBuffer(buf, hgs, e1, PREC_assign); | |
| 5198 if (msg) | |
| 5199 { | |
| 5200 buf->writeByte(','); | |
| 5201 expToCBuffer(buf, hgs, msg, PREC_assign); | |
| 5202 } | |
| 5203 buf->writeByte(')'); | |
| 5204 } | |
| 5205 | |
| 5206 /************************************************************/ | |
| 5207 | |
| 5208 DotIdExp::DotIdExp(Loc loc, Expression *e, Identifier *ident) | |
| 5209 : UnaExp(loc, TOKdot, sizeof(DotIdExp), e) | |
| 5210 { | |
| 5211 this->ident = ident; | |
| 5212 } | |
| 5213 | |
| 5214 Expression *DotIdExp::semantic(Scope *sc) | |
| 5215 { Expression *e; | |
| 5216 Expression *eleft; | |
| 5217 Expression *eright; | |
| 5218 | |
| 5219 #if LOGSEMANTIC | |
| 5220 printf("DotIdExp::semantic(this = %p, '%s')\n", this, toChars()); | |
| 5221 //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); | |
| 5222 #endif | |
| 5223 | |
| 5224 //{ static int z; fflush(stdout); if (++z == 10) *(char*)0=0; } | |
| 5225 | |
| 5226 #if 0 | |
| 5227 /* Don't do semantic analysis if we'll be converting | |
| 5228 * it to a string. | |
| 5229 */ | |
| 5230 if (ident == Id::stringof) | |
| 5231 { char *s = e1->toChars(); | |
| 5232 e = new StringExp(loc, s, strlen(s), 'c'); | |
| 5233 e = e->semantic(sc); | |
| 5234 return e; | |
| 5235 } | |
| 5236 #endif | |
| 5237 | |
| 5238 /* Special case: rewrite this.id and super.id | |
| 5239 * to be classtype.id and baseclasstype.id | |
| 5240 * if we have no this pointer. | |
| 5241 */ | |
| 5242 if ((e1->op == TOKthis || e1->op == TOKsuper) && !hasThis(sc)) | |
| 5243 { ClassDeclaration *cd; | |
| 5244 StructDeclaration *sd; | |
| 5245 AggregateDeclaration *ad; | |
| 5246 | |
| 5247 ad = sc->getStructClassScope(); | |
| 5248 if (ad) | |
| 5249 { | |
| 5250 cd = ad->isClassDeclaration(); | |
| 5251 if (cd) | |
| 5252 { | |
| 5253 if (e1->op == TOKthis) | |
| 5254 { | |
| 5255 e = new TypeDotIdExp(loc, cd->type, ident); | |
| 5256 return e->semantic(sc); | |
| 5257 } | |
| 5258 else if (cd->baseClass && e1->op == TOKsuper) | |
| 5259 { | |
| 5260 e = new TypeDotIdExp(loc, cd->baseClass->type, ident); | |
| 5261 return e->semantic(sc); | |
| 5262 } | |
| 5263 } | |
| 5264 else | |
| 5265 { | |
| 5266 sd = ad->isStructDeclaration(); | |
| 5267 if (sd) | |
| 5268 { | |
| 5269 if (e1->op == TOKthis) | |
| 5270 { | |
| 5271 e = new TypeDotIdExp(loc, sd->type, ident); | |
| 5272 return e->semantic(sc); | |
| 5273 } | |
| 5274 } | |
| 5275 } | |
| 5276 } | |
| 5277 } | |
| 5278 | |
| 5279 UnaExp::semantic(sc); | |
| 5280 | |
| 5281 if (e1->op == TOKdotexp) | |
| 5282 { | |
| 5283 DotExp *de = (DotExp *)e1; | |
| 5284 eleft = de->e1; | |
| 5285 eright = de->e2; | |
| 5286 } | |
| 5287 else | |
| 5288 { | |
| 5289 e1 = resolveProperties(sc, e1); | |
| 5290 eleft = NULL; | |
| 5291 eright = e1; | |
| 5292 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5293 #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
|
5294 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
|
5295 { /* '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
|
5296 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5297 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
|
5298 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
|
5299 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
|
5300 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
|
5301 { 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
|
5302 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
|
5303 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
|
5304 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
|
5305 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5306 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
|
5307 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
|
5308 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
|
5309 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5310 #endif |
| 159 | 5311 |
| 5312 if (e1->op == TOKtuple && ident == Id::length) | |
| 5313 { | |
| 5314 TupleExp *te = (TupleExp *)e1; | |
| 5315 e = new IntegerExp(loc, te->exps->dim, Type::tsize_t); | |
| 5316 return e; | |
| 5317 } | |
| 5318 | |
| 5319 if (eright->op == TOKimport) // also used for template alias's | |
| 5320 { | |
| 5321 ScopeExp *ie = (ScopeExp *)eright; | |
| 5322 | |
|
846
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5323 /* 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
|
5324 * 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
|
5325 * 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
|
5326 */ |
|
bc982f1ad106
Merged DMD 1.037 frontend
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
841
diff
changeset
|
5327 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
|
5328 (ie->sds->isModule() && ie->sds != sc->module) ? 1 : 0); |
| 159 | 5329 if (s) |
| 5330 { | |
| 5331 s = s->toAlias(); | |
| 5332 checkDeprecated(sc, s); | |
| 5333 | |
| 5334 EnumMember *em = s->isEnumMember(); | |
| 5335 if (em) | |
| 5336 { | |
| 5337 e = em->value; | |
| 5338 e = e->semantic(sc); | |
| 5339 return e; | |
| 5340 } | |
| 5341 | |
| 5342 VarDeclaration *v = s->isVarDeclaration(); | |
| 5343 if (v) | |
| 5344 { | |
| 5345 //printf("DotIdExp:: Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars()); | |
| 5346 if (v->inuse) | |
| 5347 { | |
| 5348 error("circular reference to '%s'", v->toChars()); | |
| 5349 type = Type::tint32; | |
| 5350 return this; | |
| 5351 } | |
| 5352 type = v->type; | |
| 5353 if (v->isConst()) | |
| 5354 { | |
| 5355 if (v->init) | |
| 5356 { | |
| 5357 ExpInitializer *ei = v->init->isExpInitializer(); | |
| 5358 if (ei) | |
| 5359 { | |
| 5360 //printf("\tei: %p (%s)\n", ei->exp, ei->exp->toChars()); | |
| 5361 //ei->exp = ei->exp->semantic(sc); | |
| 5362 if (ei->exp->type == type) | |
| 5363 { | |
| 5364 e = ei->exp->copy(); // make copy so we can change loc | |
| 5365 e->loc = loc; | |
| 5366 return e; | |
| 5367 } | |
| 5368 } | |
| 5369 } | |
| 5370 else if (type->isscalar()) | |
| 5371 { | |
| 5372 e = type->defaultInit(); | |
| 5373 e->loc = loc; | |
| 5374 return e; | |
| 5375 } | |
| 5376 } | |
| 5377 if (v->needThis()) | |
| 5378 { | |
| 5379 if (!eleft) | |
| 5380 eleft = new ThisExp(loc); | |
| 5381 e = new DotVarExp(loc, eleft, v); | |
| 5382 e = e->semantic(sc); | |
| 5383 } | |
| 5384 else | |
| 5385 { | |
| 5386 e = new VarExp(loc, v); | |
| 5387 if (eleft) | |
| 5388 { e = new CommaExp(loc, eleft, e); | |
| 5389 e->type = v->type; | |
| 5390 } | |
| 5391 } | |
| 5392 return e->deref(); | |
| 5393 } | |
| 5394 | |
| 5395 FuncDeclaration *f = s->isFuncDeclaration(); | |
| 5396 if (f) | |
| 5397 { | |
| 5398 //printf("it's a function\n"); | |
| 5399 if (f->needThis()) | |
| 5400 { | |
| 5401 if (!eleft) | |
| 5402 eleft = new ThisExp(loc); | |
| 5403 e = new DotVarExp(loc, eleft, f); | |
| 5404 e = e->semantic(sc); | |
| 5405 } | |
| 5406 else | |
| 5407 { | |
| 5408 e = new VarExp(loc, f); | |
| 5409 if (eleft) | |
| 5410 { e = new CommaExp(loc, eleft, e); | |
| 5411 e->type = f->type; | |
| 5412 } | |
| 5413 } | |
| 5414 return e; | |
| 5415 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5416 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5417 OverloadSet *o = s->isOverloadSet(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5418 if (o) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5419 { //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
|
5420 return new OverExp(o); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5421 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5422 #endif |
| 159 | 5423 |
| 5424 Type *t = s->getType(); | |
| 5425 if (t) | |
| 5426 { | |
| 5427 return new TypeExp(loc, t); | |
| 5428 } | |
| 5429 | |
| 336 | 5430 TupleDeclaration *tup = s->isTupleDeclaration(); |
| 5431 if (tup) | |
| 5432 { | |
| 5433 if (eleft) | |
| 5434 error("cannot have e.tuple"); | |
| 5435 e = new TupleExp(loc, tup); | |
| 5436 e = e->semantic(sc); | |
| 5437 return e; | |
| 5438 } | |
| 5439 | |
| 159 | 5440 ScopeDsymbol *sds = s->isScopeDsymbol(); |
| 5441 if (sds) | |
| 5442 { | |
| 5443 //printf("it's a ScopeDsymbol\n"); | |
| 5444 e = new ScopeExp(loc, sds); | |
| 5445 e = e->semantic(sc); | |
| 5446 if (eleft) | |
| 5447 e = new DotExp(loc, eleft, e); | |
| 5448 return e; | |
| 5449 } | |
| 5450 | |
| 5451 Import *imp = s->isImport(); | |
| 5452 if (imp) | |
| 5453 { | |
| 5454 ScopeExp *ie; | |
| 5455 | |
| 5456 ie = new ScopeExp(loc, imp->pkg); | |
| 5457 return ie->semantic(sc); | |
| 5458 } | |
| 5459 | |
| 5460 // BUG: handle other cases like in IdentifierExp::semantic() | |
| 5461 #ifdef DEBUG | |
| 5462 printf("s = '%s', kind = '%s'\n", s->toChars(), s->kind()); | |
| 5463 #endif | |
| 5464 assert(0); | |
| 5465 } | |
| 5466 else if (ident == Id::stringof) | |
| 5467 { char *s = ie->toChars(); | |
| 5468 e = new StringExp(loc, s, strlen(s), 'c'); | |
| 5469 e = e->semantic(sc); | |
| 5470 return e; | |
| 5471 } | |
| 5472 error("undefined identifier %s", toChars()); | |
| 5473 type = Type::tvoid; | |
| 5474 return this; | |
| 5475 } | |
| 5476 else if (e1->type->ty == Tpointer && | |
| 5477 ident != Id::init && ident != Id::__sizeof && | |
| 5478 ident != Id::alignof && ident != Id::offsetof && | |
| 5479 ident != Id::mangleof && ident != Id::stringof) | |
| 5480 { | |
| 5481 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
|
5482 e->type = ((TypePointer *)e1->type)->next; |
| 159 | 5483 return e->type->dotExp(sc, e, ident); |
| 5484 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5485 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5486 else if (t1b->ty == Tarray || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5487 t1b->ty == Tsarray || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5488 t1b->ty == Taarray) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5489 { /* 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
|
5490 * e1.ident |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5491 * as: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5492 * .ident(e1) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5493 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5494 unsigned errors = global.errors; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5495 global.gag++; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5496 e = e1->type->dotExp(sc, e1, ident); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5497 global.gag--; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5498 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
|
5499 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5500 global.errors = errors; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5501 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
|
5502 e = new CallExp(loc, e, e1); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5503 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5504 e = e->semantic(sc); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5505 return e; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5506 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5507 #endif |
| 159 | 5508 else |
| 5509 { | |
| 5510 e = e1->type->dotExp(sc, e1, ident); | |
| 5511 e = e->semantic(sc); | |
| 5512 return e; | |
| 5513 } | |
| 5514 } | |
| 5515 | |
| 5516 void DotIdExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5517 { | |
| 5518 //printf("DotIdExp::toCBuffer()\n"); | |
| 5519 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5520 buf->writeByte('.'); | |
| 5521 buf->writestring(ident->toChars()); | |
| 5522 } | |
| 5523 | |
| 5524 /********************** DotTemplateExp ***********************************/ | |
| 5525 | |
| 5526 // Mainly just a placeholder | |
| 5527 | |
| 5528 DotTemplateExp::DotTemplateExp(Loc loc, Expression *e, TemplateDeclaration *td) | |
| 5529 : UnaExp(loc, TOKdottd, sizeof(DotTemplateExp), e) | |
| 5530 | |
| 5531 { | |
| 5532 this->td = td; | |
| 5533 } | |
| 5534 | |
| 5535 void DotTemplateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5536 { | |
| 5537 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5538 buf->writeByte('.'); | |
| 5539 buf->writestring(td->toChars()); | |
| 5540 } | |
| 5541 | |
| 5542 | |
| 5543 /************************************************************/ | |
| 5544 | |
| 5545 DotVarExp::DotVarExp(Loc loc, Expression *e, Declaration *v) | |
| 5546 : UnaExp(loc, TOKdotvar, sizeof(DotVarExp), e) | |
| 5547 { | |
| 5548 //printf("DotVarExp()\n"); | |
| 5549 this->var = v; | |
| 5550 } | |
| 5551 | |
| 5552 Expression *DotVarExp::semantic(Scope *sc) | |
| 5553 { | |
| 5554 #if LOGSEMANTIC | |
| 5555 printf("DotVarExp::semantic('%s')\n", toChars()); | |
| 5556 #endif | |
| 5557 if (!type) | |
| 5558 { | |
| 5559 var = var->toAlias()->isDeclaration(); | |
| 5560 | |
| 5561 TupleDeclaration *tup = var->isTupleDeclaration(); | |
| 5562 if (tup) | |
| 5563 { /* Replace: | |
| 5564 * e1.tuple(a, b, c) | |
| 5565 * with: | |
| 5566 * tuple(e1.a, e1.b, e1.c) | |
| 5567 */ | |
| 5568 Expressions *exps = new Expressions; | |
| 5569 | |
| 5570 exps->reserve(tup->objects->dim); | |
| 5571 for (size_t i = 0; i < tup->objects->dim; i++) | |
| 5572 { Object *o = (Object *)tup->objects->data[i]; | |
| 5573 if (o->dyncast() != DYNCAST_EXPRESSION) | |
| 5574 { | |
| 5575 error("%s is not an expression", o->toChars()); | |
| 5576 } | |
| 5577 else | |
| 5578 { | |
| 5579 Expression *e = (Expression *)o; | |
| 5580 if (e->op != TOKdsymbol) | |
| 5581 error("%s is not a member", e->toChars()); | |
| 5582 else | |
| 5583 { DsymbolExp *ve = (DsymbolExp *)e; | |
| 5584 | |
| 5585 e = new DotVarExp(loc, e1, ve->s->isDeclaration()); | |
| 5586 exps->push(e); | |
| 5587 } | |
| 5588 } | |
| 5589 } | |
| 5590 Expression *e = new TupleExp(loc, exps); | |
| 5591 e = e->semantic(sc); | |
| 5592 return e; | |
| 5593 } | |
| 5594 | |
| 5595 e1 = e1->semantic(sc); | |
| 5596 type = var->type; | |
| 5597 if (!type && global.errors) | |
| 5598 { // var is goofed up, just return 0 | |
| 5599 return new IntegerExp(0); | |
| 5600 } | |
| 5601 assert(type); | |
| 5602 | |
| 5603 if (!var->isFuncDeclaration()) // for functions, do checks after overload resolution | |
| 5604 { | |
| 5605 AggregateDeclaration *ad = var->toParent()->isAggregateDeclaration(); | |
| 336 | 5606 e1 = getRightThis(loc, sc, ad, e1, var); |
| 5607 if (!sc->noaccesscheck) | |
| 5608 accessCheck(loc, sc, e1, var); | |
| 5609 | |
| 5610 VarDeclaration *v = var->isVarDeclaration(); | |
| 5611 if (v && v->isConst()) | |
| 5612 { ExpInitializer *ei = v->getExpInitializer(); | |
| 5613 if (ei) | |
| 5614 { Expression *e = ei->exp->copy(); | |
| 5615 e = e->semantic(sc); | |
| 5616 return e; | |
| 159 | 5617 } |
| 5618 } | |
| 5619 } | |
| 5620 } | |
| 5621 //printf("-DotVarExp::semantic('%s')\n", toChars()); | |
| 5622 return this; | |
| 5623 } | |
| 5624 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5625 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5626 int DotVarExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5627 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5628 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5629 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5630 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5631 |
| 159 | 5632 Expression *DotVarExp::toLvalue(Scope *sc, Expression *e) |
| 5633 { | |
| 5634 //printf("DotVarExp::toLvalue(%s)\n", toChars()); | |
| 5635 return this; | |
| 5636 } | |
| 5637 | |
| 5638 Expression *DotVarExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 5639 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5640 #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
|
5641 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
|
5642 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
|
5643 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
|
5644 #endif |
| 159 | 5645 |
| 5646 if (var->isCtorinit()) | |
| 5647 { // It's only modifiable if inside the right constructor | |
| 5648 Dsymbol *s = sc->func; | |
| 5649 while (1) | |
| 5650 { | |
| 5651 FuncDeclaration *fd = NULL; | |
| 5652 if (s) | |
| 5653 fd = s->isFuncDeclaration(); | |
| 5654 if (fd && | |
| 5655 ((fd->isCtorDeclaration() && var->storage_class & STCfield) || | |
| 5656 (fd->isStaticCtorDeclaration() && !(var->storage_class & STCfield))) && | |
| 5657 fd->toParent() == var->toParent() && | |
| 5658 e1->op == TOKthis | |
| 5659 ) | |
| 5660 { | |
| 5661 VarDeclaration *v = var->isVarDeclaration(); | |
| 5662 assert(v); | |
| 5663 v->ctorinit = 1; | |
| 5664 //printf("setting ctorinit\n"); | |
| 5665 } | |
| 5666 else | |
| 5667 { | |
| 5668 if (s) | |
| 5669 { s = s->toParent2(); | |
| 5670 continue; | |
| 5671 } | |
| 5672 else | |
| 5673 { | |
| 5674 const char *p = var->isStatic() ? "static " : ""; | |
| 5675 error("can only initialize %sconst member %s inside %sconstructor", | |
| 5676 p, var->toChars(), p); | |
| 5677 } | |
| 5678 } | |
| 5679 break; | |
| 5680 } | |
| 5681 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5682 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5683 else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5684 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5685 Type *t1 = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5686 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5687 if (!t1->isMutable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5688 (t1->ty == Tpointer && !t1->nextOf()->isMutable()) || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5689 !var->type->isMutable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5690 !var->type->isAssignable() || |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5691 var->storage_class & STCmanifest |
|
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 error("cannot modify const/invariant %s", toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5694 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
5695 #endif |
| 159 | 5696 return this; |
| 5697 } | |
| 5698 | |
| 5699 void DotVarExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5700 { | |
| 5701 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5702 buf->writeByte('.'); | |
| 5703 buf->writestring(var->toChars()); | |
| 5704 } | |
| 5705 | |
| 5706 /************************************************************/ | |
| 5707 | |
| 5708 /* Things like: | |
| 5709 * foo.bar!(args) | |
| 5710 */ | |
| 5711 | |
| 5712 DotTemplateInstanceExp::DotTemplateInstanceExp(Loc loc, Expression *e, TemplateInstance *ti) | |
| 5713 : UnaExp(loc, TOKdotti, sizeof(DotTemplateInstanceExp), e) | |
| 5714 { | |
| 5715 //printf("DotTemplateInstanceExp()\n"); | |
| 5716 this->ti = ti; | |
| 5717 } | |
| 5718 | |
| 5719 Expression *DotTemplateInstanceExp::syntaxCopy() | |
| 5720 { | |
| 5721 DotTemplateInstanceExp *de = new DotTemplateInstanceExp(loc, | |
| 5722 e1->syntaxCopy(), | |
| 5723 (TemplateInstance *)ti->syntaxCopy(NULL)); | |
| 5724 return de; | |
| 5725 } | |
| 5726 | |
| 5727 Expression *DotTemplateInstanceExp::semantic(Scope *sc) | |
| 5728 { Dsymbol *s; | |
| 5729 Dsymbol *s2; | |
| 5730 TemplateDeclaration *td; | |
| 5731 Expression *e; | |
| 5732 Identifier *id; | |
| 5733 Type *t1; | |
| 5734 Expression *eleft = NULL; | |
| 5735 Expression *eright; | |
| 5736 | |
| 5737 #if LOGSEMANTIC | |
| 5738 printf("DotTemplateInstanceExp::semantic('%s')\n", toChars()); | |
| 5739 #endif | |
| 5740 //e1->print(); | |
| 5741 //print(); | |
| 5742 e1 = e1->semantic(sc); | |
| 5743 t1 = e1->type; | |
| 5744 if (t1) | |
| 5745 t1 = t1->toBasetype(); | |
| 5746 //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
|
5747 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5748 /* 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
|
5749 * 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
|
5750 * 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
|
5751 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5752 |
| 159 | 5753 if (e1->op == TOKdotexp) |
| 5754 { DotExp *de = (DotExp *)e1; | |
| 5755 eleft = de->e1; | |
| 5756 eright = de->e2; | |
| 5757 } | |
| 5758 else | |
| 5759 { eleft = NULL; | |
| 5760 eright = e1; | |
| 5761 } | |
| 5762 if (eright->op == TOKimport) | |
| 5763 { | |
| 5764 s = ((ScopeExp *)eright)->sds; | |
| 5765 } | |
| 5766 else if (e1->op == TOKtype) | |
| 5767 { | |
| 5768 s = t1->isClassHandle(); | |
| 5769 if (!s) | |
| 5770 { if (t1->ty == Tstruct) | |
| 5771 s = ((TypeStruct *)t1)->sym; | |
| 5772 else | |
| 5773 goto L1; | |
| 5774 } | |
| 5775 } | |
| 5776 else if (t1 && (t1->ty == Tstruct || t1->ty == Tclass)) | |
| 5777 { | |
| 5778 s = t1->toDsymbol(sc); | |
| 5779 eleft = e1; | |
| 5780 } | |
| 5781 else if (t1 && t1->ty == Tpointer) | |
| 5782 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
5783 t1 = ((TypePointer *)t1)->next->toBasetype(); |
| 159 | 5784 if (t1->ty != Tstruct) |
| 5785 goto L1; | |
| 5786 s = t1->toDsymbol(sc); | |
| 5787 eleft = e1; | |
| 5788 } | |
| 5789 else | |
| 5790 { | |
| 5791 L1: | |
| 5792 error("template %s is not a member of %s", ti->toChars(), e1->toChars()); | |
| 5793 goto Lerr; | |
| 5794 } | |
| 5795 | |
| 5796 assert(s); | |
| 5797 id = ti->name; | |
| 5798 s2 = s->search(loc, id, 0); | |
| 5799 if (!s2) | |
| 5800 { error("template identifier %s is not a member of %s %s", id->toChars(), s->kind(), s->ident->toChars()); | |
| 5801 goto Lerr; | |
| 5802 } | |
| 5803 s = s2; | |
| 5804 s->semantic(sc); | |
| 5805 s = s->toAlias(); | |
| 5806 td = s->isTemplateDeclaration(); | |
| 5807 if (!td) | |
| 5808 { | |
| 5809 error("%s is not a template", id->toChars()); | |
| 5810 goto Lerr; | |
| 5811 } | |
| 5812 if (global.errors) | |
| 5813 goto Lerr; | |
| 5814 | |
| 5815 ti->tempdecl = td; | |
| 5816 | |
| 5817 if (eleft) | |
| 5818 { Declaration *v; | |
| 5819 | |
| 5820 ti->semantic(sc); | |
| 5821 s = ti->inst->toAlias(); | |
| 5822 v = s->isDeclaration(); | |
| 5823 if (v) | |
| 5824 { e = new DotVarExp(loc, eleft, v); | |
| 5825 e = e->semantic(sc); | |
| 5826 return e; | |
| 5827 } | |
| 5828 } | |
| 5829 | |
| 5830 e = new ScopeExp(loc, ti); | |
| 5831 if (eleft) | |
| 5832 { | |
| 5833 e = new DotExp(loc, eleft, e); | |
| 5834 } | |
| 5835 e = e->semantic(sc); | |
| 5836 return e; | |
| 5837 | |
| 5838 Lerr: | |
| 336 | 5839 return new IntegerExp(loc, 0, Type::tint32); |
| 159 | 5840 } |
| 5841 | |
| 5842 void DotTemplateInstanceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5843 { | |
| 5844 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5845 buf->writeByte('.'); | |
| 5846 ti->toCBuffer(buf, hgs); | |
| 5847 } | |
| 5848 | |
| 5849 /************************************************************/ | |
| 5850 | |
| 5851 DelegateExp::DelegateExp(Loc loc, Expression *e, FuncDeclaration *f) | |
| 5852 : UnaExp(loc, TOKdelegate, sizeof(DelegateExp), e) | |
| 5853 { | |
| 5854 this->func = f; | |
| 5855 } | |
| 5856 | |
| 5857 Expression *DelegateExp::semantic(Scope *sc) | |
| 5858 { | |
| 5859 #if LOGSEMANTIC | |
| 5860 printf("DelegateExp::semantic('%s')\n", toChars()); | |
| 5861 #endif | |
| 5862 if (!type) | |
| 5863 { | |
| 5864 e1 = e1->semantic(sc); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
5865 // 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
|
5866 type = new TypeDelegate(func->type->syntaxCopy()); |
| 159 | 5867 type = type->semantic(loc, sc); |
| 5868 AggregateDeclaration *ad = func->toParent()->isAggregateDeclaration(); | |
| 336 | 5869 if (func->needThis()) |
| 5870 e1 = getRightThis(loc, sc, ad, e1, func); | |
| 159 | 5871 } |
| 5872 return this; | |
| 5873 } | |
| 5874 | |
| 5875 void DelegateExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5876 { | |
| 5877 buf->writeByte('&'); | |
| 5878 if (!func->isNested()) | |
| 5879 { | |
| 5880 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5881 buf->writeByte('.'); | |
| 5882 } | |
| 5883 buf->writestring(func->toChars()); | |
| 5884 } | |
| 5885 | |
| 5886 /************************************************************/ | |
| 5887 | |
| 5888 DotTypeExp::DotTypeExp(Loc loc, Expression *e, Dsymbol *s) | |
| 5889 : UnaExp(loc, TOKdottype, sizeof(DotTypeExp), e) | |
| 5890 { | |
| 5891 this->sym = s; | |
| 5892 this->type = s->getType(); | |
| 5893 } | |
| 5894 | |
| 5895 Expression *DotTypeExp::semantic(Scope *sc) | |
| 5896 { | |
| 5897 #if LOGSEMANTIC | |
| 5898 printf("DotTypeExp::semantic('%s')\n", toChars()); | |
| 5899 #endif | |
| 5900 UnaExp::semantic(sc); | |
| 5901 return this; | |
| 5902 } | |
| 5903 | |
| 5904 void DotTypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 5905 { | |
| 5906 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 5907 buf->writeByte('.'); | |
| 5908 buf->writestring(sym->toChars()); | |
| 5909 } | |
| 5910 | |
| 5911 /************************************************************/ | |
| 5912 | |
| 5913 CallExp::CallExp(Loc loc, Expression *e, Expressions *exps) | |
| 5914 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5915 { | |
| 5916 this->arguments = exps; | |
| 5917 } | |
| 5918 | |
| 5919 CallExp::CallExp(Loc loc, Expression *e) | |
| 5920 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5921 { | |
| 5922 this->arguments = NULL; | |
| 5923 } | |
| 5924 | |
| 5925 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1) | |
| 5926 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5927 { | |
| 5928 Expressions *arguments = new Expressions(); | |
| 5929 arguments->setDim(1); | |
| 5930 arguments->data[0] = (void *)earg1; | |
| 5931 | |
| 5932 this->arguments = arguments; | |
| 5933 } | |
| 5934 | |
| 5935 CallExp::CallExp(Loc loc, Expression *e, Expression *earg1, Expression *earg2) | |
| 5936 : UnaExp(loc, TOKcall, sizeof(CallExp), e) | |
| 5937 { | |
| 5938 Expressions *arguments = new Expressions(); | |
| 5939 arguments->setDim(2); | |
| 5940 arguments->data[0] = (void *)earg1; | |
| 5941 arguments->data[1] = (void *)earg2; | |
| 5942 | |
| 5943 this->arguments = arguments; | |
| 5944 } | |
| 5945 | |
| 5946 Expression *CallExp::syntaxCopy() | |
| 5947 { | |
| 5948 return new CallExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 5949 } | |
| 5950 | |
| 5951 | |
| 5952 Expression *CallExp::semantic(Scope *sc) | |
| 5953 { | |
| 5954 TypeFunction *tf; | |
| 5955 FuncDeclaration *f; | |
| 5956 int i; | |
| 5957 Type *t1; | |
| 5958 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
|
5959 Objects *targsi = NULL; // initial list of template arguments |
| 159 | 5960 |
| 5961 #if LOGSEMANTIC | |
| 5962 printf("CallExp::semantic() %s\n", toChars()); | |
| 5963 #endif | |
| 5964 if (type) | |
| 5965 return this; // semantic() already run | |
| 5966 #if 0 | |
| 5967 if (arguments && arguments->dim) | |
| 5968 { | |
| 5969 Expression *earg = (Expression *)arguments->data[0]; | |
| 5970 earg->print(); | |
| 5971 if (earg->type) earg->type->print(); | |
| 5972 } | |
| 5973 #endif | |
| 5974 | |
| 5975 if (e1->op == TOKdelegate) | |
| 5976 { DelegateExp *de = (DelegateExp *)e1; | |
| 5977 | |
| 5978 e1 = new DotVarExp(de->loc, de->e1, de->func); | |
| 5979 return semantic(sc); | |
| 5980 } | |
| 5981 | |
| 5982 /* Transform: | |
| 5983 * array.id(args) into id(array,args) | |
| 5984 * aa.remove(arg) into delete aa[arg] | |
| 5985 */ | |
| 5986 if (e1->op == TOKdot) | |
| 5987 { | |
| 5988 // BUG: we should handle array.a.b.c.e(args) too | |
| 5989 | |
| 5990 DotIdExp *dotid = (DotIdExp *)(e1); | |
| 5991 dotid->e1 = dotid->e1->semantic(sc); | |
| 5992 assert(dotid->e1); | |
| 5993 if (dotid->e1->type) | |
| 5994 { | |
| 5995 TY e1ty = dotid->e1->type->toBasetype()->ty; | |
| 5996 if (e1ty == Taarray && dotid->ident == Id::remove) | |
| 5997 { | |
| 5998 if (!arguments || arguments->dim != 1) | |
| 5999 { error("expected key as argument to aa.remove()"); | |
| 6000 goto Lagain; | |
| 6001 } | |
| 6002 Expression *key = (Expression *)arguments->data[0]; | |
| 6003 key = key->semantic(sc); | |
| 6004 key = resolveProperties(sc, key); | |
| 6005 key->rvalue(); | |
| 6006 | |
| 6007 TypeAArray *taa = (TypeAArray *)dotid->e1->type->toBasetype(); | |
| 6008 key = key->implicitCastTo(sc, taa->index); | |
| 6009 key = key->implicitCastTo(sc, taa->key); | |
| 6010 | |
| 6011 return new RemoveExp(loc, dotid->e1, key); | |
| 6012 } | |
| 6013 else if (e1ty == Tarray || e1ty == Tsarray || e1ty == Taarray) | |
| 6014 { | |
| 6015 if (!arguments) | |
| 6016 arguments = new Expressions(); | |
| 6017 arguments->shift(dotid->e1); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6018 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6019 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
|
6020 #else |
| 159 | 6021 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
|
6022 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6023 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6024 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6025 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6026 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6027 #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
|
6028 /* 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
|
6029 * 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
|
6030 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6031 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
|
6032 { 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
|
6033 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
|
6034 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
|
6035 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6036 /* 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
|
6037 * 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
|
6038 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6039 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
|
6040 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
|
6041 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
|
6042 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
|
6043 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
|
6044 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
|
6045 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6046 /* 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
|
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 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
|
6049 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
|
6050 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
|
6051 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6052 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6053 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6054 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6055 /* 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
|
6056 * 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
|
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 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
|
6059 { 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
|
6060 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
|
6061 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
|
6062 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6063 /* 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
|
6064 * 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
|
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 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
|
6067 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
|
6068 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
|
6069 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
|
6070 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
|
6071 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
|
6072 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
|
6073 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6074 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
|
6075 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
|
6076 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
|
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 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6079 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
|
6080 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6081 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6082 #endif |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6083 |
| 159 | 6084 istemp = 0; |
| 6085 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
|
6086 //printf("Lagain: %s\n", toChars()); |
| 159 | 6087 f = NULL; |
| 6088 if (e1->op == TOKthis || e1->op == TOKsuper) | |
| 6089 { | |
| 6090 // semantic() run later for these | |
| 6091 } | |
| 6092 else | |
| 6093 { | |
| 6094 UnaExp::semantic(sc); | |
| 6095 | |
| 6096 /* Look for e1 being a lazy parameter | |
| 6097 */ | |
| 6098 if (e1->op == TOKvar) | |
| 6099 { VarExp *ve = (VarExp *)e1; | |
| 6100 | |
| 6101 if (ve->var->storage_class & STClazy) | |
| 6102 { | |
| 6103 TypeFunction *tf = new TypeFunction(NULL, ve->var->type, 0, LINKd); | |
| 6104 TypeDelegate *t = new TypeDelegate(tf); | |
| 6105 ve->type = t->semantic(loc, sc); | |
| 6106 } | |
| 6107 } | |
| 6108 | |
| 6109 if (e1->op == TOKimport) | |
| 6110 { // Perhaps this should be moved to ScopeExp::semantic() | |
| 6111 ScopeExp *se = (ScopeExp *)e1; | |
| 6112 e1 = new DsymbolExp(loc, se->sds); | |
| 6113 e1 = e1->semantic(sc); | |
| 6114 } | |
| 6115 #if 1 // patch for #540 by Oskar Linde | |
| 6116 else if (e1->op == TOKdotexp) | |
| 6117 { | |
| 6118 DotExp *de = (DotExp *) e1; | |
| 6119 | |
| 6120 if (de->e2->op == TOKimport) | |
| 6121 { // This should *really* be moved to ScopeExp::semantic() | |
| 6122 ScopeExp *se = (ScopeExp *)de->e2; | |
| 6123 de->e2 = new DsymbolExp(loc, se->sds); | |
| 6124 de->e2 = de->e2->semantic(sc); | |
| 6125 } | |
| 6126 | |
| 6127 if (de->e2->op == TOKtemplate) | |
| 6128 { TemplateExp *te = (TemplateExp *) de->e2; | |
| 6129 e1 = new DotTemplateExp(loc,de->e1,te->td); | |
| 6130 } | |
| 6131 } | |
| 6132 #endif | |
| 6133 } | |
| 6134 | |
| 6135 if (e1->op == TOKcomma) | |
| 6136 { | |
| 6137 CommaExp *ce = (CommaExp *)e1; | |
| 6138 | |
| 6139 e1 = ce->e2; | |
| 6140 e1->type = ce->type; | |
| 6141 ce->e2 = this; | |
| 6142 ce->type = NULL; | |
| 6143 return ce->semantic(sc); | |
| 6144 } | |
| 6145 | |
| 6146 t1 = NULL; | |
| 6147 if (e1->type) | |
| 6148 t1 = e1->type->toBasetype(); | |
| 6149 | |
| 6150 // Check for call operator overload | |
| 6151 if (t1) | |
| 6152 { AggregateDeclaration *ad; | |
| 6153 | |
| 6154 if (t1->ty == Tstruct) | |
| 6155 { | |
| 6156 ad = ((TypeStruct *)t1)->sym; | |
| 6157 if (search_function(ad, Id::call)) | |
| 6158 goto L1; // overload of opCall, therefore it's a call | |
| 6159 | |
| 6160 if (e1->op != TOKtype) | |
| 6161 error("%s %s does not overload ()", ad->kind(), ad->toChars()); | |
| 6162 /* It's a struct literal | |
| 6163 */ | |
| 6164 Expression *e = new StructLiteralExp(loc, (StructDeclaration *)ad, arguments); | |
| 6165 e = e->semantic(sc); | |
| 6166 e->type = e1->type; // in case e1->type was a typedef | |
| 6167 return e; | |
| 6168 } | |
| 6169 else if (t1->ty == Tclass) | |
| 6170 { | |
| 6171 ad = ((TypeClass *)t1)->sym; | |
| 6172 goto L1; | |
| 6173 L1: | |
| 6174 // Rewrite as e1.call(arguments) | |
| 6175 Expression *e = new DotIdExp(loc, e1, Id::call); | |
| 6176 e = new CallExp(loc, e, arguments); | |
| 6177 e = e->semantic(sc); | |
| 6178 return e; | |
| 6179 } | |
| 6180 } | |
| 6181 | |
| 6182 arrayExpressionSemantic(arguments, sc); | |
| 6183 preFunctionArguments(loc, sc, arguments); | |
| 6184 | |
| 6185 if (e1->op == TOKdotvar && t1->ty == Tfunction || | |
| 6186 e1->op == TOKdottd) | |
| 6187 { | |
| 6188 DotVarExp *dve; | |
| 6189 DotTemplateExp *dte; | |
| 6190 AggregateDeclaration *ad; | |
| 6191 UnaExp *ue = (UnaExp *)(e1); | |
| 336 | 6192 |
| 159 | 6193 if (e1->op == TOKdotvar) |
| 6194 { // Do overload resolution | |
| 6195 dve = (DotVarExp *)(e1); | |
| 6196 | |
| 6197 f = dve->var->isFuncDeclaration(); | |
| 6198 assert(f); | |
| 6199 f = f->overloadResolve(loc, arguments); | |
| 6200 | |
| 6201 ad = f->toParent()->isAggregateDeclaration(); | |
| 6202 } | |
| 6203 else | |
| 6204 { dte = (DotTemplateExp *)(e1); | |
| 6205 TemplateDeclaration *td = dte->td; | |
| 6206 assert(td); | |
| 6207 if (!arguments) | |
| 6208 // Should fix deduceFunctionTemplate() so it works on NULL argument | |
| 6209 arguments = new Expressions(); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6210 f = td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); |
| 159 | 6211 if (!f) |
| 6212 { type = Type::terror; | |
| 6213 return this; | |
| 6214 } | |
| 6215 ad = td->toParent()->isAggregateDeclaration(); | |
| 6216 } | |
| 336 | 6217 if (f->needThis()) |
| 6218 { | |
| 6219 ue->e1 = getRightThis(loc, sc, ad, ue->e1, f); | |
| 6220 } | |
| 6221 | |
| 6222 /* Cannot call public functions from inside invariant | |
| 6223 * (because then the invariant would have infinite recursion) | |
| 159 | 6224 */ |
| 336 | 6225 if (sc->func && sc->func->isInvariantDeclaration() && |
| 6226 ue->e1->op == TOKthis && | |
| 6227 f->addPostInvariant() | |
| 159 | 6228 ) |
| 6229 { | |
| 336 | 6230 error("cannot call public/export function %s from invariant", f->toChars()); |
| 159 | 6231 } |
| 6232 | |
| 6233 checkDeprecated(sc, f); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6234 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6235 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6236 #endif |
| 159 | 6237 accessCheck(loc, sc, ue->e1, f); |
| 6238 if (!f->needThis()) | |
| 6239 { | |
| 6240 VarExp *ve = new VarExp(loc, f); | |
| 6241 e1 = new CommaExp(loc, ue->e1, ve); | |
| 6242 e1->type = f->type; | |
| 6243 } | |
| 6244 else | |
| 6245 { | |
| 6246 if (e1->op == TOKdotvar) | |
| 6247 dve->var = f; | |
| 6248 else | |
| 6249 e1 = new DotVarExp(loc, dte->e1, f); | |
| 6250 e1->type = f->type; | |
| 6251 | |
| 6252 // See if we need to adjust the 'this' pointer | |
| 6253 AggregateDeclaration *ad = f->isThis(); | |
| 6254 ClassDeclaration *cd = ue->e1->type->isClassHandle(); | |
| 6255 if (ad && cd && ad->isClassDeclaration() && ad != cd && | |
| 6256 ue->e1->op != TOKsuper) | |
| 6257 { | |
| 6258 ue->e1 = ue->e1->castTo(sc, ad->type); //new CastExp(loc, ue->e1, ad->type); | |
| 6259 ue->e1 = ue->e1->semantic(sc); | |
| 6260 } | |
| 6261 } | |
| 6262 t1 = e1->type; | |
| 6263 } | |
| 6264 else if (e1->op == TOKsuper) | |
| 6265 { | |
| 6266 // Base class constructor call | |
| 6267 ClassDeclaration *cd = NULL; | |
| 6268 | |
| 6269 if (sc->func) | |
| 6270 cd = sc->func->toParent()->isClassDeclaration(); | |
| 6271 if (!cd || !cd->baseClass || !sc->func->isCtorDeclaration()) | |
| 6272 { | |
| 6273 error("super class constructor call must be in a constructor"); | |
| 6274 type = Type::terror; | |
| 6275 return this; | |
| 6276 } | |
| 6277 else | |
| 6278 { | |
| 6279 f = cd->baseClass->ctor; | |
| 6280 if (!f) | |
| 6281 { error("no super class constructor for %s", cd->baseClass->toChars()); | |
| 6282 type = Type::terror; | |
| 6283 return this; | |
| 6284 } | |
| 6285 else | |
| 6286 { | |
| 336 | 6287 if (!sc->intypeof) |
| 6288 { | |
| 159 | 6289 #if 0 |
| 336 | 6290 if (sc->callSuper & (CSXthis | CSXsuper)) |
| 6291 error("reference to this before super()"); | |
| 159 | 6292 #endif |
| 336 | 6293 if (sc->noctor || sc->callSuper & CSXlabel) |
| 6294 error("constructor calls not allowed in loops or after labels"); | |
| 6295 if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) | |
| 6296 error("multiple constructor calls"); | |
| 6297 sc->callSuper |= CSXany_ctor | CSXsuper_ctor; | |
| 6298 } | |
| 159 | 6299 |
| 6300 f = f->overloadResolve(loc, arguments); | |
| 6301 checkDeprecated(sc, f); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6302 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6303 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6304 #endif |
| 159 | 6305 e1 = new DotVarExp(e1->loc, e1, f); |
| 6306 e1 = e1->semantic(sc); | |
| 6307 t1 = e1->type; | |
| 6308 } | |
| 6309 } | |
| 6310 } | |
| 6311 else if (e1->op == TOKthis) | |
| 6312 { | |
| 6313 // same class constructor call | |
| 6314 ClassDeclaration *cd = NULL; | |
| 6315 | |
| 6316 if (sc->func) | |
| 6317 cd = sc->func->toParent()->isClassDeclaration(); | |
| 6318 if (!cd || !sc->func->isCtorDeclaration()) | |
| 6319 { | |
| 6320 error("class constructor call must be in a constructor"); | |
| 6321 type = Type::terror; | |
| 6322 return this; | |
| 6323 } | |
| 6324 else | |
| 6325 { | |
| 336 | 6326 if (!sc->intypeof) |
| 6327 { | |
| 159 | 6328 #if 0 |
| 336 | 6329 if (sc->callSuper & (CSXthis | CSXsuper)) |
| 6330 error("reference to this before super()"); | |
| 159 | 6331 #endif |
| 336 | 6332 if (sc->noctor || sc->callSuper & CSXlabel) |
| 6333 error("constructor calls not allowed in loops or after labels"); | |
| 6334 if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor)) | |
| 6335 error("multiple constructor calls"); | |
| 6336 sc->callSuper |= CSXany_ctor | CSXthis_ctor; | |
| 6337 } | |
| 159 | 6338 |
| 6339 f = cd->ctor; | |
| 6340 f = f->overloadResolve(loc, arguments); | |
| 6341 checkDeprecated(sc, f); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6342 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6343 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6344 #endif |
| 159 | 6345 e1 = new DotVarExp(e1->loc, e1, f); |
| 6346 e1 = e1->semantic(sc); | |
| 6347 t1 = e1->type; | |
| 6348 | |
| 6349 // BUG: this should really be done by checking the static | |
| 6350 // call graph | |
| 6351 if (f == sc->func) | |
| 6352 error("cyclic constructor call"); | |
| 6353 } | |
| 6354 } | |
| 6355 else if (!t1) | |
| 6356 { | |
| 6357 error("function expected before (), not '%s'", e1->toChars()); | |
| 6358 type = Type::terror; | |
| 6359 return this; | |
| 6360 } | |
| 6361 else if (t1->ty != Tfunction) | |
| 6362 { | |
| 6363 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
|
6364 { 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
|
6365 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
|
6366 tf = (TypeFunction *)(td->next); |
| 159 | 6367 goto Lcheckargs; |
| 6368 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6369 else if (t1->ty == Tpointer && ((TypePointer *)t1)->next->ty == Tfunction) |
| 159 | 6370 { Expression *e; |
| 6371 | |
| 6372 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
|
6373 t1 = ((TypePointer *)t1)->next; |
| 159 | 6374 e->type = t1; |
| 6375 e1 = e; | |
| 6376 } | |
| 6377 else if (e1->op == TOKtemplate) | |
| 6378 { | |
| 6379 TemplateExp *te = (TemplateExp *)e1; | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6380 f = te->td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); |
| 159 | 6381 if (!f) |
| 6382 { type = Type::terror; | |
| 6383 return this; | |
| 6384 } | |
| 6385 if (f->needThis() && hasThis(sc)) | |
| 6386 { | |
| 6387 // Supply an implicit 'this', as in | |
| 6388 // this.ident | |
| 6389 | |
| 6390 e1 = new DotTemplateExp(loc, (new ThisExp(loc))->semantic(sc), te->td); | |
| 6391 goto Lagain; | |
| 6392 } | |
| 6393 | |
| 6394 e1 = new VarExp(loc, f); | |
| 6395 goto Lagain; | |
| 6396 } | |
| 6397 else | |
| 6398 { error("function expected before (), not %s of type %s", e1->toChars(), e1->type->toChars()); | |
| 6399 type = Type::terror; | |
| 6400 return this; | |
| 6401 } | |
| 6402 } | |
| 6403 else if (e1->op == TOKvar) | |
| 6404 { | |
| 6405 // Do overload resolution | |
| 6406 VarExp *ve = (VarExp *)e1; | |
| 6407 | |
| 6408 f = ve->var->isFuncDeclaration(); | |
| 6409 assert(f); | |
| 6410 | |
| 6411 // Look to see if f is really a function template | |
| 6412 if (0 && !istemp && f->parent) | |
| 6413 { TemplateInstance *ti = f->parent->isTemplateInstance(); | |
| 6414 | |
| 6415 if (ti && | |
| 6416 (ti->name == f->ident || | |
| 6417 ti->toAlias()->ident == f->ident) | |
| 6418 && | |
| 6419 ti->tempdecl) | |
| 6420 { | |
| 6421 /* This is so that one can refer to the enclosing | |
| 6422 * template, even if it has the same name as a member | |
| 6423 * of the template, if it has a !(arguments) | |
| 6424 */ | |
| 6425 TemplateDeclaration *tempdecl = ti->tempdecl; | |
| 6426 if (tempdecl->overroot) // if not start of overloaded list of TemplateDeclaration's | |
| 6427 tempdecl = tempdecl->overroot; // then get the start | |
| 6428 e1 = new TemplateExp(loc, tempdecl); | |
| 6429 istemp = 1; | |
| 6430 goto Lagain; | |
| 6431 } | |
| 6432 } | |
| 6433 | |
| 6434 f = f->overloadResolve(loc, arguments); | |
| 6435 checkDeprecated(sc, f); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6436 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6437 checkPurity(sc, f); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6438 #endif |
| 159 | 6439 |
| 6440 if (f->needThis() && hasThis(sc)) | |
| 6441 { | |
| 6442 // Supply an implicit 'this', as in | |
| 6443 // this.ident | |
| 6444 | |
| 6445 e1 = new DotVarExp(loc, new ThisExp(loc), f); | |
| 6446 goto Lagain; | |
| 6447 } | |
| 6448 | |
| 6449 accessCheck(loc, sc, NULL, f); | |
| 6450 | |
| 6451 ve->var = f; | |
| 6452 ve->type = f->type; | |
| 6453 t1 = f->type; | |
| 6454 } | |
| 6455 assert(t1->ty == Tfunction); | |
| 6456 tf = (TypeFunction *)(t1); | |
| 6457 | |
| 6458 Lcheckargs: | |
| 6459 assert(tf->ty == Tfunction); | |
| 6460 type = tf->next; | |
| 6461 | |
| 6462 if (!arguments) | |
| 6463 arguments = new Expressions(); | |
| 6464 functionArguments(loc, sc, tf, arguments); | |
| 6465 | |
| 6466 assert(type); | |
| 6467 | |
| 6468 if (f && f->tintro) | |
| 6469 { | |
| 6470 Type *t = type; | |
| 6471 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
|
6472 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
|
6473 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6474 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
|
6475 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
6476 type = tf->next; |
| 159 | 6477 return castTo(sc, t); |
| 6478 } | |
| 6479 } | |
| 6480 | |
| 6481 return this; | |
| 6482 } | |
| 6483 | |
| 6484 int CallExp::checkSideEffect(int flag) | |
| 6485 { | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6486 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6487 if (flag != 2) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6488 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6489 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6490 if (e1->checkSideEffect(2)) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6491 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6492 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6493 /* 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
|
6494 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6495 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
|
6496 { Expression *e = (Expression *)arguments->data[i]; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6497 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6498 if (e->checkSideEffect(2)) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6499 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6500 } |
|
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 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
|
6503 * then this expression has no side effects. |
|
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 Type *t = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6506 if (t->ty == Tfunction && ((TypeFunction *)t)->ispure) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6507 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6508 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
|
6509 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6510 #endif |
| 159 | 6511 return 1; |
| 6512 } | |
| 6513 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6514 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6515 int CallExp::canThrow() |
|
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 if (e1->canThrow()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6518 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6519 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6520 /* 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
|
6521 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6522 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
|
6523 { Expression *e = (Expression *)arguments->data[i]; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6524 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6525 if (e->canThrow()) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6526 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6527 } |
|
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 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
|
6530 * then this expression cannot throw. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6531 * Note that pure functions can throw. |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6532 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6533 Type *t = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6534 if (t->ty == Tfunction && ((TypeFunction *)t)->isnothrow) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6535 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6536 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
|
6537 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6538 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6539 return 1; |
|
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 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6542 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6543 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6544 int CallExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6545 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6546 if (type->toBasetype()->ty == Tstruct) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6547 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6548 Type *tb = e1->type->toBasetype(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6549 if (tb->ty == Tfunction && ((TypeFunction *)tb)->isref) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6550 return 1; // function returns a reference |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6551 return 0; |
|
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 |
| 159 | 6555 Expression *CallExp::toLvalue(Scope *sc, Expression *e) |
| 6556 { | |
| 6557 if (type->toBasetype()->ty == Tstruct) | |
| 6558 return this; | |
| 6559 else | |
| 6560 return Expression::toLvalue(sc, e); | |
| 6561 } | |
| 6562 | |
| 6563 void CallExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 6564 { int i; | |
| 6565 | |
| 6566 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6567 buf->writeByte('('); | |
| 6568 argsToCBuffer(buf, arguments, hgs); | |
| 6569 buf->writeByte(')'); | |
| 6570 } | |
| 6571 | |
| 6572 | |
| 6573 /************************************************************/ | |
| 6574 | |
| 6575 AddrExp::AddrExp(Loc loc, Expression *e) | |
| 6576 : UnaExp(loc, TOKaddress, sizeof(AddrExp), e) | |
| 6577 { | |
| 6578 } | |
| 6579 | |
| 6580 Expression *AddrExp::semantic(Scope *sc) | |
| 6581 { | |
| 6582 #if LOGSEMANTIC | |
| 6583 printf("AddrExp::semantic('%s')\n", toChars()); | |
| 6584 #endif | |
| 6585 if (!type) | |
| 6586 { | |
| 6587 UnaExp::semantic(sc); | |
| 6588 e1 = e1->toLvalue(sc, NULL); | |
| 6589 if (!e1->type) | |
| 6590 { | |
| 6591 error("cannot take address of %s", e1->toChars()); | |
| 6592 type = Type::tint32; | |
| 6593 return this; | |
| 6594 } | |
| 6595 type = e1->type->pointerTo(); | |
| 6596 | |
| 6597 // See if this should really be a delegate | |
| 6598 if (e1->op == TOKdotvar) | |
| 6599 { | |
| 6600 DotVarExp *dve = (DotVarExp *)e1; | |
| 6601 FuncDeclaration *f = dve->var->isFuncDeclaration(); | |
| 6602 | |
| 6603 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
|
6604 { Expression *e = new DelegateExp(loc, dve->e1, f); |
| 159 | 6605 e = e->semantic(sc); |
| 6606 return e; | |
| 6607 } | |
| 6608 } | |
| 6609 else if (e1->op == TOKvar) | |
| 6610 { | |
| 6611 VarExp *dve = (VarExp *)e1; | |
| 6612 FuncDeclaration *f = dve->var->isFuncDeclaration(); | |
| 6613 VarDeclaration *v = dve->var->isVarDeclaration(); | |
| 6614 | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
6615 // 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
|
6616 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
|
6617 { |
|
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
|
6618 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
|
6619 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
|
6620 } |
|
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
|
6621 |
| 159 | 6622 if (f && f->isNested()) |
| 6623 { Expression *e; | |
| 6624 | |
| 6625 e = new DelegateExp(loc, e1, f); | |
| 6626 e = e->semantic(sc); | |
| 6627 return e; | |
| 6628 } | |
| 6629 } | |
| 6630 else if (e1->op == TOKarray) | |
| 6631 { | |
| 6632 if (e1->type->toBasetype()->ty == Tbit) | |
| 6633 error("cannot take address of bit in array"); | |
| 6634 } | |
| 6635 return optimize(WANTvalue); | |
| 6636 } | |
| 6637 return this; | |
| 6638 } | |
| 6639 | |
| 6640 /************************************************************/ | |
| 6641 | |
| 6642 PtrExp::PtrExp(Loc loc, Expression *e) | |
| 6643 : UnaExp(loc, TOKstar, sizeof(PtrExp), e) | |
| 6644 { | |
| 6645 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
|
6646 type = ((TypePointer *)e->type)->next; |
| 159 | 6647 } |
| 6648 | |
| 6649 PtrExp::PtrExp(Loc loc, Expression *e, Type *t) | |
| 6650 : UnaExp(loc, TOKstar, sizeof(PtrExp), e) | |
| 6651 { | |
| 6652 type = t; | |
| 6653 } | |
| 6654 | |
| 6655 Expression *PtrExp::semantic(Scope *sc) | |
| 6656 { Type *tb; | |
| 6657 | |
| 6658 #if LOGSEMANTIC | |
| 6659 printf("PtrExp::semantic('%s')\n", toChars()); | |
| 6660 #endif | |
| 6661 UnaExp::semantic(sc); | |
| 6662 e1 = resolveProperties(sc, e1); | |
| 6663 if (type) | |
| 6664 return this; | |
| 6665 if (!e1->type) | |
| 6666 printf("PtrExp::semantic('%s')\n", toChars()); | |
| 6667 tb = e1->type->toBasetype(); | |
| 6668 switch (tb->ty) | |
| 6669 { | |
| 6670 case Tpointer: | |
| 6671 type = tb->next; | |
| 6672 if (type->isbit()) | |
| 6673 { Expression *e; | |
| 6674 | |
| 6675 // Rewrite *p as p[0] | |
| 6676 e = new IndexExp(loc, e1, new IntegerExp(0)); | |
| 6677 return e->semantic(sc); | |
| 6678 } | |
| 6679 break; | |
| 6680 | |
| 6681 case Tsarray: | |
| 6682 case Tarray: | |
| 6683 type = tb->next; | |
| 6684 e1 = e1->castTo(sc, type->pointerTo()); | |
| 6685 break; | |
| 6686 | |
| 6687 default: | |
| 6688 error("can only * a pointer, not a '%s'", e1->type->toChars()); | |
| 6689 type = Type::tint32; | |
| 6690 break; | |
| 6691 } | |
| 6692 rvalue(); | |
| 6693 return this; | |
| 6694 } | |
| 6695 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6696 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6697 int PtrExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6698 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6699 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6700 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6701 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6702 |
| 159 | 6703 Expression *PtrExp::toLvalue(Scope *sc, Expression *e) |
| 6704 { | |
| 6705 #if 0 | |
| 6706 tym = tybasic(e1->ET->Tty); | |
| 6707 if (!(tyscalar(tym) || | |
| 6708 tym == TYstruct || | |
| 6709 tym == TYarray && e->Eoper == TOKaddr)) | |
| 6710 synerr(EM_lvalue); // lvalue expected | |
| 6711 #endif | |
| 6712 return this; | |
| 6713 } | |
| 6714 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6715 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6716 Expression *PtrExp::modifiableLvalue(Scope *sc, Expression *e) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6717 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6718 //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
|
6719 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6720 if (e1->op == TOKsymoff) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6721 { SymOffExp *se = (SymOffExp *)e1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6722 se->var->checkModify(loc, sc, type); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6723 //return toLvalue(sc, e); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6724 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6725 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6726 return Expression::modifiableLvalue(sc, e); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6727 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6728 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6729 |
| 159 | 6730 void PtrExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 6731 { | |
| 6732 buf->writeByte('*'); | |
| 6733 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6734 } | |
| 6735 | |
| 6736 /************************************************************/ | |
| 6737 | |
| 6738 NegExp::NegExp(Loc loc, Expression *e) | |
| 6739 : UnaExp(loc, TOKneg, sizeof(NegExp), e) | |
| 6740 { | |
| 6741 } | |
| 6742 | |
| 6743 Expression *NegExp::semantic(Scope *sc) | |
| 6744 { Expression *e; | |
| 6745 | |
| 6746 #if LOGSEMANTIC | |
| 6747 printf("NegExp::semantic('%s')\n", toChars()); | |
| 6748 #endif | |
| 6749 if (!type) | |
| 6750 { | |
| 6751 UnaExp::semantic(sc); | |
| 6752 e1 = resolveProperties(sc, e1); | |
| 6753 e = op_overload(sc); | |
| 6754 if (e) | |
| 6755 return e; | |
| 6756 | |
| 6757 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
|
6758 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
|
6759 e1->checkArithmetic(); |
| 159 | 6760 type = e1->type; |
| 6761 } | |
| 6762 return this; | |
| 6763 } | |
| 6764 | |
| 6765 /************************************************************/ | |
| 6766 | |
| 6767 UAddExp::UAddExp(Loc loc, Expression *e) | |
| 6768 : UnaExp(loc, TOKuadd, sizeof(UAddExp), e) | |
| 6769 { | |
| 6770 } | |
| 6771 | |
| 6772 Expression *UAddExp::semantic(Scope *sc) | |
| 6773 { Expression *e; | |
| 6774 | |
| 6775 #if LOGSEMANTIC | |
| 6776 printf("UAddExp::semantic('%s')\n", toChars()); | |
| 6777 #endif | |
| 6778 assert(!type); | |
| 6779 UnaExp::semantic(sc); | |
| 6780 e1 = resolveProperties(sc, e1); | |
| 6781 e = op_overload(sc); | |
| 6782 if (e) | |
| 6783 return e; | |
| 6784 e1->checkNoBool(); | |
| 6785 e1->checkArithmetic(); | |
| 6786 return e1; | |
| 6787 } | |
| 6788 | |
| 6789 /************************************************************/ | |
| 6790 | |
| 6791 ComExp::ComExp(Loc loc, Expression *e) | |
| 6792 : UnaExp(loc, TOKtilde, sizeof(ComExp), e) | |
| 6793 { | |
| 6794 } | |
| 6795 | |
| 6796 Expression *ComExp::semantic(Scope *sc) | |
| 6797 { Expression *e; | |
| 6798 | |
| 6799 if (!type) | |
| 6800 { | |
| 6801 UnaExp::semantic(sc); | |
| 6802 e1 = resolveProperties(sc, e1); | |
| 6803 e = op_overload(sc); | |
| 6804 if (e) | |
| 6805 return e; | |
| 6806 | |
| 6807 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
|
6808 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
|
6809 e1 = e1->checkIntegral(); |
| 159 | 6810 type = e1->type; |
| 6811 } | |
| 6812 return this; | |
| 6813 } | |
| 6814 | |
| 6815 /************************************************************/ | |
| 6816 | |
| 6817 NotExp::NotExp(Loc loc, Expression *e) | |
| 6818 : UnaExp(loc, TOKnot, sizeof(NotExp), e) | |
| 6819 { | |
| 6820 } | |
| 6821 | |
| 6822 Expression *NotExp::semantic(Scope *sc) | |
| 6823 { | |
| 6824 UnaExp::semantic(sc); | |
| 6825 e1 = resolveProperties(sc, e1); | |
| 6826 e1 = e1->checkToBoolean(); | |
| 6827 type = Type::tboolean; | |
| 6828 return this; | |
| 6829 } | |
| 6830 | |
| 6831 int NotExp::isBit() | |
| 6832 { | |
| 6833 return TRUE; | |
| 6834 } | |
| 6835 | |
| 6836 | |
| 6837 | |
| 6838 /************************************************************/ | |
| 6839 | |
| 6840 BoolExp::BoolExp(Loc loc, Expression *e, Type *t) | |
| 6841 : UnaExp(loc, TOKtobool, sizeof(BoolExp), e) | |
| 6842 { | |
| 6843 type = t; | |
| 6844 } | |
| 6845 | |
| 6846 Expression *BoolExp::semantic(Scope *sc) | |
| 6847 { | |
| 6848 UnaExp::semantic(sc); | |
| 6849 e1 = resolveProperties(sc, e1); | |
| 6850 e1 = e1->checkToBoolean(); | |
| 6851 type = Type::tboolean; | |
| 6852 return this; | |
| 6853 } | |
| 6854 | |
| 6855 int BoolExp::isBit() | |
| 6856 { | |
| 6857 return TRUE; | |
| 6858 } | |
| 6859 | |
| 6860 /************************************************************/ | |
| 6861 | |
| 6862 DeleteExp::DeleteExp(Loc loc, Expression *e) | |
| 6863 : UnaExp(loc, TOKdelete, sizeof(DeleteExp), e) | |
| 6864 { | |
| 6865 } | |
| 6866 | |
| 6867 Expression *DeleteExp::semantic(Scope *sc) | |
| 6868 { | |
| 6869 Type *tb; | |
| 6870 | |
| 6871 UnaExp::semantic(sc); | |
| 6872 e1 = resolveProperties(sc, e1); | |
| 6873 e1 = e1->toLvalue(sc, NULL); | |
| 6874 type = Type::tvoid; | |
| 6875 | |
| 6876 tb = e1->type->toBasetype(); | |
| 6877 switch (tb->ty) | |
| 6878 { case Tclass: | |
| 6879 { TypeClass *tc = (TypeClass *)tb; | |
| 6880 ClassDeclaration *cd = tc->sym; | |
| 6881 | |
| 6882 if (cd->isCOMinterface()) | |
| 6883 { /* Because COM classes are deleted by IUnknown.Release() | |
| 6884 */ | |
| 6885 error("cannot delete instance of COM interface %s", cd->toChars()); | |
| 6886 } | |
| 6887 break; | |
| 6888 } | |
| 6889 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
|
6890 tb = ((TypePointer *)tb)->next->toBasetype(); |
| 159 | 6891 if (tb->ty == Tstruct) |
| 6892 { | |
| 6893 TypeStruct *ts = (TypeStruct *)tb; | |
| 6894 StructDeclaration *sd = ts->sym; | |
| 6895 FuncDeclaration *f = sd->aggDelete; | |
| 6896 | |
| 6897 if (f) | |
| 6898 { | |
| 6899 Type *tpv = Type::tvoid->pointerTo(); | |
| 6900 | |
| 6901 Expression *e = e1->castTo(sc, tpv); | |
| 6902 Expression *ec = new VarExp(loc, f); | |
| 6903 e = new CallExp(loc, ec, e); | |
| 6904 return e->semantic(sc); | |
| 6905 } | |
| 6906 } | |
| 6907 break; | |
| 6908 | |
| 6909 case Tarray: | |
| 6910 break; | |
| 6911 | |
| 6912 default: | |
| 6913 if (e1->op == TOKindex) | |
| 6914 { | |
| 6915 IndexExp *ae = (IndexExp *)(e1); | |
| 6916 Type *tb1 = ae->e1->type->toBasetype(); | |
| 6917 if (tb1->ty == Taarray) | |
| 6918 break; | |
| 6919 } | |
| 6920 error("cannot delete type %s", e1->type->toChars()); | |
| 6921 break; | |
| 6922 } | |
| 6923 | |
| 6924 if (e1->op == TOKindex) | |
| 6925 { | |
| 6926 IndexExp *ae = (IndexExp *)(e1); | |
| 6927 Type *tb1 = ae->e1->type->toBasetype(); | |
| 6928 if (tb1->ty == Taarray) | |
| 6929 { if (!global.params.useDeprecated) | |
| 6930 error("delete aa[key] deprecated, use aa.remove(key)"); | |
| 6931 } | |
| 6932 } | |
| 6933 | |
| 6934 return this; | |
| 6935 } | |
| 6936 | |
| 6937 int DeleteExp::checkSideEffect(int flag) | |
| 6938 { | |
| 6939 return 1; | |
| 6940 } | |
| 6941 | |
| 6942 Expression *DeleteExp::checkToBoolean() | |
| 6943 { | |
| 6944 error("delete does not give a boolean result"); | |
| 6945 return this; | |
| 6946 } | |
| 6947 | |
| 6948 void DeleteExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 6949 { | |
| 6950 buf->writestring("delete "); | |
| 6951 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 6952 } | |
| 6953 | |
| 6954 /************************************************************/ | |
| 6955 | |
| 6956 CastExp::CastExp(Loc loc, Expression *e, Type *t) | |
| 6957 : UnaExp(loc, TOKcast, sizeof(CastExp), e) | |
| 6958 { | |
| 6959 to = t; | |
| 6960 } | |
| 6961 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6962 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6963 /* For cast(const) and cast(immutable) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6964 */ |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6965 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
|
6966 : UnaExp(loc, TOKcast, sizeof(CastExp), e) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6967 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6968 to = NULL; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6969 this->mod = mod; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6970 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6971 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
6972 |
| 159 | 6973 Expression *CastExp::syntaxCopy() |
| 6974 { | |
| 6975 return new CastExp(loc, e1->syntaxCopy(), to->syntaxCopy()); | |
| 6976 } | |
| 6977 | |
| 6978 | |
| 6979 Expression *CastExp::semantic(Scope *sc) | |
| 6980 { Expression *e; | |
| 6981 BinExp *b; | |
| 6982 UnaExp *u; | |
| 6983 | |
| 6984 #if LOGSEMANTIC | |
| 6985 printf("CastExp::semantic('%s')\n", toChars()); | |
| 6986 #endif | |
| 6987 | |
| 6988 //static int x; assert(++x < 10); | |
| 6989 | |
| 6990 if (type) | |
| 6991 return this; | |
| 6992 UnaExp::semantic(sc); | |
| 6993 if (e1->type) // if not a tuple | |
| 6994 { | |
| 6995 e1 = resolveProperties(sc, e1); | |
| 6996 to = to->semantic(loc, sc); | |
| 6997 | |
| 6998 e = op_overload(sc); | |
| 6999 if (e) | |
| 7000 { | |
| 7001 return e->implicitCastTo(sc, to); | |
| 7002 } | |
| 7003 | |
| 7004 Type *tob = to->toBasetype(); | |
| 7005 if (tob->ty == Tstruct && | |
| 7006 !tob->equals(e1->type->toBasetype()) && | |
| 7007 ((TypeStruct *)to)->sym->search(0, Id::call, 0) | |
| 7008 ) | |
| 7009 { | |
| 7010 /* Look to replace: | |
| 7011 * cast(S)t | |
| 7012 * with: | |
| 7013 * S(t) | |
| 7014 */ | |
| 7015 | |
| 7016 // Rewrite as to.call(e1) | |
| 7017 e = new TypeExp(loc, to); | |
| 7018 e = new DotIdExp(loc, e, Id::call); | |
| 7019 e = new CallExp(loc, e, e1); | |
| 7020 e = e->semantic(sc); | |
| 7021 return e; | |
| 7022 } | |
| 7023 } | |
| 7024 e = e1->castTo(sc, to); | |
| 7025 return e; | |
| 7026 } | |
| 7027 | |
| 7028 int CastExp::checkSideEffect(int flag) | |
| 7029 { | |
| 7030 /* if not: | |
| 7031 * cast(void) | |
| 7032 * cast(classtype)func() | |
| 7033 */ | |
| 7034 if (!to->equals(Type::tvoid) && | |
| 7035 !(to->ty == Tclass && e1->op == TOKcall && e1->type->ty == Tclass)) | |
| 7036 return Expression::checkSideEffect(flag); | |
| 7037 return 1; | |
| 7038 } | |
| 7039 | |
| 7040 void CastExp::checkEscape() | |
| 7041 { Type *tb = type->toBasetype(); | |
| 7042 if (tb->ty == Tarray && e1->op == TOKvar && | |
| 7043 e1->type->toBasetype()->ty == Tsarray) | |
| 7044 { VarExp *ve = (VarExp *)e1; | |
| 7045 VarDeclaration *v = ve->var->isVarDeclaration(); | |
| 7046 if (v) | |
| 7047 { | |
| 7048 if (!v->isDataseg() && !v->isParameter()) | |
| 7049 error("escaping reference to local %s", v->toChars()); | |
| 7050 } | |
| 7051 } | |
| 7052 } | |
| 7053 | |
| 7054 void CastExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7055 { | |
| 7056 buf->writestring("cast("); | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7057 #if DMDV1 |
| 159 | 7058 to->toCBuffer(buf, NULL, hgs); |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7059 #else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7060 if (to) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7061 to->toCBuffer(buf, NULL, hgs); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7062 else |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7063 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7064 switch (mod) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7065 { case 0: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7066 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7067 case MODconst: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7068 buf->writestring(Token::tochars[TOKconst]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7069 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7070 case MODinvariant: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7071 buf->writestring(Token::tochars[TOKimmutable]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7072 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7073 case MODshared: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7074 buf->writestring(Token::tochars[TOKshared]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7075 break; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7076 case MODshared | MODconst: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7077 buf->writestring(Token::tochars[TOKshared]); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7078 buf->writeByte(' '); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7079 buf->writestring(Token::tochars[TOKconst]); |
|
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 default: |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7082 assert(0); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7083 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7084 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7085 #endif |
| 159 | 7086 buf->writeByte(')'); |
| 7087 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7088 } | |
| 7089 | |
| 7090 | |
| 7091 /************************************************************/ | |
| 7092 | |
| 7093 SliceExp::SliceExp(Loc loc, Expression *e1, Expression *lwr, Expression *upr) | |
| 7094 : UnaExp(loc, TOKslice, sizeof(SliceExp), e1) | |
| 7095 { | |
| 7096 this->upr = upr; | |
| 7097 this->lwr = lwr; | |
| 7098 lengthVar = NULL; | |
| 7099 } | |
| 7100 | |
| 7101 Expression *SliceExp::syntaxCopy() | |
| 7102 { | |
| 7103 Expression *lwr = NULL; | |
| 7104 if (this->lwr) | |
| 7105 lwr = this->lwr->syntaxCopy(); | |
| 7106 | |
| 7107 Expression *upr = NULL; | |
| 7108 if (this->upr) | |
| 7109 upr = this->upr->syntaxCopy(); | |
| 7110 | |
| 7111 return new SliceExp(loc, e1->syntaxCopy(), lwr, upr); | |
| 7112 } | |
| 7113 | |
| 7114 Expression *SliceExp::semantic(Scope *sc) | |
| 7115 { Expression *e; | |
| 7116 AggregateDeclaration *ad; | |
| 7117 //FuncDeclaration *fd; | |
| 7118 ScopeDsymbol *sym; | |
| 7119 | |
| 7120 #if LOGSEMANTIC | |
| 7121 printf("SliceExp::semantic('%s')\n", toChars()); | |
| 7122 #endif | |
| 7123 if (type) | |
| 7124 return this; | |
| 7125 | |
| 7126 UnaExp::semantic(sc); | |
| 7127 e1 = resolveProperties(sc, e1); | |
| 7128 | |
| 7129 e = this; | |
| 7130 | |
| 7131 Type *t = e1->type->toBasetype(); | |
| 7132 if (t->ty == Tpointer) | |
| 7133 { | |
| 7134 if (!lwr || !upr) | |
| 7135 error("need upper and lower bound to slice pointer"); | |
| 7136 } | |
| 7137 else if (t->ty == Tarray) | |
| 7138 { | |
| 7139 } | |
| 7140 else if (t->ty == Tsarray) | |
| 7141 { | |
| 7142 } | |
| 7143 else if (t->ty == Tclass) | |
| 7144 { | |
| 7145 ad = ((TypeClass *)t)->sym; | |
| 7146 goto L1; | |
| 7147 } | |
| 7148 else if (t->ty == Tstruct) | |
| 7149 { | |
| 7150 ad = ((TypeStruct *)t)->sym; | |
| 7151 | |
| 7152 L1: | |
| 7153 if (search_function(ad, Id::slice)) | |
| 7154 { | |
| 7155 // Rewrite as e1.slice(lwr, upr) | |
| 7156 e = new DotIdExp(loc, e1, Id::slice); | |
| 7157 | |
| 7158 if (lwr) | |
| 7159 { | |
| 7160 assert(upr); | |
| 7161 e = new CallExp(loc, e, lwr, upr); | |
| 7162 } | |
| 7163 else | |
| 7164 { assert(!upr); | |
| 7165 e = new CallExp(loc, e); | |
| 7166 } | |
| 7167 e = e->semantic(sc); | |
| 7168 return e; | |
| 7169 } | |
| 7170 goto Lerror; | |
| 7171 } | |
| 7172 else if (t->ty == Ttuple) | |
| 7173 { | |
| 7174 if (!lwr && !upr) | |
| 7175 return e1; | |
| 7176 if (!lwr || !upr) | |
| 7177 { error("need upper and lower bound to slice tuple"); | |
| 7178 goto Lerror; | |
| 7179 } | |
| 7180 } | |
| 7181 else | |
| 7182 goto Lerror; | |
| 7183 | |
| 7184 if (t->ty == Tsarray || t->ty == Tarray || t->ty == Ttuple) | |
| 7185 { | |
| 7186 sym = new ArrayScopeSymbol(this); | |
| 7187 sym->loc = loc; | |
| 7188 sym->parent = sc->scopesym; | |
| 7189 sc = sc->push(sym); | |
| 7190 } | |
| 7191 | |
| 7192 if (lwr) | |
| 7193 { lwr = lwr->semantic(sc); | |
| 7194 lwr = resolveProperties(sc, lwr); | |
| 7195 lwr = lwr->implicitCastTo(sc, Type::tsize_t); | |
| 7196 } | |
| 7197 if (upr) | |
| 7198 { upr = upr->semantic(sc); | |
| 7199 upr = resolveProperties(sc, upr); | |
| 7200 upr = upr->implicitCastTo(sc, Type::tsize_t); | |
| 7201 } | |
| 7202 | |
| 7203 if (t->ty == Tsarray || t->ty == Tarray || t->ty == Ttuple) | |
| 7204 sc->pop(); | |
| 7205 | |
| 7206 if (t->ty == Ttuple) | |
| 7207 { | |
| 7208 lwr = lwr->optimize(WANTvalue); | |
| 7209 upr = upr->optimize(WANTvalue); | |
| 7210 uinteger_t i1 = lwr->toUInteger(); | |
| 7211 uinteger_t i2 = upr->toUInteger(); | |
| 7212 | |
| 7213 size_t length; | |
| 7214 TupleExp *te; | |
| 7215 TypeTuple *tup; | |
| 7216 | |
| 7217 if (e1->op == TOKtuple) // slicing an expression tuple | |
| 7218 { te = (TupleExp *)e1; | |
| 7219 length = te->exps->dim; | |
| 7220 } | |
| 7221 else if (e1->op == TOKtype) // slicing a type tuple | |
| 7222 { tup = (TypeTuple *)t; | |
| 7223 length = Argument::dim(tup->arguments); | |
| 7224 } | |
| 7225 else | |
| 7226 assert(0); | |
| 7227 | |
| 7228 if (i1 <= i2 && i2 <= length) | |
| 7229 { size_t j1 = (size_t) i1; | |
| 7230 size_t j2 = (size_t) i2; | |
| 7231 | |
| 7232 if (e1->op == TOKtuple) | |
| 7233 { Expressions *exps = new Expressions; | |
| 7234 exps->setDim(j2 - j1); | |
| 7235 for (size_t i = 0; i < j2 - j1; i++) | |
| 7236 { Expression *e = (Expression *)te->exps->data[j1 + i]; | |
| 7237 exps->data[i] = (void *)e; | |
| 7238 } | |
| 7239 e = new TupleExp(loc, exps); | |
| 7240 } | |
| 7241 else | |
| 7242 { Arguments *args = new Arguments; | |
| 7243 args->reserve(j2 - j1); | |
| 7244 for (size_t i = j1; i < j2; i++) | |
| 7245 { Argument *arg = Argument::getNth(tup->arguments, i); | |
| 7246 args->push(arg); | |
| 7247 } | |
| 7248 e = new TypeExp(e1->loc, new TypeTuple(args)); | |
| 7249 } | |
| 7250 e = e->semantic(sc); | |
| 7251 } | |
| 7252 else | |
| 7253 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7254 error("string slice [%ju .. %ju] is out of bounds", i1, i2); |
| 159 | 7255 e = e1; |
| 7256 } | |
| 7257 return e; | |
| 7258 } | |
| 7259 | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7260 if (t->ty == Tarray) |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7261 type = e1->type; |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7262 else |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7263 type = t->nextOf()->arrayOf(); |
| 159 | 7264 return e; |
| 7265 | |
| 7266 Lerror: | |
| 7267 char *s; | |
| 7268 if (t->ty == Tvoid) | |
| 7269 s = e1->toChars(); | |
| 7270 else | |
| 7271 s = t->toChars(); | |
| 7272 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
|
7273 e = new IntegerExp(0); |
| 159 | 7274 return e; |
| 7275 } | |
| 7276 | |
| 7277 void SliceExp::checkEscape() | |
| 7278 { | |
| 7279 e1->checkEscape(); | |
| 7280 } | |
| 7281 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7282 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7283 int SliceExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7284 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7285 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7286 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7287 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7288 |
| 159 | 7289 Expression *SliceExp::toLvalue(Scope *sc, Expression *e) |
| 7290 { | |
| 7291 return this; | |
| 7292 } | |
| 7293 | |
| 7294 Expression *SliceExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7295 { | |
| 7296 error("slice expression %s is not a modifiable lvalue", toChars()); | |
| 7297 return this; | |
| 7298 } | |
| 7299 | |
| 7300 void SliceExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7301 { | |
| 7302 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7303 buf->writeByte('['); | |
| 7304 if (upr || lwr) | |
| 7305 { | |
| 7306 if (lwr) | |
| 7307 expToCBuffer(buf, hgs, lwr, PREC_assign); | |
| 7308 else | |
| 7309 buf->writeByte('0'); | |
| 7310 buf->writestring(".."); | |
| 7311 if (upr) | |
| 7312 expToCBuffer(buf, hgs, upr, PREC_assign); | |
| 7313 else | |
| 7314 buf->writestring("length"); // BUG: should be array.length | |
| 7315 } | |
| 7316 buf->writeByte(']'); | |
| 7317 } | |
| 7318 | |
| 7319 /********************** ArrayLength **************************************/ | |
| 7320 | |
| 7321 ArrayLengthExp::ArrayLengthExp(Loc loc, Expression *e1) | |
| 7322 : UnaExp(loc, TOKarraylength, sizeof(ArrayLengthExp), e1) | |
| 7323 { | |
| 7324 } | |
| 7325 | |
| 7326 Expression *ArrayLengthExp::semantic(Scope *sc) | |
| 7327 { Expression *e; | |
| 7328 | |
| 7329 #if LOGSEMANTIC | |
| 7330 printf("ArrayLengthExp::semantic('%s')\n", toChars()); | |
| 7331 #endif | |
| 7332 if (!type) | |
| 7333 { | |
| 7334 UnaExp::semantic(sc); | |
| 7335 e1 = resolveProperties(sc, e1); | |
| 7336 | |
| 7337 type = Type::tsize_t; | |
| 7338 } | |
| 7339 return this; | |
| 7340 } | |
| 7341 | |
| 7342 void ArrayLengthExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7343 { | |
| 7344 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7345 buf->writestring(".length"); | |
| 7346 } | |
| 7347 | |
| 7348 /*********************** ArrayExp *************************************/ | |
| 7349 | |
| 7350 // e1 [ i1, i2, i3, ... ] | |
| 7351 | |
| 7352 ArrayExp::ArrayExp(Loc loc, Expression *e1, Expressions *args) | |
| 7353 : UnaExp(loc, TOKarray, sizeof(ArrayExp), e1) | |
| 7354 { | |
| 7355 arguments = args; | |
| 7356 } | |
| 7357 | |
| 7358 Expression *ArrayExp::syntaxCopy() | |
| 7359 { | |
| 7360 return new ArrayExp(loc, e1->syntaxCopy(), arraySyntaxCopy(arguments)); | |
| 7361 } | |
| 7362 | |
| 7363 Expression *ArrayExp::semantic(Scope *sc) | |
| 7364 { Expression *e; | |
| 7365 Type *t1; | |
| 7366 | |
| 7367 #if LOGSEMANTIC | |
| 7368 printf("ArrayExp::semantic('%s')\n", toChars()); | |
| 7369 #endif | |
| 7370 UnaExp::semantic(sc); | |
| 7371 e1 = resolveProperties(sc, e1); | |
| 7372 | |
| 7373 t1 = e1->type->toBasetype(); | |
| 7374 if (t1->ty != Tclass && t1->ty != Tstruct) | |
| 7375 { // Convert to IndexExp | |
| 7376 if (arguments->dim != 1) | |
| 7377 error("only one index allowed to index %s", t1->toChars()); | |
| 7378 e = new IndexExp(loc, e1, (Expression *)arguments->data[0]); | |
| 7379 return e->semantic(sc); | |
| 7380 } | |
| 7381 | |
| 7382 // Run semantic() on each argument | |
| 7383 for (size_t i = 0; i < arguments->dim; i++) | |
| 7384 { e = (Expression *)arguments->data[i]; | |
| 7385 | |
| 7386 e = e->semantic(sc); | |
| 7387 if (!e->type) | |
| 7388 error("%s has no value", e->toChars()); | |
| 7389 arguments->data[i] = (void *)e; | |
| 7390 } | |
| 7391 | |
| 7392 expandTuples(arguments); | |
| 7393 assert(arguments && arguments->dim); | |
| 7394 | |
| 7395 e = op_overload(sc); | |
| 7396 if (!e) | |
| 7397 { error("no [] operator overload for type %s", e1->type->toChars()); | |
| 7398 e = e1; | |
| 7399 } | |
| 7400 return e; | |
| 7401 } | |
| 7402 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7403 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7404 int ArrayExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7405 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7406 if (type && type->toBasetype()->ty == Tvoid) |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7407 return 0; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7408 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7409 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7410 #endif |
| 159 | 7411 |
| 7412 Expression *ArrayExp::toLvalue(Scope *sc, Expression *e) | |
| 7413 { | |
| 7414 if (type && type->toBasetype()->ty == Tvoid) | |
| 7415 error("voids have no value"); | |
| 7416 return this; | |
| 7417 } | |
| 7418 | |
| 7419 | |
| 7420 void ArrayExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7421 { int i; | |
| 7422 | |
| 7423 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7424 buf->writeByte('['); | |
| 7425 argsToCBuffer(buf, arguments, hgs); | |
| 7426 buf->writeByte(']'); | |
| 7427 } | |
| 7428 | |
| 7429 /************************* DotExp ***********************************/ | |
| 7430 | |
| 7431 DotExp::DotExp(Loc loc, Expression *e1, Expression *e2) | |
| 7432 : BinExp(loc, TOKdotexp, sizeof(DotExp), e1, e2) | |
| 7433 { | |
| 7434 } | |
| 7435 | |
| 7436 Expression *DotExp::semantic(Scope *sc) | |
| 7437 { | |
| 7438 #if LOGSEMANTIC | |
| 7439 printf("DotExp::semantic('%s')\n", toChars()); | |
| 7440 if (type) printf("\ttype = %s\n", type->toChars()); | |
| 7441 #endif | |
| 7442 e1 = e1->semantic(sc); | |
| 7443 e2 = e2->semantic(sc); | |
| 7444 if (e2->op == TOKimport) | |
| 7445 { | |
| 7446 ScopeExp *se = (ScopeExp *)e2; | |
| 7447 TemplateDeclaration *td = se->sds->isTemplateDeclaration(); | |
| 7448 if (td) | |
| 7449 { Expression *e = new DotTemplateExp(loc, e1, td); | |
| 7450 e = e->semantic(sc); | |
| 7451 return e; | |
| 7452 } | |
| 7453 } | |
| 7454 if (!type) | |
| 7455 type = e2->type; | |
| 7456 return this; | |
| 7457 } | |
| 7458 | |
| 7459 | |
| 7460 /************************* CommaExp ***********************************/ | |
| 7461 | |
| 7462 CommaExp::CommaExp(Loc loc, Expression *e1, Expression *e2) | |
| 7463 : BinExp(loc, TOKcomma, sizeof(CommaExp), e1, e2) | |
| 7464 { | |
| 7465 } | |
| 7466 | |
| 7467 Expression *CommaExp::semantic(Scope *sc) | |
| 7468 { | |
| 7469 if (!type) | |
| 7470 { BinExp::semanticp(sc); | |
| 7471 type = e2->type; | |
| 7472 } | |
| 7473 return this; | |
| 7474 } | |
| 7475 | |
| 7476 void CommaExp::checkEscape() | |
| 7477 { | |
| 7478 e2->checkEscape(); | |
| 7479 } | |
| 7480 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7481 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7482 int CommaExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7483 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7484 return e2->isLvalue(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7485 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7486 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7487 |
| 159 | 7488 Expression *CommaExp::toLvalue(Scope *sc, Expression *e) |
| 7489 { | |
| 7490 e2 = e2->toLvalue(sc, NULL); | |
| 7491 return this; | |
| 7492 } | |
| 7493 | |
| 7494 Expression *CommaExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7495 { | |
| 7496 e2 = e2->modifiableLvalue(sc, e); | |
| 7497 return this; | |
| 7498 } | |
| 7499 | |
| 7500 int CommaExp::isBool(int result) | |
| 7501 { | |
| 7502 return e2->isBool(result); | |
| 7503 } | |
| 7504 | |
| 7505 int CommaExp::checkSideEffect(int flag) | |
| 7506 { | |
| 7507 if (flag == 2) | |
| 7508 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 7509 else | |
| 7510 { | |
| 7511 // Don't check e1 until we cast(void) the a,b code generation | |
| 7512 return e2->checkSideEffect(flag); | |
| 7513 } | |
| 7514 } | |
| 7515 | |
| 7516 /************************** IndexExp **********************************/ | |
| 7517 | |
| 7518 // e1 [ e2 ] | |
| 7519 | |
| 7520 IndexExp::IndexExp(Loc loc, Expression *e1, Expression *e2) | |
| 7521 : BinExp(loc, TOKindex, sizeof(IndexExp), e1, e2) | |
| 7522 { | |
| 7523 //printf("IndexExp::IndexExp('%s')\n", toChars()); | |
| 7524 lengthVar = NULL; | |
| 7525 modifiable = 0; // assume it is an rvalue | |
| 7526 } | |
| 7527 | |
| 7528 Expression *IndexExp::semantic(Scope *sc) | |
| 7529 { Expression *e; | |
| 7530 BinExp *b; | |
| 7531 UnaExp *u; | |
| 7532 Type *t1; | |
| 7533 ScopeDsymbol *sym; | |
| 7534 | |
| 7535 #if LOGSEMANTIC | |
| 7536 printf("IndexExp::semantic('%s')\n", toChars()); | |
| 7537 #endif | |
| 7538 if (type) | |
| 7539 return this; | |
| 7540 if (!e1->type) | |
| 7541 e1 = e1->semantic(sc); | |
| 7542 assert(e1->type); // semantic() should already be run on it | |
| 7543 e = this; | |
| 7544 | |
| 7545 // Note that unlike C we do not implement the int[ptr] | |
| 7546 | |
| 7547 t1 = e1->type->toBasetype(); | |
| 7548 | |
| 7549 if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) | |
| 7550 { // Create scope for 'length' variable | |
| 7551 sym = new ArrayScopeSymbol(this); | |
| 7552 sym->loc = loc; | |
| 7553 sym->parent = sc->scopesym; | |
| 7554 sc = sc->push(sym); | |
| 7555 } | |
| 7556 | |
| 7557 e2 = e2->semantic(sc); | |
| 7558 if (!e2->type) | |
| 7559 { | |
| 7560 error("%s has no value", e2->toChars()); | |
| 7561 e2->type = Type::terror; | |
| 7562 } | |
| 7563 e2 = resolveProperties(sc, e2); | |
| 7564 | |
| 7565 if (t1->ty == Tsarray || t1->ty == Tarray || t1->ty == Ttuple) | |
| 7566 sc = sc->pop(); | |
| 7567 | |
| 7568 switch (t1->ty) | |
| 7569 { | |
| 7570 case Tpointer: | |
| 7571 case Tarray: | |
| 7572 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7573 e->type = t1->next; | |
| 7574 break; | |
| 7575 | |
| 7576 case Tsarray: | |
| 7577 { | |
| 7578 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7579 | |
| 7580 TypeSArray *tsa = (TypeSArray *)t1; | |
| 7581 | |
| 7582 #if 0 // Don't do now, because it might be short-circuit evaluated | |
| 7583 // Do compile time array bounds checking if possible | |
| 7584 e2 = e2->optimize(WANTvalue); | |
| 7585 if (e2->op == TOKint64) | |
| 7586 { | |
| 7587 integer_t index = e2->toInteger(); | |
| 7588 integer_t length = tsa->dim->toInteger(); | |
| 7589 if (index < 0 || index >= length) | |
| 7590 error("array index [%lld] is outside array bounds [0 .. %lld]", | |
| 7591 index, length); | |
| 7592 } | |
| 7593 #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
|
7594 e->type = t1->nextOf(); |
| 159 | 7595 break; |
| 7596 } | |
| 7597 | |
| 7598 case Taarray: | |
| 7599 { TypeAArray *taa = (TypeAArray *)t1; | |
| 7600 | |
| 7601 e2 = e2->implicitCastTo(sc, taa->index); // type checking | |
| 7602 e2 = e2->implicitCastTo(sc, taa->key); // actual argument type | |
| 7603 type = taa->next; | |
| 7604 break; | |
| 7605 } | |
| 7606 | |
| 7607 case Ttuple: | |
| 7608 { | |
| 7609 e2 = e2->implicitCastTo(sc, Type::tsize_t); | |
| 7610 e2 = e2->optimize(WANTvalue); | |
| 7611 uinteger_t index = e2->toUInteger(); | |
| 7612 size_t length; | |
| 7613 TupleExp *te; | |
| 7614 TypeTuple *tup; | |
| 7615 | |
| 7616 if (e1->op == TOKtuple) | |
| 7617 { te = (TupleExp *)e1; | |
| 7618 length = te->exps->dim; | |
| 7619 } | |
| 7620 else if (e1->op == TOKtype) | |
| 7621 { | |
| 7622 tup = (TypeTuple *)t1; | |
| 7623 length = Argument::dim(tup->arguments); | |
| 7624 } | |
| 7625 else | |
| 7626 assert(0); | |
| 7627 | |
| 7628 if (index < length) | |
| 7629 { | |
| 7630 | |
| 7631 if (e1->op == TOKtuple) | |
| 7632 e = (Expression *)te->exps->data[(size_t)index]; | |
| 7633 else | |
| 7634 e = new TypeExp(e1->loc, Argument::getNth(tup->arguments, (size_t)index)->type); | |
| 7635 } | |
| 7636 else | |
| 7637 { | |
|
1103
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7638 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
|
7639 index, length); |
|
b30fe7e1dbb9
- Updated to DMD frontend 1.041.
Tomas Lindquist Olsen <tomas.l.olsen gmail.com>
parents:
1012
diff
changeset
|
7640 e = e1; |
| 159 | 7641 } |
| 7642 break; | |
| 7643 } | |
| 7644 | |
| 7645 default: | |
| 7646 error("%s must be an array or pointer type, not %s", | |
| 7647 e1->toChars(), e1->type->toChars()); | |
| 7648 type = Type::tint32; | |
| 7649 break; | |
| 7650 } | |
| 7651 return e; | |
| 7652 } | |
| 7653 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7654 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7655 int IndexExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7656 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7657 return 1; |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7658 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7659 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
7660 |
| 159 | 7661 Expression *IndexExp::toLvalue(Scope *sc, Expression *e) |
| 7662 { | |
| 7663 // if (type && type->toBasetype()->ty == Tvoid) | |
| 7664 // error("voids have no value"); | |
| 7665 return this; | |
| 7666 } | |
| 7667 | |
| 7668 Expression *IndexExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 7669 { | |
| 7670 //printf("IndexExp::modifiableLvalue(%s)\n", toChars()); | |
| 7671 modifiable = 1; | |
| 7672 if (e1->op == TOKstring) | |
| 7673 error("string literals are immutable"); | |
| 7674 if (e1->type->toBasetype()->ty == Taarray) | |
| 7675 e1 = e1->modifiableLvalue(sc, e1); | |
| 7676 return toLvalue(sc, e); | |
| 7677 } | |
| 7678 | |
| 7679 void IndexExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7680 { | |
| 7681 expToCBuffer(buf, hgs, e1, PREC_primary); | |
| 7682 buf->writeByte('['); | |
| 7683 expToCBuffer(buf, hgs, e2, PREC_assign); | |
| 7684 buf->writeByte(']'); | |
| 7685 } | |
| 7686 | |
| 7687 | |
| 7688 /************************* PostExp ***********************************/ | |
| 7689 | |
| 7690 PostExp::PostExp(enum TOK op, Loc loc, Expression *e) | |
| 7691 : BinExp(loc, op, sizeof(PostExp), e, | |
| 7692 new IntegerExp(loc, 1, Type::tint32)) | |
| 7693 { | |
| 7694 } | |
| 7695 | |
| 7696 Expression *PostExp::semantic(Scope *sc) | |
| 7697 { Expression *e = this; | |
| 7698 | |
| 7699 if (!type) | |
| 7700 { | |
| 7701 BinExp::semantic(sc); | |
| 7702 e2 = resolveProperties(sc, e2); | |
| 7703 | |
| 7704 e = op_overload(sc); | |
| 7705 if (e) | |
| 7706 return e; | |
| 7707 | |
| 7708 e = this; | |
| 7709 e1 = e1->modifiableLvalue(sc, e1); | |
| 7710 e1->checkScalar(); | |
| 7711 e1->checkNoBool(); | |
| 7712 if (e1->type->ty == Tpointer) | |
| 7713 e = scaleFactor(sc); | |
| 7714 else | |
| 7715 e2 = e2->castTo(sc, e1->type); | |
| 7716 e->type = e1->type; | |
| 7717 } | |
| 7718 return e; | |
| 7719 } | |
| 7720 | |
| 7721 void PostExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) | |
| 7722 { | |
| 7723 expToCBuffer(buf, hgs, e1, precedence[op]); | |
| 7724 buf->writestring((op == TOKplusplus) ? (char *)"++" : (char *)"--"); | |
| 7725 } | |
| 7726 | |
| 7727 /************************************************************/ | |
| 7728 | |
| 7729 /* Can be TOKconstruct too */ | |
| 7730 | |
| 7731 AssignExp::AssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 7732 : BinExp(loc, TOKassign, sizeof(AssignExp), e1, e2) | |
| 7733 { | |
| 7734 ismemset = 0; | |
| 7735 } | |
| 7736 | |
| 7737 Expression *AssignExp::semantic(Scope *sc) | |
| 7738 { Type *t1; | |
| 7739 Expression *e1old = e1; | |
| 7740 | |
| 7741 #if LOGSEMANTIC | |
| 7742 printf("AssignExp::semantic('%s')\n", toChars()); | |
| 7743 #endif | |
| 7744 //printf("e1->op = %d, '%s'\n", e1->op, Token::toChars(e1->op)); | |
| 7745 | |
| 7746 /* Look for operator overloading of a[i]=value. | |
| 7747 * Do it before semantic() otherwise the a[i] will have been | |
| 7748 * converted to a.opIndex() already. | |
| 7749 */ | |
| 7750 if (e1->op == TOKarray) | |
| 7751 { Type *t1; | |
| 7752 ArrayExp *ae = (ArrayExp *)e1; | |
| 7753 AggregateDeclaration *ad; | |
| 7754 Identifier *id = Id::index; | |
| 7755 | |
| 7756 ae->e1 = ae->e1->semantic(sc); | |
| 7757 t1 = ae->e1->type->toBasetype(); | |
| 7758 if (t1->ty == Tstruct) | |
| 7759 { | |
| 7760 ad = ((TypeStruct *)t1)->sym; | |
| 7761 goto L1; | |
| 7762 } | |
| 7763 else if (t1->ty == Tclass) | |
| 7764 { | |
| 7765 ad = ((TypeClass *)t1)->sym; | |
| 7766 L1: | |
| 7767 // Rewrite (a[i] = value) to (a.opIndexAssign(value, i)) | |
| 7768 if (search_function(ad, Id::indexass)) | |
| 7769 { Expression *e = new DotIdExp(loc, ae->e1, Id::indexass); | |
| 7770 Expressions *a = (Expressions *)ae->arguments->copy(); | |
| 7771 | |
| 7772 a->insert(0, e2); | |
| 7773 e = new CallExp(loc, e, a); | |
| 7774 e = e->semantic(sc); | |
| 7775 return e; | |
| 7776 } | |
| 7777 else | |
| 7778 { | |
| 7779 // Rewrite (a[i] = value) to (a.opIndex(i, value)) | |
| 7780 if (search_function(ad, id)) | |
| 7781 { Expression *e = new DotIdExp(loc, ae->e1, id); | |
| 7782 | |
| 7783 if (1 || !global.params.useDeprecated) | |
| 7784 error("operator [] assignment overload with opIndex(i, value) illegal, use opIndexAssign(value, i)"); | |
| 7785 | |
| 7786 e = new CallExp(loc, e, (Expression *)ae->arguments->data[0], e2); | |
| 7787 e = e->semantic(sc); | |
| 7788 return e; | |
| 7789 } | |
| 7790 } | |
| 7791 } | |
| 7792 } | |
| 7793 /* Look for operator overloading of a[i..j]=value. | |
| 7794 * Do it before semantic() otherwise the a[i..j] will have been | |
| 7795 * converted to a.opSlice() already. | |
| 7796 */ | |
| 7797 if (e1->op == TOKslice) | |
| 7798 { Type *t1; | |
| 7799 SliceExp *ae = (SliceExp *)e1; | |
| 7800 AggregateDeclaration *ad; | |
| 7801 Identifier *id = Id::index; | |
| 7802 | |
| 7803 ae->e1 = ae->e1->semantic(sc); | |
| 7804 ae->e1 = resolveProperties(sc, ae->e1); | |
| 7805 t1 = ae->e1->type->toBasetype(); | |
| 7806 if (t1->ty == Tstruct) | |
| 7807 { | |
| 7808 ad = ((TypeStruct *)t1)->sym; | |
| 7809 goto L2; | |
| 7810 } | |
| 7811 else if (t1->ty == Tclass) | |
| 7812 { | |
| 7813 ad = ((TypeClass *)t1)->sym; | |
| 7814 L2: | |
| 7815 // Rewrite (a[i..j] = value) to (a.opIndexAssign(value, i, j)) | |
| 7816 if (search_function(ad, Id::sliceass)) | |
| 7817 { Expression *e = new DotIdExp(loc, ae->e1, Id::sliceass); | |
| 7818 Expressions *a = new Expressions(); | |
| 7819 | |
| 7820 a->push(e2); | |
| 7821 if (ae->lwr) | |
| 7822 { a->push(ae->lwr); | |
| 7823 assert(ae->upr); | |
| 7824 a->push(ae->upr); | |
| 7825 } | |
| 7826 else | |
| 7827 assert(!ae->upr); | |
| 7828 e = new CallExp(loc, e, a); | |
| 7829 e = e->semantic(sc); | |
| 7830 return e; | |
| 7831 } | |
| 7832 } | |
| 7833 } | |
| 7834 | |
| 7835 BinExp::semantic(sc); | |
|
717
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7836 |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7837 if (e1->op == TOKdottd) |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7838 { // 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
|
7839 Expression *e = new CallExp(loc, e1, e2); |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7840 e = e->semantic(sc); |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7841 return e; |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7842 } |
|
a26b0c5d5942
Merged DMD 1.036.
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
664
diff
changeset
|
7843 |
| 159 | 7844 e2 = resolveProperties(sc, e2); |
| 7845 assert(e1->type); | |
| 7846 | |
| 7847 /* Rewrite tuple assignment as a tuple of assignments. | |
| 7848 */ | |
| 7849 if (e1->op == TOKtuple && e2->op == TOKtuple) | |
| 7850 { TupleExp *tup1 = (TupleExp *)e1; | |
| 7851 TupleExp *tup2 = (TupleExp *)e2; | |
| 7852 size_t dim = tup1->exps->dim; | |
| 7853 if (dim != tup2->exps->dim) | |
| 7854 { | |
| 7855 error("mismatched tuple lengths, %d and %d", (int)dim, (int)tup2->exps->dim); | |
| 7856 } | |
| 7857 else | |
| 7858 { Expressions *exps = new Expressions; | |
| 7859 exps->setDim(dim); | |
| 7860 | |
| 7861 for (int i = 0; i < dim; i++) | |
| 7862 { Expression *ex1 = (Expression *)tup1->exps->data[i]; | |
| 7863 Expression *ex2 = (Expression *)tup2->exps->data[i]; | |
| 7864 exps->data[i] = (void *) new AssignExp(loc, ex1, ex2); | |
| 7865 } | |
| 7866 Expression *e = new TupleExp(loc, exps); | |
| 7867 e = e->semantic(sc); | |
| 7868 return e; | |
| 7869 } | |
| 7870 } | |
| 7871 | |
| 7872 t1 = e1->type->toBasetype(); | |
| 7873 | |
| 7874 if (t1->ty == Tfunction) | |
| 7875 { // Rewrite f=value to f(value) | |
| 7876 Expression *e; | |
| 7877 | |
| 7878 e = new CallExp(loc, e1, e2); | |
| 7879 e = e->semantic(sc); | |
| 7880 return e; | |
| 7881 } | |
| 7882 | |
| 7883 /* If it is an assignment from a 'foreign' type, | |
| 7884 * check for operator overloading. | |
| 7885 */ | |
| 7886 if (t1->ty == Tclass || t1->ty == Tstruct) | |
| 7887 { | |
| 7888 if (!e2->type->implicitConvTo(e1->type)) | |
| 7889 { | |
| 7890 Expression *e = op_overload(sc); | |
| 7891 if (e) | |
| 7892 return e; | |
| 7893 } | |
| 7894 } | |
| 7895 | |
| 7896 e2->rvalue(); | |
| 7897 | |
| 7898 if (e1->op == TOKarraylength) | |
| 7899 { | |
| 7900 // e1 is not an lvalue, but we let code generator handle it | |
| 7901 ArrayLengthExp *ale = (ArrayLengthExp *)e1; | |
| 7902 | |
| 7903 ale->e1 = ale->e1->modifiableLvalue(sc, e1); | |
| 7904 } | |
| 7905 else if (e1->op == TOKslice) | |
| 7906 ; | |
| 7907 else | |
| 7908 { // Try to do a decent error message with the expression | |
| 7909 // before it got constant folded | |
| 7910 e1 = e1->modifiableLvalue(sc, e1old); | |
| 7911 } | |
| 7912 | |
| 7913 if (e1->op == TOKslice && | |
| 7914 t1->nextOf() && | |
| 7915 e2->implicitConvTo(t1->nextOf()) | |
| 7916 // !(t1->nextOf()->equals(e2->type->nextOf())) | |
| 7917 ) | |
| 7918 { // memset | |
| 7919 ismemset = 1; // make it easy for back end to tell what this is | |
| 7920 e2 = e2->implicitCastTo(sc, t1->next); | |
| 7921 } | |
| 7922 else if (t1->ty == Tsarray) | |
| 7923 { | |
| 7924 error("cannot assign to static array %s", e1->toChars()); | |
| 7925 } | |
| 7926 else | |
| 7927 { | |
| 7928 e2 = e2->implicitCastTo(sc, e1->type); | |
| 7929 } | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7930 |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7931 /* 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
|
7932 */ |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7933 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
|
7934 (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
|
7935 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
|
7936 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
|
7937 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
|
7938 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
|
7939 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7940 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
|
7941 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
|
7942 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7943 |
| 159 | 7944 type = e1->type; |
| 7945 assert(type); | |
| 7946 return this; | |
| 7947 } | |
| 7948 | |
| 7949 Expression *AssignExp::checkToBoolean() | |
| 7950 { | |
| 7951 // Things like: | |
| 7952 // if (a = b) ... | |
| 7953 // are usually mistakes. | |
| 7954 | |
| 7955 error("'=' does not give a boolean result"); | |
| 7956 return this; | |
| 7957 } | |
| 7958 | |
| 7959 /************************************************************/ | |
| 7960 | |
| 7961 AddAssignExp::AddAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 7962 : BinExp(loc, TOKaddass, sizeof(AddAssignExp), e1, e2) | |
| 7963 { | |
| 7964 } | |
| 7965 | |
| 7966 Expression *AddAssignExp::semantic(Scope *sc) | |
| 7967 { Expression *e; | |
| 7968 | |
| 7969 if (type) | |
| 7970 return this; | |
| 7971 | |
| 7972 BinExp::semantic(sc); | |
| 7973 e2 = resolveProperties(sc, e2); | |
| 7974 | |
| 7975 e = op_overload(sc); | |
| 7976 if (e) | |
| 7977 return e; | |
| 7978 | |
| 7979 Type *tb1 = e1->type->toBasetype(); | |
| 7980 Type *tb2 = e2->type->toBasetype(); | |
| 7981 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7982 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
|
7983 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7984 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
|
7985 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
|
7986 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
|
7987 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7988 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7989 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7990 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
|
7991 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
7992 |
| 159 | 7993 if ((tb1->ty == Tarray || tb1->ty == Tsarray) && |
| 7994 (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
|
7995 tb1->nextOf()->equals(tb2->nextOf()) |
| 159 | 7996 ) |
| 7997 { | |
| 7998 type = e1->type; | |
| 7999 e = this; | |
| 8000 } | |
| 8001 else | |
| 8002 { | |
| 8003 e1->checkScalar(); | |
| 8004 e1->checkNoBool(); | |
| 8005 if (tb1->ty == Tpointer && tb2->isintegral()) | |
| 8006 e = scaleFactor(sc); | |
| 8007 else if (tb1->ty == Tbit || tb1->ty == Tbool) | |
| 8008 { | |
| 8009 #if 0 | |
| 8010 // Need to rethink this | |
| 8011 if (e1->op != TOKvar) | |
| 8012 { // Rewrite e1+=e2 to (v=&e1),*v=*v+e2 | |
| 8013 VarDeclaration *v; | |
| 8014 Expression *ea; | |
| 8015 Expression *ex; | |
| 8016 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8017 Identifier *id = Lexer::uniqueId("__name"); |
| 159 | 8018 |
| 8019 v = new VarDeclaration(loc, tb1->pointerTo(), id, NULL); | |
| 8020 v->semantic(sc); | |
| 8021 if (!sc->insert(v)) | |
| 8022 assert(0); | |
| 8023 v->parent = sc->func; | |
| 8024 | |
| 8025 ea = new AddrExp(loc, e1); | |
| 8026 ea = new AssignExp(loc, new VarExp(loc, v), ea); | |
| 8027 | |
| 8028 ex = new VarExp(loc, v); | |
| 8029 ex = new PtrExp(loc, ex); | |
| 8030 e = new AddExp(loc, ex, e2); | |
| 8031 e = new CastExp(loc, e, e1->type); | |
| 8032 e = new AssignExp(loc, ex->syntaxCopy(), e); | |
| 8033 | |
| 8034 e = new CommaExp(loc, ea, e); | |
| 8035 } | |
| 8036 else | |
| 8037 #endif | |
| 8038 { // Rewrite e1+=e2 to e1=e1+e2 | |
| 8039 // BUG: doesn't account for side effects in e1 | |
| 8040 // BUG: other assignment operators for bits aren't handled at all | |
| 8041 e = new AddExp(loc, e1, e2); | |
| 8042 e = new CastExp(loc, e, e1->type); | |
| 8043 e = new AssignExp(loc, e1->syntaxCopy(), e); | |
| 8044 } | |
| 8045 e = e->semantic(sc); | |
| 8046 } | |
| 8047 else | |
| 8048 { | |
| 8049 type = e1->type; | |
| 8050 typeCombine(sc); | |
| 8051 e1->checkArithmetic(); | |
| 8052 e2->checkArithmetic(); | |
| 8053 if (type->isreal() || type->isimaginary()) | |
| 8054 { | |
| 8055 assert(global.errors || e2->type->isfloating()); | |
| 8056 e2 = e2->castTo(sc, e1->type); | |
| 8057 } | |
| 8058 e = this; | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8059 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8060 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
|
8061 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8062 } |
| 8063 } | |
| 8064 return e; | |
| 8065 } | |
| 8066 | |
| 8067 /************************************************************/ | |
| 8068 | |
| 8069 MinAssignExp::MinAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8070 : BinExp(loc, TOKminass, sizeof(MinAssignExp), e1, e2) | |
| 8071 { | |
| 8072 } | |
| 8073 | |
| 8074 Expression *MinAssignExp::semantic(Scope *sc) | |
| 8075 { Expression *e; | |
| 8076 | |
| 8077 if (type) | |
| 8078 return this; | |
| 8079 | |
| 8080 BinExp::semantic(sc); | |
| 8081 e2 = resolveProperties(sc, e2); | |
| 8082 | |
| 8083 e = op_overload(sc); | |
| 8084 if (e) | |
| 8085 return e; | |
| 8086 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8087 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
|
8088 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8089 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
|
8090 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
|
8091 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
|
8092 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8093 |
| 159 | 8094 e1 = e1->modifiableLvalue(sc, e1); |
| 8095 e1->checkScalar(); | |
| 8096 e1->checkNoBool(); | |
| 8097 if (e1->type->ty == Tpointer && e2->type->isintegral()) | |
| 8098 e = scaleFactor(sc); | |
| 8099 else | |
| 8100 { | |
| 8101 e1 = e1->checkArithmetic(); | |
| 8102 e2 = e2->checkArithmetic(); | |
| 8103 type = e1->type; | |
| 8104 typeCombine(sc); | |
| 8105 if (type->isreal() || type->isimaginary()) | |
| 8106 { | |
| 8107 assert(e2->type->isfloating()); | |
| 8108 e2 = e2->castTo(sc, e1->type); | |
| 8109 } | |
| 8110 e = this; | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8111 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8112 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
|
8113 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8114 } |
| 8115 return e; | |
| 8116 } | |
| 8117 | |
| 8118 /************************************************************/ | |
| 8119 | |
| 8120 CatAssignExp::CatAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8121 : BinExp(loc, TOKcatass, sizeof(CatAssignExp), e1, e2) | |
| 8122 { | |
| 8123 } | |
| 8124 | |
| 8125 Expression *CatAssignExp::semantic(Scope *sc) | |
| 8126 { Expression *e; | |
| 8127 | |
| 8128 BinExp::semantic(sc); | |
| 8129 e2 = resolveProperties(sc, e2); | |
| 8130 | |
| 8131 e = op_overload(sc); | |
| 8132 if (e) | |
| 8133 return e; | |
| 8134 | |
| 8135 if (e1->op == TOKslice) | |
| 8136 { SliceExp *se = (SliceExp *)e1; | |
| 8137 | |
| 8138 if (se->e1->type->toBasetype()->ty == Tsarray) | |
| 8139 error("cannot append to static array %s", se->e1->type->toChars()); | |
| 8140 } | |
| 8141 | |
| 8142 e1 = e1->modifiableLvalue(sc, e1); | |
| 8143 | |
| 8144 Type *tb1 = e1->type->toBasetype(); | |
| 8145 Type *tb2 = e2->type->toBasetype(); | |
| 8146 | |
| 8147 e2->rvalue(); | |
| 8148 | |
| 8149 if ((tb1->ty == Tarray) && | |
| 8150 (tb2->ty == Tarray || tb2->ty == Tsarray) && | |
| 8151 e2->implicitConvTo(e1->type) | |
| 8152 //e1->type->next->equals(e2->type->next) | |
| 8153 ) | |
| 8154 { // Append array | |
| 8155 e2 = e2->castTo(sc, e1->type); | |
| 8156 type = e1->type; | |
| 8157 e = this; | |
| 8158 } | |
| 8159 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
|
8160 e2->implicitConvTo(tb1->nextOf()) |
| 159 | 8161 ) |
| 8162 { // 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
|
8163 e2 = e2->castTo(sc, tb1->nextOf()); |
| 159 | 8164 type = e1->type; |
| 8165 e = this; | |
| 8166 } | |
| 8167 else | |
| 8168 { | |
| 8169 error("cannot append type %s to type %s", tb2->toChars(), tb1->toChars()); | |
| 8170 type = Type::tint32; | |
| 8171 e = this; | |
| 8172 } | |
| 8173 return e; | |
| 8174 } | |
| 8175 | |
| 8176 /************************************************************/ | |
| 8177 | |
| 8178 MulAssignExp::MulAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8179 : BinExp(loc, TOKmulass, sizeof(MulAssignExp), e1, e2) | |
| 8180 { | |
| 8181 } | |
| 8182 | |
| 8183 Expression *MulAssignExp::semantic(Scope *sc) | |
| 8184 { Expression *e; | |
| 8185 | |
| 8186 BinExp::semantic(sc); | |
| 8187 e2 = resolveProperties(sc, e2); | |
| 8188 | |
| 8189 e = op_overload(sc); | |
| 8190 if (e) | |
| 8191 return e; | |
| 8192 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8193 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
|
8194 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8195 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
|
8196 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
|
8197 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
|
8198 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8199 |
| 159 | 8200 e1 = e1->modifiableLvalue(sc, e1); |
| 8201 e1->checkScalar(); | |
| 8202 e1->checkNoBool(); | |
| 8203 type = e1->type; | |
| 8204 typeCombine(sc); | |
| 8205 e1->checkArithmetic(); | |
| 8206 e2->checkArithmetic(); | |
| 8207 if (e2->type->isfloating()) | |
| 8208 { Type *t1; | |
| 8209 Type *t2; | |
| 8210 | |
| 8211 t1 = e1->type; | |
| 8212 t2 = e2->type; | |
| 8213 if (t1->isreal()) | |
| 8214 { | |
| 8215 if (t2->isimaginary() || t2->iscomplex()) | |
| 8216 { | |
| 8217 e2 = e2->castTo(sc, t1); | |
| 8218 } | |
| 8219 } | |
| 8220 else if (t1->isimaginary()) | |
| 8221 { | |
| 8222 if (t2->isimaginary() || t2->iscomplex()) | |
| 8223 { | |
| 8224 switch (t1->ty) | |
| 8225 { | |
| 8226 case Timaginary32: t2 = Type::tfloat32; break; | |
| 8227 case Timaginary64: t2 = Type::tfloat64; break; | |
| 8228 case Timaginary80: t2 = Type::tfloat80; break; | |
| 8229 default: | |
| 8230 assert(0); | |
| 8231 } | |
| 8232 e2 = e2->castTo(sc, t2); | |
| 8233 } | |
| 8234 } | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8235 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8236 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
|
8237 error("Cannot assign %s to %s", e2->type->toChars(), type->toChars()); |
| 159 | 8238 } |
| 8239 return this; | |
| 8240 } | |
| 8241 | |
| 8242 /************************************************************/ | |
| 8243 | |
| 8244 DivAssignExp::DivAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8245 : BinExp(loc, TOKdivass, sizeof(DivAssignExp), e1, e2) | |
| 8246 { | |
| 8247 } | |
| 8248 | |
| 8249 Expression *DivAssignExp::semantic(Scope *sc) | |
| 8250 { Expression *e; | |
| 8251 | |
| 8252 BinExp::semantic(sc); | |
| 8253 e2 = resolveProperties(sc, e2); | |
| 8254 | |
| 8255 e = op_overload(sc); | |
| 8256 if (e) | |
| 8257 return e; | |
| 8258 | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8259 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
|
8260 { // T[] -= ... |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8261 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
|
8262 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
|
8263 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
|
8264 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8265 |
| 159 | 8266 e1 = e1->modifiableLvalue(sc, e1); |
| 8267 e1->checkScalar(); | |
| 8268 e1->checkNoBool(); | |
| 8269 type = e1->type; | |
| 8270 typeCombine(sc); | |
| 8271 e1->checkArithmetic(); | |
| 8272 e2->checkArithmetic(); | |
| 8273 if (e2->type->isimaginary()) | |
| 8274 { Type *t1; | |
| 8275 Type *t2; | |
| 8276 | |
| 8277 t1 = e1->type; | |
| 8278 if (t1->isreal()) | |
| 8279 { // x/iv = i(-x/v) | |
| 8280 // Therefore, the result is 0 | |
| 8281 e2 = new CommaExp(loc, e2, new RealExp(loc, 0, t1)); | |
| 8282 e2->type = t1; | |
| 8283 e = new AssignExp(loc, e1, e2); | |
| 8284 e->type = t1; | |
| 8285 return e; | |
| 8286 } | |
| 8287 else if (t1->isimaginary()) | |
| 8288 { Expression *e; | |
| 8289 | |
| 8290 switch (t1->ty) | |
| 8291 { | |
| 8292 case Timaginary32: t2 = Type::tfloat32; break; | |
| 8293 case Timaginary64: t2 = Type::tfloat64; break; | |
| 8294 case Timaginary80: t2 = Type::tfloat80; break; | |
| 8295 default: | |
| 8296 assert(0); | |
| 8297 } | |
| 8298 e2 = e2->castTo(sc, t2); | |
| 8299 e = new AssignExp(loc, e1, e2); | |
| 8300 e->type = t1; | |
| 8301 return e; | |
| 8302 } | |
| 8303 } | |
|
1012
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8304 |
|
39cf8fa483fd
Error gracefully for +=, -=, *=, /= if rhs is complex but lhs isn't.
Christian Kamm <kamm incasoftware de>
parents:
891
diff
changeset
|
8305 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
|
8306 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
|
8307 |
| 159 | 8308 return this; |
| 8309 } | |
| 8310 | |
| 8311 /************************************************************/ | |
| 8312 | |
| 8313 ModAssignExp::ModAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8314 : BinExp(loc, TOKmodass, sizeof(ModAssignExp), e1, e2) | |
| 8315 { | |
| 8316 } | |
| 8317 | |
| 8318 Expression *ModAssignExp::semantic(Scope *sc) | |
| 8319 { | |
| 8320 return commonSemanticAssign(sc); | |
| 8321 } | |
| 8322 | |
| 8323 /************************************************************/ | |
| 8324 | |
| 8325 ShlAssignExp::ShlAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8326 : BinExp(loc, TOKshlass, sizeof(ShlAssignExp), e1, e2) | |
| 8327 { | |
| 8328 } | |
| 8329 | |
| 8330 Expression *ShlAssignExp::semantic(Scope *sc) | |
| 8331 { Expression *e; | |
| 8332 | |
| 8333 //printf("ShlAssignExp::semantic()\n"); | |
| 8334 BinExp::semantic(sc); | |
| 8335 e2 = resolveProperties(sc, e2); | |
| 8336 | |
| 8337 e = op_overload(sc); | |
| 8338 if (e) | |
| 8339 return e; | |
| 8340 | |
| 8341 e1 = e1->modifiableLvalue(sc, e1); | |
| 8342 e1->checkScalar(); | |
| 8343 e1->checkNoBool(); | |
| 8344 type = e1->type; | |
| 8345 typeCombine(sc); | |
| 8346 e1->checkIntegral(); | |
| 8347 e2 = e2->checkIntegral(); | |
| 8348 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8349 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8350 return this; |
| 8351 } | |
| 8352 | |
| 8353 /************************************************************/ | |
| 8354 | |
| 8355 ShrAssignExp::ShrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8356 : BinExp(loc, TOKshrass, sizeof(ShrAssignExp), e1, e2) | |
| 8357 { | |
| 8358 } | |
| 8359 | |
| 8360 Expression *ShrAssignExp::semantic(Scope *sc) | |
| 8361 { Expression *e; | |
| 8362 | |
| 8363 BinExp::semantic(sc); | |
| 8364 e2 = resolveProperties(sc, e2); | |
| 8365 | |
| 8366 e = op_overload(sc); | |
| 8367 if (e) | |
| 8368 return e; | |
| 8369 | |
| 8370 e1 = e1->modifiableLvalue(sc, e1); | |
| 8371 e1->checkScalar(); | |
| 8372 e1->checkNoBool(); | |
| 8373 type = e1->type; | |
| 8374 typeCombine(sc); | |
| 8375 e1->checkIntegral(); | |
| 8376 e2 = e2->checkIntegral(); | |
| 8377 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8378 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8379 return this; |
| 8380 } | |
| 8381 | |
| 8382 /************************************************************/ | |
| 8383 | |
| 8384 UshrAssignExp::UshrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8385 : BinExp(loc, TOKushrass, sizeof(UshrAssignExp), e1, e2) | |
| 8386 { | |
| 8387 } | |
| 8388 | |
| 8389 Expression *UshrAssignExp::semantic(Scope *sc) | |
| 8390 { Expression *e; | |
| 8391 | |
| 8392 BinExp::semantic(sc); | |
| 8393 e2 = resolveProperties(sc, e2); | |
| 8394 | |
| 8395 e = op_overload(sc); | |
| 8396 if (e) | |
| 8397 return e; | |
| 8398 | |
| 8399 e1 = e1->modifiableLvalue(sc, e1); | |
| 8400 e1->checkScalar(); | |
| 8401 e1->checkNoBool(); | |
| 8402 type = e1->type; | |
| 8403 typeCombine(sc); | |
| 8404 e1->checkIntegral(); | |
| 8405 e2 = e2->checkIntegral(); | |
| 8406 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8407 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8408 return this; |
| 8409 } | |
| 8410 | |
| 8411 /************************************************************/ | |
| 8412 | |
| 8413 AndAssignExp::AndAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8414 : BinExp(loc, TOKandass, sizeof(AndAssignExp), e1, e2) | |
| 8415 { | |
| 8416 } | |
| 8417 | |
| 8418 Expression *AndAssignExp::semantic(Scope *sc) | |
| 8419 { | |
| 8420 return commonSemanticAssignIntegral(sc); | |
| 8421 } | |
| 8422 | |
| 8423 /************************************************************/ | |
| 8424 | |
| 8425 OrAssignExp::OrAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8426 : BinExp(loc, TOKorass, sizeof(OrAssignExp), e1, e2) | |
| 8427 { | |
| 8428 } | |
| 8429 | |
| 8430 Expression *OrAssignExp::semantic(Scope *sc) | |
| 8431 { | |
| 8432 return commonSemanticAssignIntegral(sc); | |
| 8433 } | |
| 8434 | |
| 8435 /************************************************************/ | |
| 8436 | |
| 8437 XorAssignExp::XorAssignExp(Loc loc, Expression *e1, Expression *e2) | |
| 8438 : BinExp(loc, TOKxorass, sizeof(XorAssignExp), e1, e2) | |
| 8439 { | |
| 8440 } | |
| 8441 | |
| 8442 Expression *XorAssignExp::semantic(Scope *sc) | |
| 8443 { | |
| 8444 return commonSemanticAssignIntegral(sc); | |
| 8445 } | |
| 8446 | |
| 8447 /************************* AddExp *****************************/ | |
| 8448 | |
| 8449 AddExp::AddExp(Loc loc, Expression *e1, Expression *e2) | |
| 8450 : BinExp(loc, TOKadd, sizeof(AddExp), e1, e2) | |
| 8451 { | |
| 8452 } | |
| 8453 | |
| 8454 Expression *AddExp::semantic(Scope *sc) | |
| 8455 { Expression *e; | |
| 8456 | |
| 8457 #if LOGSEMANTIC | |
| 8458 printf("AddExp::semantic('%s')\n", toChars()); | |
| 8459 #endif | |
| 8460 if (!type) | |
| 8461 { | |
| 8462 BinExp::semanticp(sc); | |
| 8463 | |
| 8464 e = op_overload(sc); | |
| 8465 if (e) | |
| 8466 return e; | |
| 8467 | |
| 8468 Type *tb1 = e1->type->toBasetype(); | |
| 8469 Type *tb2 = e2->type->toBasetype(); | |
| 8470 | |
| 8471 if ((tb1->ty == Tarray || tb1->ty == Tsarray) && | |
| 8472 (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
|
8473 tb1->nextOf()->equals(tb2->nextOf()) |
| 159 | 8474 ) |
| 8475 { | |
| 8476 type = e1->type; | |
| 8477 e = this; | |
| 8478 } | |
| 8479 else if (tb1->ty == Tpointer && e2->type->isintegral() || | |
| 8480 tb2->ty == Tpointer && e1->type->isintegral()) | |
| 8481 e = scaleFactor(sc); | |
| 8482 else if (tb1->ty == Tpointer && tb2->ty == Tpointer) | |
| 8483 { | |
| 8484 incompatibleTypes(); | |
| 8485 type = e1->type; | |
| 8486 e = this; | |
| 8487 } | |
| 8488 else | |
| 8489 { | |
| 8490 typeCombine(sc); | |
| 8491 if ((e1->type->isreal() && e2->type->isimaginary()) || | |
| 8492 (e1->type->isimaginary() && e2->type->isreal())) | |
| 8493 { | |
| 8494 switch (type->toBasetype()->ty) | |
| 8495 { | |
| 8496 case Tfloat32: | |
| 8497 case Timaginary32: | |
| 8498 type = Type::tcomplex32; | |
| 8499 break; | |
| 8500 | |
| 8501 case Tfloat64: | |
| 8502 case Timaginary64: | |
| 8503 type = Type::tcomplex64; | |
| 8504 break; | |
| 8505 | |
| 8506 case Tfloat80: | |
| 8507 case Timaginary80: | |
| 8508 type = Type::tcomplex80; | |
| 8509 break; | |
| 8510 | |
| 8511 default: | |
| 8512 assert(0); | |
| 8513 } | |
| 8514 } | |
| 8515 e = this; | |
| 8516 } | |
| 8517 return e; | |
| 8518 } | |
| 8519 return this; | |
| 8520 } | |
| 8521 | |
| 8522 /************************************************************/ | |
| 8523 | |
| 8524 MinExp::MinExp(Loc loc, Expression *e1, Expression *e2) | |
| 8525 : BinExp(loc, TOKmin, sizeof(MinExp), e1, e2) | |
| 8526 { | |
| 8527 } | |
| 8528 | |
| 8529 Expression *MinExp::semantic(Scope *sc) | |
| 8530 { Expression *e; | |
| 8531 Type *t1; | |
| 8532 Type *t2; | |
| 8533 | |
| 8534 #if LOGSEMANTIC | |
| 8535 printf("MinExp::semantic('%s')\n", toChars()); | |
| 8536 #endif | |
| 8537 if (type) | |
| 8538 return this; | |
| 8539 | |
| 8540 BinExp::semanticp(sc); | |
| 8541 | |
| 8542 e = op_overload(sc); | |
| 8543 if (e) | |
| 8544 return e; | |
| 8545 | |
| 8546 e = this; | |
| 8547 t1 = e1->type->toBasetype(); | |
| 8548 t2 = e2->type->toBasetype(); | |
| 8549 if (t1->ty == Tpointer) | |
| 8550 { | |
| 8551 if (t2->ty == Tpointer) | |
| 8552 { // Need to divide the result by the stride | |
| 8553 // Replace (ptr - ptr) with (ptr - ptr) / stride | |
| 8554 d_int64 stride; | |
| 8555 Expression *e; | |
| 8556 | |
| 8557 typeCombine(sc); // make sure pointer types are compatible | |
| 8558 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
|
8559 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
|
8560 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
|
8561 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8562 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
|
8563 } |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8564 else |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8565 { |
|
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8566 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
|
8567 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
|
8568 } |
| 159 | 8569 return e; |
| 8570 } | |
| 8571 else if (t2->isintegral()) | |
| 8572 e = scaleFactor(sc); | |
| 8573 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
|
8574 { error("incompatible types for minus"); |
| 159 | 8575 return new IntegerExp(0); |
| 8576 } | |
| 8577 } | |
| 8578 else if (t2->ty == Tpointer) | |
| 8579 { | |
| 8580 type = e2->type; | |
| 8581 error("can't subtract pointer from %s", e1->type->toChars()); | |
| 8582 return new IntegerExp(0); | |
| 8583 } | |
| 8584 else | |
| 8585 { | |
| 8586 typeCombine(sc); | |
| 8587 t1 = e1->type->toBasetype(); | |
| 8588 t2 = e2->type->toBasetype(); | |
| 8589 if ((t1->isreal() && t2->isimaginary()) || | |
| 8590 (t1->isimaginary() && t2->isreal())) | |
| 8591 { | |
| 8592 switch (type->ty) | |
| 8593 { | |
| 8594 case Tfloat32: | |
| 8595 case Timaginary32: | |
| 8596 type = Type::tcomplex32; | |
| 8597 break; | |
| 8598 | |
| 8599 case Tfloat64: | |
| 8600 case Timaginary64: | |
| 8601 type = Type::tcomplex64; | |
| 8602 break; | |
| 8603 | |
| 8604 case Tfloat80: | |
| 8605 case Timaginary80: | |
| 8606 type = Type::tcomplex80; | |
| 8607 break; | |
| 8608 | |
| 8609 default: | |
| 8610 assert(0); | |
| 8611 } | |
| 8612 } | |
| 8613 } | |
| 8614 return e; | |
| 8615 } | |
| 8616 | |
| 8617 /************************* CatExp *****************************/ | |
| 8618 | |
| 8619 CatExp::CatExp(Loc loc, Expression *e1, Expression *e2) | |
| 8620 : BinExp(loc, TOKcat, sizeof(CatExp), e1, e2) | |
| 8621 { | |
| 8622 } | |
| 8623 | |
| 8624 Expression *CatExp::semantic(Scope *sc) | |
| 8625 { Expression *e; | |
| 8626 | |
| 8627 //printf("CatExp::semantic() %s\n", toChars()); | |
| 8628 if (!type) | |
| 8629 { | |
| 8630 BinExp::semanticp(sc); | |
| 8631 e = op_overload(sc); | |
| 8632 if (e) | |
| 8633 return e; | |
| 8634 | |
| 8635 Type *tb1 = e1->type->toBasetype(); | |
| 8636 Type *tb2 = e2->type->toBasetype(); | |
| 8637 | |
| 8638 | |
| 8639 /* BUG: Should handle things like: | |
| 8640 * char c; | |
| 8641 * c ~ ' ' | |
| 8642 * ' ' ~ c; | |
| 8643 */ | |
| 8644 | |
| 8645 #if 0 | |
| 8646 e1->type->print(); | |
| 8647 e2->type->print(); | |
| 8648 #endif | |
| 8649 if ((tb1->ty == Tsarray || tb1->ty == Tarray) && | |
| 8650 e2->type->equals(tb1->next)) | |
| 8651 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8652 type = tb1->nextOf()->arrayOf(); |
| 159 | 8653 if (tb2->ty == Tarray) |
| 8654 { // Make e2 into [e2] | |
| 8655 e2 = new ArrayLiteralExp(e2->loc, e2); | |
| 8656 e2->type = type; | |
| 8657 } | |
| 8658 return this; | |
| 8659 } | |
| 8660 else if ((tb2->ty == Tsarray || tb2->ty == Tarray) && | |
| 8661 e1->type->equals(tb2->next)) | |
| 8662 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8663 type = tb2->nextOf()->arrayOf(); |
| 159 | 8664 if (tb1->ty == Tarray) |
| 8665 { // Make e1 into [e1] | |
| 8666 e1 = new ArrayLiteralExp(e1->loc, e1); | |
| 8667 e1->type = type; | |
| 8668 } | |
| 8669 return this; | |
| 8670 } | |
| 8671 | |
| 8672 typeCombine(sc); | |
| 8673 | |
| 8674 if (type->toBasetype()->ty == Tsarray) | |
| 8675 type = type->toBasetype()->next->arrayOf(); | |
| 8676 #if 0 | |
| 8677 e1->type->print(); | |
| 8678 e2->type->print(); | |
| 8679 type->print(); | |
| 8680 print(); | |
| 8681 #endif | |
| 8682 if (e1->op == TOKstring && e2->op == TOKstring) | |
| 8683 e = optimize(WANTvalue); | |
| 8684 else if (e1->type->equals(e2->type) && | |
| 8685 (e1->type->toBasetype()->ty == Tarray || | |
| 8686 e1->type->toBasetype()->ty == Tsarray)) | |
| 8687 { | |
| 8688 e = this; | |
| 8689 } | |
| 8690 else | |
| 8691 { | |
|
510
6aee82889553
Merged DMD 1.034, array operations are not yet implemented ;)
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
486
diff
changeset
|
8692 //printf("(%s) ~ (%s)\n", e1->toChars(), e2->toChars()); |
| 159 | 8693 error("Can only concatenate arrays, not (%s ~ %s)", |
| 8694 e1->type->toChars(), e2->type->toChars()); | |
| 8695 type = Type::tint32; | |
| 8696 e = this; | |
| 8697 } | |
| 8698 e->type = e->type->semantic(loc, sc); | |
| 8699 return e; | |
| 8700 } | |
| 8701 return this; | |
| 8702 } | |
| 8703 | |
| 8704 /************************************************************/ | |
| 8705 | |
| 8706 MulExp::MulExp(Loc loc, Expression *e1, Expression *e2) | |
| 8707 : BinExp(loc, TOKmul, sizeof(MulExp), e1, e2) | |
| 8708 { | |
| 8709 } | |
| 8710 | |
| 8711 Expression *MulExp::semantic(Scope *sc) | |
| 8712 { Expression *e; | |
| 8713 | |
| 8714 #if 0 | |
| 8715 printf("MulExp::semantic() %s\n", toChars()); | |
| 8716 #endif | |
| 8717 if (type) | |
| 8718 { | |
| 8719 return this; | |
| 8720 } | |
| 8721 | |
| 8722 BinExp::semanticp(sc); | |
| 8723 e = op_overload(sc); | |
| 8724 if (e) | |
| 8725 return e; | |
| 8726 | |
| 8727 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
|
8728 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
|
8729 { 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
|
8730 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
|
8731 } |
| 159 | 8732 if (type->isfloating()) |
| 8733 { Type *t1 = e1->type; | |
| 8734 Type *t2 = e2->type; | |
| 8735 | |
| 8736 if (t1->isreal()) | |
| 8737 { | |
| 8738 type = t2; | |
| 8739 } | |
| 8740 else if (t2->isreal()) | |
| 8741 { | |
| 8742 type = t1; | |
| 8743 } | |
| 8744 else if (t1->isimaginary()) | |
| 8745 { | |
| 8746 if (t2->isimaginary()) | |
| 8747 { Expression *e; | |
| 8748 | |
| 8749 switch (t1->ty) | |
| 8750 { | |
| 8751 case Timaginary32: type = Type::tfloat32; break; | |
| 8752 case Timaginary64: type = Type::tfloat64; break; | |
| 8753 case Timaginary80: type = Type::tfloat80; break; | |
| 8754 default: assert(0); | |
| 8755 } | |
| 8756 | |
| 8757 // iy * iv = -yv | |
| 8758 e1->type = type; | |
| 8759 e2->type = type; | |
| 8760 e = new NegExp(loc, this); | |
| 8761 e = e->semantic(sc); | |
| 8762 return e; | |
| 8763 } | |
| 8764 else | |
| 8765 type = t2; // t2 is complex | |
| 8766 } | |
| 8767 else if (t2->isimaginary()) | |
| 8768 { | |
| 8769 type = t1; // t1 is complex | |
| 8770 } | |
| 8771 } | |
| 8772 return this; | |
| 8773 } | |
| 8774 | |
| 8775 /************************************************************/ | |
| 8776 | |
| 8777 DivExp::DivExp(Loc loc, Expression *e1, Expression *e2) | |
| 8778 : BinExp(loc, TOKdiv, sizeof(DivExp), e1, e2) | |
| 8779 { | |
| 8780 } | |
| 8781 | |
| 8782 Expression *DivExp::semantic(Scope *sc) | |
| 8783 { Expression *e; | |
| 8784 | |
| 8785 if (type) | |
| 8786 return this; | |
| 8787 | |
| 8788 BinExp::semanticp(sc); | |
| 8789 e = op_overload(sc); | |
| 8790 if (e) | |
| 8791 return e; | |
| 8792 | |
| 8793 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
|
8794 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
|
8795 { 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
|
8796 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
|
8797 } |
| 159 | 8798 if (type->isfloating()) |
| 8799 { Type *t1 = e1->type; | |
| 8800 Type *t2 = e2->type; | |
| 8801 | |
| 8802 if (t1->isreal()) | |
| 8803 { | |
| 8804 type = t2; | |
| 8805 if (t2->isimaginary()) | |
| 8806 { Expression *e; | |
| 8807 | |
| 8808 // x/iv = i(-x/v) | |
| 8809 e2->type = t1; | |
| 8810 e = new NegExp(loc, this); | |
| 8811 e = e->semantic(sc); | |
| 8812 return e; | |
| 8813 } | |
| 8814 } | |
| 8815 else if (t2->isreal()) | |
| 8816 { | |
| 8817 type = t1; | |
| 8818 } | |
| 8819 else if (t1->isimaginary()) | |
| 8820 { | |
| 8821 if (t2->isimaginary()) | |
| 8822 { | |
| 8823 switch (t1->ty) | |
| 8824 { | |
| 8825 case Timaginary32: type = Type::tfloat32; break; | |
| 8826 case Timaginary64: type = Type::tfloat64; break; | |
| 8827 case Timaginary80: type = Type::tfloat80; break; | |
| 8828 default: assert(0); | |
| 8829 } | |
| 8830 } | |
| 8831 else | |
| 8832 type = t2; // t2 is complex | |
| 8833 } | |
| 8834 else if (t2->isimaginary()) | |
| 8835 { | |
| 8836 type = t1; // t1 is complex | |
| 8837 } | |
| 8838 } | |
| 8839 return this; | |
| 8840 } | |
| 8841 | |
| 8842 /************************************************************/ | |
| 8843 | |
| 8844 ModExp::ModExp(Loc loc, Expression *e1, Expression *e2) | |
| 8845 : BinExp(loc, TOKmod, sizeof(ModExp), e1, e2) | |
| 8846 { | |
| 8847 } | |
| 8848 | |
| 8849 Expression *ModExp::semantic(Scope *sc) | |
| 8850 { Expression *e; | |
| 8851 | |
| 8852 if (type) | |
| 8853 return this; | |
| 8854 | |
| 8855 BinExp::semanticp(sc); | |
| 8856 e = op_overload(sc); | |
| 8857 if (e) | |
| 8858 return e; | |
| 8859 | |
| 8860 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
|
8861 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
|
8862 { 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
|
8863 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
|
8864 } |
| 159 | 8865 if (type->isfloating()) |
| 8866 { type = e1->type; | |
| 8867 if (e2->type->iscomplex()) | |
| 8868 { error("cannot perform modulo complex arithmetic"); | |
| 8869 return new IntegerExp(0); | |
| 8870 } | |
| 8871 } | |
| 8872 return this; | |
| 8873 } | |
| 8874 | |
| 8875 /************************************************************/ | |
| 8876 | |
| 8877 ShlExp::ShlExp(Loc loc, Expression *e1, Expression *e2) | |
| 8878 : BinExp(loc, TOKshl, sizeof(ShlExp), e1, e2) | |
| 8879 { | |
| 8880 } | |
| 8881 | |
| 8882 Expression *ShlExp::semantic(Scope *sc) | |
| 8883 { Expression *e; | |
| 8884 | |
| 8885 //printf("ShlExp::semantic(), type = %p\n", type); | |
| 8886 if (!type) | |
| 8887 { BinExp::semanticp(sc); | |
| 8888 e = op_overload(sc); | |
| 8889 if (e) | |
| 8890 return e; | |
| 8891 e1 = e1->checkIntegral(); | |
| 8892 e2 = e2->checkIntegral(); | |
| 8893 e1 = e1->integralPromotions(sc); | |
| 8894 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8895 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8896 type = e1->type; |
| 8897 } | |
| 8898 return this; | |
| 8899 } | |
| 8900 | |
| 8901 /************************************************************/ | |
| 8902 | |
| 8903 ShrExp::ShrExp(Loc loc, Expression *e1, Expression *e2) | |
| 8904 : BinExp(loc, TOKshr, sizeof(ShrExp), e1, e2) | |
| 8905 { | |
| 8906 } | |
| 8907 | |
| 8908 Expression *ShrExp::semantic(Scope *sc) | |
| 8909 { Expression *e; | |
| 8910 | |
| 8911 if (!type) | |
| 8912 { BinExp::semanticp(sc); | |
| 8913 e = op_overload(sc); | |
| 8914 if (e) | |
| 8915 return e; | |
| 8916 e1 = e1->checkIntegral(); | |
| 8917 e2 = e2->checkIntegral(); | |
| 8918 e1 = e1->integralPromotions(sc); | |
| 8919 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8920 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8921 type = e1->type; |
| 8922 } | |
| 8923 return this; | |
| 8924 } | |
| 8925 | |
| 8926 /************************************************************/ | |
| 8927 | |
| 8928 UshrExp::UshrExp(Loc loc, Expression *e1, Expression *e2) | |
| 8929 : BinExp(loc, TOKushr, sizeof(UshrExp), e1, e2) | |
| 8930 { | |
| 8931 } | |
| 8932 | |
| 8933 Expression *UshrExp::semantic(Scope *sc) | |
| 8934 { Expression *e; | |
| 8935 | |
| 8936 if (!type) | |
| 8937 { BinExp::semanticp(sc); | |
| 8938 e = op_overload(sc); | |
| 8939 if (e) | |
| 8940 return e; | |
| 8941 e1 = e1->checkIntegral(); | |
| 8942 e2 = e2->checkIntegral(); | |
| 8943 e1 = e1->integralPromotions(sc); | |
| 8944 //e2 = e2->castTo(sc, Type::tshiftcnt); | |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
8945 e2 = e2->castTo(sc, e1->type); // LDC |
| 159 | 8946 type = e1->type; |
| 8947 } | |
| 8948 return this; | |
| 8949 } | |
| 8950 | |
| 8951 /************************************************************/ | |
| 8952 | |
| 8953 AndExp::AndExp(Loc loc, Expression *e1, Expression *e2) | |
| 8954 : BinExp(loc, TOKand, sizeof(AndExp), e1, e2) | |
| 8955 { | |
| 8956 } | |
| 8957 | |
| 8958 Expression *AndExp::semantic(Scope *sc) | |
| 8959 { Expression *e; | |
| 8960 | |
| 8961 if (!type) | |
| 8962 { BinExp::semanticp(sc); | |
| 8963 e = op_overload(sc); | |
| 8964 if (e) | |
| 8965 return e; | |
| 8966 if (e1->type->toBasetype()->ty == Tbool && | |
| 8967 e2->type->toBasetype()->ty == Tbool) | |
| 8968 { | |
| 8969 type = e1->type; | |
| 8970 e = this; | |
| 8971 } | |
| 8972 else | |
| 8973 { | |
| 8974 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
|
8975 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
|
8976 { 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
|
8977 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
|
8978 } |
| 159 | 8979 } |
| 8980 } | |
| 8981 return this; | |
| 8982 } | |
| 8983 | |
| 8984 /************************************************************/ | |
| 8985 | |
| 8986 OrExp::OrExp(Loc loc, Expression *e1, Expression *e2) | |
| 8987 : BinExp(loc, TOKor, sizeof(OrExp), e1, e2) | |
| 8988 { | |
| 8989 } | |
| 8990 | |
| 8991 Expression *OrExp::semantic(Scope *sc) | |
| 8992 { Expression *e; | |
| 8993 | |
| 8994 if (!type) | |
| 8995 { BinExp::semanticp(sc); | |
| 8996 e = op_overload(sc); | |
| 8997 if (e) | |
| 8998 return e; | |
| 8999 if (e1->type->toBasetype()->ty == Tbool && | |
| 9000 e2->type->toBasetype()->ty == Tbool) | |
| 9001 { | |
| 9002 type = e1->type; | |
| 9003 e = this; | |
| 9004 } | |
| 9005 else | |
| 9006 { | |
| 9007 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
|
9008 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
|
9009 { 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
|
9010 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
|
9011 } |
| 159 | 9012 } |
| 9013 } | |
| 9014 return this; | |
| 9015 } | |
| 9016 | |
| 9017 /************************************************************/ | |
| 9018 | |
| 9019 XorExp::XorExp(Loc loc, Expression *e1, Expression *e2) | |
| 9020 : BinExp(loc, TOKxor, sizeof(XorExp), e1, e2) | |
| 9021 { | |
| 9022 } | |
| 9023 | |
| 9024 Expression *XorExp::semantic(Scope *sc) | |
| 9025 { Expression *e; | |
| 9026 | |
| 9027 if (!type) | |
| 9028 { BinExp::semanticp(sc); | |
| 9029 e = op_overload(sc); | |
| 9030 if (e) | |
| 9031 return e; | |
| 9032 if (e1->type->toBasetype()->ty == Tbool && | |
| 9033 e2->type->toBasetype()->ty == Tbool) | |
| 9034 { | |
| 9035 type = e1->type; | |
| 9036 e = this; | |
| 9037 } | |
| 9038 else | |
| 9039 { | |
| 9040 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
|
9041 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
|
9042 { 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
|
9043 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
|
9044 } |
| 159 | 9045 } |
| 9046 } | |
| 9047 return this; | |
| 9048 } | |
| 9049 | |
| 9050 | |
| 9051 /************************************************************/ | |
| 9052 | |
| 9053 OrOrExp::OrOrExp(Loc loc, Expression *e1, Expression *e2) | |
| 9054 : BinExp(loc, TOKoror, sizeof(OrOrExp), e1, e2) | |
| 9055 { | |
| 9056 } | |
| 9057 | |
| 9058 Expression *OrOrExp::semantic(Scope *sc) | |
| 9059 { | |
| 9060 unsigned cs1; | |
| 9061 | |
| 9062 // same as for AndAnd | |
| 9063 e1 = e1->semantic(sc); | |
| 9064 e1 = resolveProperties(sc, e1); | |
| 9065 e1 = e1->checkToPointer(); | |
| 9066 e1 = e1->checkToBoolean(); | |
| 9067 cs1 = sc->callSuper; | |
| 9068 | |
| 9069 if (sc->flags & SCOPEstaticif) | |
| 9070 { | |
| 9071 /* If in static if, don't evaluate e2 if we don't have to. | |
| 9072 */ | |
| 9073 e1 = e1->optimize(WANTflags); | |
| 9074 if (e1->isBool(TRUE)) | |
| 9075 { | |
| 9076 return new IntegerExp(loc, 1, Type::tboolean); | |
| 9077 } | |
| 9078 } | |
| 9079 | |
| 9080 e2 = e2->semantic(sc); | |
| 9081 sc->mergeCallSuper(loc, cs1); | |
| 9082 e2 = resolveProperties(sc, e2); | |
| 9083 e2 = e2->checkToPointer(); | |
| 9084 | |
| 9085 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
|
9086 if (e2->type->ty == Tvoid) |
| 159 | 9087 type = Type::tvoid; |
| 9088 if (e2->op == TOKtype || e2->op == TOKimport) | |
| 9089 error("%s is not an expression", e2->toChars()); | |
| 9090 return this; | |
| 9091 } | |
| 9092 | |
| 9093 Expression *OrOrExp::checkToBoolean() | |
| 9094 { | |
| 9095 e2 = e2->checkToBoolean(); | |
| 9096 return this; | |
| 9097 } | |
| 9098 | |
| 9099 int OrOrExp::isBit() | |
| 9100 { | |
| 9101 return TRUE; | |
| 9102 } | |
| 9103 | |
| 9104 int OrOrExp::checkSideEffect(int flag) | |
| 9105 { | |
| 9106 if (flag == 2) | |
| 9107 { | |
| 9108 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 9109 } | |
| 9110 else | |
| 9111 { e1->checkSideEffect(1); | |
| 9112 return e2->checkSideEffect(flag); | |
| 9113 } | |
| 9114 } | |
| 9115 | |
| 9116 /************************************************************/ | |
| 9117 | |
| 9118 AndAndExp::AndAndExp(Loc loc, Expression *e1, Expression *e2) | |
| 9119 : BinExp(loc, TOKandand, sizeof(AndAndExp), e1, e2) | |
| 9120 { | |
| 9121 } | |
| 9122 | |
| 9123 Expression *AndAndExp::semantic(Scope *sc) | |
| 9124 { | |
| 9125 unsigned cs1; | |
| 9126 | |
| 9127 // same as for OrOr | |
| 9128 e1 = e1->semantic(sc); | |
| 9129 e1 = resolveProperties(sc, e1); | |
| 9130 e1 = e1->checkToPointer(); | |
| 9131 e1 = e1->checkToBoolean(); | |
| 9132 cs1 = sc->callSuper; | |
| 9133 | |
| 9134 if (sc->flags & SCOPEstaticif) | |
| 9135 { | |
| 9136 /* If in static if, don't evaluate e2 if we don't have to. | |
| 9137 */ | |
| 9138 e1 = e1->optimize(WANTflags); | |
| 9139 if (e1->isBool(FALSE)) | |
| 9140 { | |
| 9141 return new IntegerExp(loc, 0, Type::tboolean); | |
| 9142 } | |
| 9143 } | |
| 9144 | |
| 9145 e2 = e2->semantic(sc); | |
| 9146 sc->mergeCallSuper(loc, cs1); | |
| 9147 e2 = resolveProperties(sc, e2); | |
| 9148 e2 = e2->checkToPointer(); | |
| 9149 | |
| 9150 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
|
9151 if (e2->type->ty == Tvoid) |
| 159 | 9152 type = Type::tvoid; |
| 9153 if (e2->op == TOKtype || e2->op == TOKimport) | |
| 9154 error("%s is not an expression", e2->toChars()); | |
| 9155 return this; | |
| 9156 } | |
| 9157 | |
| 9158 Expression *AndAndExp::checkToBoolean() | |
| 9159 { | |
| 9160 e2 = e2->checkToBoolean(); | |
| 9161 return this; | |
| 9162 } | |
| 9163 | |
| 9164 int AndAndExp::isBit() | |
| 9165 { | |
| 9166 return TRUE; | |
| 9167 } | |
| 9168 | |
| 9169 int AndAndExp::checkSideEffect(int flag) | |
| 9170 { | |
| 9171 if (flag == 2) | |
| 9172 { | |
| 9173 return e1->checkSideEffect(2) || e2->checkSideEffect(2); | |
| 9174 } | |
| 9175 else | |
| 9176 { | |
| 9177 e1->checkSideEffect(1); | |
| 9178 return e2->checkSideEffect(flag); | |
| 9179 } | |
| 9180 } | |
| 9181 | |
| 9182 /************************************************************/ | |
| 9183 | |
| 9184 InExp::InExp(Loc loc, Expression *e1, Expression *e2) | |
| 9185 : BinExp(loc, TOKin, sizeof(InExp), e1, e2) | |
| 9186 { | |
| 9187 } | |
| 9188 | |
| 9189 Expression *InExp::semantic(Scope *sc) | |
| 9190 { Expression *e; | |
| 9191 | |
| 9192 if (type) | |
| 9193 return this; | |
| 9194 | |
| 9195 BinExp::semanticp(sc); | |
| 9196 e = op_overload(sc); | |
| 9197 if (e) | |
| 9198 return e; | |
| 9199 | |
| 9200 //type = Type::tboolean; | |
| 9201 Type *t2b = e2->type->toBasetype(); | |
| 9202 if (t2b->ty != Taarray) | |
| 9203 { | |
| 9204 error("rvalue of in expression must be an associative array, not %s", e2->type->toChars()); | |
| 9205 type = Type::terror; | |
| 9206 } | |
| 9207 else | |
| 9208 { | |
| 9209 TypeAArray *ta = (TypeAArray *)t2b; | |
| 9210 | |
| 9211 // Convert key to type of key | |
| 9212 e1 = e1->implicitCastTo(sc, ta->index); | |
| 9213 | |
| 9214 // 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
|
9215 type = ta->nextOf()->pointerTo(); |
| 159 | 9216 } |
| 9217 return this; | |
| 9218 } | |
| 9219 | |
| 9220 int InExp::isBit() | |
| 9221 { | |
| 9222 return FALSE; | |
| 9223 } | |
| 9224 | |
| 9225 | |
| 9226 /************************************************************/ | |
| 9227 | |
| 9228 /* This deletes the key e1 from the associative array e2 | |
| 9229 */ | |
| 9230 | |
| 9231 RemoveExp::RemoveExp(Loc loc, Expression *e1, Expression *e2) | |
| 9232 : BinExp(loc, TOKremove, sizeof(RemoveExp), e1, e2) | |
| 9233 { | |
| 9234 type = Type::tvoid; | |
| 9235 } | |
| 9236 | |
| 9237 /************************************************************/ | |
| 9238 | |
| 9239 CmpExp::CmpExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9240 : BinExp(loc, op, sizeof(CmpExp), e1, e2) | |
| 9241 { | |
| 9242 } | |
| 9243 | |
| 9244 Expression *CmpExp::semantic(Scope *sc) | |
| 9245 { Expression *e; | |
| 9246 Type *t1; | |
| 9247 Type *t2; | |
| 9248 | |
| 9249 #if LOGSEMANTIC | |
| 9250 printf("CmpExp::semantic('%s')\n", toChars()); | |
| 9251 #endif | |
| 9252 if (type) | |
| 9253 return this; | |
| 9254 | |
| 9255 BinExp::semanticp(sc); | |
| 9256 | |
| 9257 if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull || | |
| 9258 e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull) | |
| 9259 { | |
| 9260 error("do not use null when comparing class types"); | |
| 9261 } | |
| 9262 | |
| 9263 e = op_overload(sc); | |
| 9264 if (e) | |
| 9265 { | |
| 9266 e = new CmpExp(op, loc, e, new IntegerExp(loc, 0, Type::tint32)); | |
| 9267 e = e->semantic(sc); | |
| 9268 return e; | |
| 9269 } | |
| 9270 | |
| 9271 typeCombine(sc); | |
| 9272 type = Type::tboolean; | |
| 9273 | |
| 9274 // Special handling for array comparisons | |
| 9275 t1 = e1->type->toBasetype(); | |
| 9276 t2 = e2->type->toBasetype(); | |
| 9277 if ((t1->ty == Tarray || t1->ty == Tsarray) && | |
| 9278 (t2->ty == Tarray || t2->ty == Tsarray)) | |
| 9279 { | |
| 9280 if (!t1->next->equals(t2->next)) | |
| 9281 error("array comparison type mismatch, %s vs %s", t1->next->toChars(), t2->next->toChars()); | |
| 9282 e = this; | |
| 9283 } | |
| 9284 else if (t1->ty == Tstruct || t2->ty == Tstruct || | |
| 9285 (t1->ty == Tclass && t2->ty == Tclass)) | |
| 9286 { | |
| 9287 if (t2->ty == Tstruct) | |
| 9288 error("need member function opCmp() for %s %s to compare", t2->toDsymbol(sc)->kind(), t2->toChars()); | |
| 9289 else | |
| 9290 error("need member function opCmp() for %s %s to compare", t1->toDsymbol(sc)->kind(), t1->toChars()); | |
| 9291 e = this; | |
| 9292 } | |
| 9293 #if 1 | |
| 9294 else if (t1->iscomplex() || t2->iscomplex()) | |
| 9295 { | |
| 9296 error("compare not defined for complex operands"); | |
| 9297 e = new IntegerExp(0); | |
| 9298 } | |
| 9299 #endif | |
| 9300 else | |
| 9301 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
|
9302 //printf("CmpExp: %s\n", e->toChars()); |
| 159 | 9303 return e; |
| 9304 } | |
| 9305 | |
| 9306 int CmpExp::isBit() | |
| 9307 { | |
| 9308 return TRUE; | |
| 9309 } | |
| 9310 | |
| 9311 | |
| 9312 /************************************************************/ | |
| 9313 | |
| 9314 EqualExp::EqualExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9315 : BinExp(loc, op, sizeof(EqualExp), e1, e2) | |
| 9316 { | |
| 9317 assert(op == TOKequal || op == TOKnotequal); | |
| 9318 } | |
| 9319 | |
| 9320 Expression *EqualExp::semantic(Scope *sc) | |
| 9321 { Expression *e; | |
| 9322 Type *t1; | |
| 9323 Type *t2; | |
| 9324 | |
| 9325 //printf("EqualExp::semantic('%s')\n", toChars()); | |
| 9326 if (type) | |
| 9327 return this; | |
| 9328 | |
| 9329 BinExp::semanticp(sc); | |
| 9330 | |
| 9331 /* Before checking for operator overloading, check to see if we're | |
| 9332 * comparing the addresses of two statics. If so, we can just see | |
| 9333 * if they are the same symbol. | |
| 9334 */ | |
| 9335 if (e1->op == TOKaddress && e2->op == TOKaddress) | |
| 9336 { AddrExp *ae1 = (AddrExp *)e1; | |
| 9337 AddrExp *ae2 = (AddrExp *)e2; | |
| 9338 | |
| 9339 if (ae1->e1->op == TOKvar && ae2->e1->op == TOKvar) | |
| 9340 { VarExp *ve1 = (VarExp *)ae1->e1; | |
| 9341 VarExp *ve2 = (VarExp *)ae2->e1; | |
| 9342 | |
| 9343 if (ve1->var == ve2->var /*|| ve1->var->toSymbol() == ve2->var->toSymbol()*/) | |
| 9344 { | |
| 9345 // They are the same, result is 'true' for ==, 'false' for != | |
| 9346 e = new IntegerExp(loc, (op == TOKequal), Type::tboolean); | |
| 9347 return e; | |
| 9348 } | |
| 9349 } | |
| 9350 } | |
| 9351 | |
| 9352 if (e1->type->toBasetype()->ty == Tclass && e2->op == TOKnull || | |
| 9353 e2->type->toBasetype()->ty == Tclass && e1->op == TOKnull) | |
| 9354 { | |
| 9355 error("use '%s' instead of '%s' when comparing with null", | |
| 9356 Token::toChars(op == TOKequal ? TOKidentity : TOKnotidentity), | |
| 9357 Token::toChars(op)); | |
| 9358 } | |
| 9359 | |
| 9360 //if (e2->op != TOKnull) | |
| 9361 { | |
| 9362 e = op_overload(sc); | |
| 9363 if (e) | |
| 9364 { | |
| 9365 if (op == TOKnotequal) | |
| 9366 { | |
| 9367 e = new NotExp(e->loc, e); | |
| 9368 e = e->semantic(sc); | |
| 9369 } | |
| 9370 return e; | |
| 9371 } | |
| 9372 } | |
| 9373 | |
| 9374 e = typeCombine(sc); | |
| 9375 type = Type::tboolean; | |
| 9376 | |
| 9377 // Special handling for array comparisons | |
| 9378 t1 = e1->type->toBasetype(); | |
| 9379 t2 = e2->type->toBasetype(); | |
| 9380 if ((t1->ty == Tarray || t1->ty == Tsarray) && | |
| 9381 (t2->ty == Tarray || t2->ty == Tsarray)) | |
| 9382 { | |
| 9383 if (!t1->next->equals(t2->next)) | |
| 9384 error("array comparison type mismatch, %s vs %s", t1->next->toChars(), t2->next->toChars()); | |
| 9385 } | |
| 9386 else | |
| 9387 { | |
| 9388 if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) | |
| 9389 { | |
| 9390 // Cast both to complex | |
| 9391 e1 = e1->castTo(sc, Type::tcomplex80); | |
| 9392 e2 = e2->castTo(sc, Type::tcomplex80); | |
| 9393 } | |
| 9394 } | |
| 9395 return e; | |
| 9396 } | |
| 9397 | |
| 9398 int EqualExp::isBit() | |
| 9399 { | |
| 9400 return TRUE; | |
| 9401 } | |
| 9402 | |
| 9403 | |
| 9404 | |
| 9405 /************************************************************/ | |
| 9406 | |
| 9407 IdentityExp::IdentityExp(enum TOK op, Loc loc, Expression *e1, Expression *e2) | |
| 9408 : BinExp(loc, op, sizeof(IdentityExp), e1, e2) | |
| 9409 { | |
| 9410 } | |
| 9411 | |
| 9412 Expression *IdentityExp::semantic(Scope *sc) | |
| 9413 { | |
| 9414 if (type) | |
| 9415 return this; | |
| 9416 | |
| 9417 BinExp::semanticp(sc); | |
| 9418 type = Type::tboolean; | |
| 9419 typeCombine(sc); | |
| 9420 if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) | |
| 9421 { | |
| 9422 // Cast both to complex | |
| 9423 e1 = e1->castTo(sc, Type::tcomplex80); | |
| 9424 e2 = e2->castTo(sc, Type::tcomplex80); | |
| 9425 } | |
| 9426 return this; | |
| 9427 } | |
| 9428 | |
| 9429 int IdentityExp::isBit() | |
| 9430 { | |
| 9431 return TRUE; | |
| 9432 } | |
| 9433 | |
| 9434 | |
| 9435 /****************************************************************/ | |
| 9436 | |
| 9437 CondExp::CondExp(Loc loc, Expression *econd, Expression *e1, Expression *e2) | |
| 9438 : BinExp(loc, TOKquestion, sizeof(CondExp), e1, e2) | |
| 9439 { | |
| 9440 this->econd = econd; | |
| 9441 } | |
| 9442 | |
| 9443 Expression *CondExp::syntaxCopy() | |
| 9444 { | |
| 9445 return new CondExp(loc, econd->syntaxCopy(), e1->syntaxCopy(), e2->syntaxCopy()); | |
| 9446 } | |
| 9447 | |
| 9448 | |
| 9449 Expression *CondExp::semantic(Scope *sc) | |
| 9450 { Type *t1; | |
| 9451 Type *t2; | |
| 9452 unsigned cs0; | |
| 9453 unsigned cs1; | |
| 9454 | |
| 9455 #if LOGSEMANTIC | |
| 9456 printf("CondExp::semantic('%s')\n", toChars()); | |
| 9457 #endif | |
| 9458 if (type) | |
| 9459 return this; | |
| 9460 | |
| 9461 econd = econd->semantic(sc); | |
| 9462 econd = resolveProperties(sc, econd); | |
| 9463 econd = econd->checkToPointer(); | |
| 9464 econd = econd->checkToBoolean(); | |
| 9465 | |
| 9466 #if 0 /* this cannot work right because the types of e1 and e2 | |
| 9467 * both contribute to the type of the result. | |
| 9468 */ | |
| 9469 if (sc->flags & SCOPEstaticif) | |
| 9470 { | |
| 9471 /* If in static if, don't evaluate what we don't have to. | |
| 9472 */ | |
| 9473 econd = econd->optimize(WANTflags); | |
| 9474 if (econd->isBool(TRUE)) | |
| 9475 { | |
| 9476 e1 = e1->semantic(sc); | |
| 9477 e1 = resolveProperties(sc, e1); | |
| 9478 return e1; | |
| 9479 } | |
| 9480 else if (econd->isBool(FALSE)) | |
| 9481 { | |
| 9482 e2 = e2->semantic(sc); | |
| 9483 e2 = resolveProperties(sc, e2); | |
| 9484 return e2; | |
| 9485 } | |
| 9486 } | |
| 9487 #endif | |
| 9488 | |
| 9489 | |
| 9490 cs0 = sc->callSuper; | |
| 9491 e1 = e1->semantic(sc); | |
| 9492 e1 = resolveProperties(sc, e1); | |
| 9493 cs1 = sc->callSuper; | |
| 9494 sc->callSuper = cs0; | |
| 9495 e2 = e2->semantic(sc); | |
| 9496 e2 = resolveProperties(sc, e2); | |
| 9497 sc->mergeCallSuper(loc, cs1); | |
| 9498 | |
| 9499 | |
| 9500 // If either operand is void, the result is void | |
| 9501 t1 = e1->type; | |
| 9502 t2 = e2->type; | |
| 9503 if (t1->ty == Tvoid || t2->ty == Tvoid) | |
| 9504 type = Type::tvoid; | |
| 9505 else if (t1 == t2) | |
| 9506 type = t1; | |
| 9507 else | |
| 9508 { | |
| 9509 typeCombine(sc); | |
| 9510 switch (e1->type->toBasetype()->ty) | |
| 9511 { | |
| 9512 case Tcomplex32: | |
| 9513 case Tcomplex64: | |
| 9514 case Tcomplex80: | |
| 9515 e2 = e2->castTo(sc, e1->type); | |
| 9516 break; | |
| 9517 } | |
| 9518 switch (e2->type->toBasetype()->ty) | |
| 9519 { | |
| 9520 case Tcomplex32: | |
| 9521 case Tcomplex64: | |
| 9522 case Tcomplex80: | |
| 9523 e1 = e1->castTo(sc, e2->type); | |
| 9524 break; | |
| 9525 } | |
| 9526 } | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9527 #if 0 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9528 printf("res: %s\n", type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9529 printf("e1 : %s\n", e1->type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9530 printf("e2 : %s\n", e2->type->toChars()); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9531 #endif |
| 159 | 9532 return this; |
| 9533 } | |
| 9534 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9535 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9536 int CondExp::isLvalue() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9537 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9538 return e1->isLvalue() && e2->isLvalue(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9539 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9540 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9541 |
| 159 | 9542 Expression *CondExp::toLvalue(Scope *sc, Expression *ex) |
| 9543 { | |
| 9544 PtrExp *e; | |
| 9545 | |
| 9546 // convert (econd ? e1 : e2) to *(econd ? &e1 : &e2) | |
| 9547 e = new PtrExp(loc, this, type); | |
| 9548 | |
| 9549 e1 = e1->addressOf(sc); | |
| 9550 //e1 = e1->toLvalue(sc, NULL); | |
| 9551 | |
| 9552 e2 = e2->addressOf(sc); | |
| 9553 //e2 = e2->toLvalue(sc, NULL); | |
| 9554 | |
| 9555 typeCombine(sc); | |
| 9556 | |
| 9557 type = e2->type; | |
| 9558 return e; | |
| 9559 } | |
| 9560 | |
| 9561 Expression *CondExp::modifiableLvalue(Scope *sc, Expression *e) | |
| 9562 { | |
| 9563 error("conditional expression %s is not a modifiable lvalue", toChars()); | |
| 9564 return this; | |
| 9565 } | |
| 9566 | |
| 9567 void CondExp::checkEscape() | |
| 9568 { | |
| 9569 e1->checkEscape(); | |
| 9570 e2->checkEscape(); | |
| 9571 } | |
| 9572 | |
| 9573 | |
| 9574 Expression *CondExp::checkToBoolean() | |
| 9575 { | |
| 9576 e1 = e1->checkToBoolean(); | |
| 9577 e2 = e2->checkToBoolean(); | |
| 9578 return this; | |
| 9579 } | |
| 9580 | |
| 9581 int CondExp::checkSideEffect(int flag) | |
| 9582 { | |
| 9583 if (flag == 2) | |
| 9584 { | |
| 9585 return econd->checkSideEffect(2) || | |
| 9586 e1->checkSideEffect(2) || | |
| 9587 e2->checkSideEffect(2); | |
| 9588 } | |
| 9589 else | |
| 9590 { | |
| 9591 econd->checkSideEffect(1); | |
| 9592 e1->checkSideEffect(flag); | |
| 9593 return e2->checkSideEffect(flag); | |
| 9594 } | |
| 9595 } | |
| 9596 | |
|
875
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9597 #if DMDV2 |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9598 int CondExp::canThrow() |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9599 { |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9600 return econd->canThrow() || e1->canThrow() || e2->canThrow(); |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9601 } |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9602 #endif |
|
330f999ade44
Merged DMD 1.038
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
parents:
846
diff
changeset
|
9603 |
| 159 | 9604 void CondExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs) |
| 9605 { | |
| 9606 expToCBuffer(buf, hgs, econd, PREC_oror); | |
| 9607 buf->writestring(" ? "); | |
| 9608 expToCBuffer(buf, hgs, e1, PREC_expr); | |
| 9609 buf->writestring(" : "); | |
| 9610 expToCBuffer(buf, hgs, e2, PREC_cond); | |
| 9611 } | |
| 9612 | |
|
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
|
9613 /************************************************************/ |
|
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
|
9614 |
|
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
|
9615 #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
|
9616 |
|
664
eef8ac26c66c
Some missed LLVMDC -> LDC.
Christian Kamm <kamm incasoftware de>
parents:
639
diff
changeset
|
9617 // 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
|
9618 |
|
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
|
9619 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
|
9620 : 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
|
9621 { |
|
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
|
9622 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
|
9623 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
|
9624 } |
|
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
|
9625 |
|
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
|
9626 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
|
9627 { |
|
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
|
9628 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
|
9629 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
|
9630 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
|
9631 } |
|
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
|
9632 |
|
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
|
9633 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
|
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 // 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
|
9636 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
|
9637 } |
|
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
|
9638 |
|
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 #endif |