Mercurial > projects > ddmd
annotate dmd/expression/Util.d @ 64:4290d870944a
More fixes
| author | korDen |
|---|---|
| date | Mon, 23 Aug 2010 20:29:15 +0400 |
| parents | 3adbb28755e8 |
| children | ef02e2e203c2 |
| rev | line source |
|---|---|
| 0 | 1 module dmd.expression.Util; |
| 2 | |
| 3 import dmd.Expression; | |
| 4 import dmd.Loc; | |
| 53 | 5 import dmd.RealExp; |
| 0 | 6 import dmd.Scope; |
| 7 import dmd.FuncExp; | |
| 8 import dmd.DelegateExp; | |
| 9 import dmd.LINK; | |
| 10 import dmd.NullExp; | |
| 11 import dmd.SymOffExp; | |
| 12 import dmd.ExpInitializer; | |
| 13 import dmd.Lexer; | |
| 14 import dmd.TypeSArray; | |
| 15 import dmd.TypeArray; | |
| 16 import dmd.VarDeclaration; | |
| 17 import dmd.VoidInitializer; | |
| 18 import dmd.DeclarationExp; | |
| 19 import dmd.VarExp; | |
| 20 import dmd.NewExp; | |
| 21 import dmd.STC; | |
| 22 import dmd.WANT; | |
| 23 import dmd.IndexExp; | |
| 24 import dmd.AssignExp; | |
| 25 import dmd.CommaExp; | |
| 26 import dmd.Argument; | |
| 27 import dmd.DefaultInitExp; | |
| 28 import dmd.Identifier; | |
| 29 import dmd.Dsymbol; | |
| 30 import dmd.Global; | |
| 31 import dmd.ScopeDsymbol; | |
| 32 import dmd.DotIdExp; | |
| 33 import dmd.DotVarExp; | |
| 34 import dmd.CallExp; | |
| 35 import dmd.TY; | |
| 36 import dmd.MATCH; | |
| 53 | 37 import dmd.BUILTIN; |
| 0 | 38 import dmd.TypeFunction; |
| 39 import dmd.declaration.Match; | |
| 40 import dmd.ArrayTypes; | |
| 41 import dmd.Declaration; | |
| 42 import dmd.FuncAliasDeclaration; | |
| 43 import dmd.AliasDeclaration; | |
| 44 import dmd.FuncDeclaration; | |
| 45 import dmd.TemplateDeclaration; | |
| 46 import dmd.AggregateDeclaration; | |
| 47 import dmd.IntegerExp; | |
| 48 import dmd.Type; | |
| 49 import dmd.TOK; | |
| 50 import dmd.TypeExp; | |
| 51 import dmd.TypeTuple; | |
| 52 import dmd.TupleExp; | |
| 53 import dmd.OutBuffer; | |
| 54 import dmd.HdrGenState; | |
| 55 import dmd.ClassDeclaration; | |
| 56 import dmd.TypeClass; | |
| 57 import dmd.StructDeclaration; | |
| 58 import dmd.TypeStruct; | |
| 59 import dmd.MOD; | |
| 60 import dmd.PROT; | |
| 61 import dmd.PREC; | |
| 62 import dmd.Util; | |
| 63 import dmd.TypeAArray; | |
| 64 import dmd.Id; | |
| 65 | |
| 66 import std.stdio : writef; | |
| 67 | |
| 68 | |
| 69 /*********************************** | |
| 70 * Utility to build a function call out of this reference and argument. | |
| 71 */ | |
| 72 Expression build_overload(Loc loc, Scope sc, Expression ethis, Expression earg, Identifier id) | |
| 73 { | |
| 74 Expression e; | |
| 75 | |
| 76 //printf("build_overload(id = '%s')\n", id.toChars()); | |
| 77 //earg.print(); | |
| 78 //earg.type.print(); | |
| 79 e = new DotIdExp(loc, ethis, id); | |
| 80 | |
| 81 if (earg) | |
| 82 e = new CallExp(loc, e, earg); | |
| 83 else | |
| 84 e = new CallExp(loc, e); | |
| 85 | |
| 86 e = e.semantic(sc); | |
| 87 return e; | |
| 88 } | |
| 89 | |
| 90 /*************************************** | |
| 91 * Search for function funcid in aggregate ad. | |
| 92 */ | |
| 93 | |
| 94 Dsymbol search_function(ScopeDsymbol ad, Identifier funcid) | |
| 95 { | |
| 96 Dsymbol s; | |
| 97 FuncDeclaration fd; | |
| 98 TemplateDeclaration td; | |
| 99 | |
| 100 s = ad.search(Loc(0), funcid, 0); | |
| 101 if (s) | |
| 102 { | |
| 103 Dsymbol s2; | |
| 104 | |
| 105 //printf("search_function: s = '%s'\n", s.kind()); | |
| 106 s2 = s.toAlias(); | |
| 107 //printf("search_function: s2 = '%s'\n", s2.kind()); | |
| 108 fd = s2.isFuncDeclaration(); | |
| 109 if (fd && fd.type.ty == TY.Tfunction) | |
| 110 return fd; | |
| 111 | |
| 112 td = s2.isTemplateDeclaration(); | |
| 113 if (td) | |
| 114 return td; | |
| 115 } | |
| 116 | |
| 117 return null; | |
| 118 } | |
| 119 | |
| 120 /******************************************** | |
| 121 * Find function in overload list that exactly matches t. | |
| 122 */ | |
| 123 | |
| 124 /*************************************************** | |
| 125 * Visit each overloaded function in turn, and call | |
| 126 * dg(param, f) on it. | |
| 127 * Exit when no more, or dg(param, f) returns 1. | |
| 128 * Returns: | |
| 129 * 0 continue | |
| 130 * 1 done | |
| 131 */ | |
| 132 | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
133 int overloadApply(FuncDeclaration fstart, int delegate(void*, FuncDeclaration) dg, void* param) |
| 0 | 134 { |
| 135 FuncDeclaration f; | |
| 136 Declaration d; | |
| 137 Declaration next; | |
| 138 | |
| 139 for (d = fstart; d; d = next) | |
| 140 { | |
| 141 FuncAliasDeclaration fa = d.isFuncAliasDeclaration(); | |
| 142 | |
| 143 if (fa) | |
| 144 { | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
145 if (overloadApply(fa.funcalias, dg, param)) |
| 0 | 146 return 1; |
| 147 next = fa.overnext; | |
| 148 } | |
| 149 else | |
| 150 { | |
| 151 AliasDeclaration a = d.isAliasDeclaration(); | |
| 152 | |
| 153 if (a) | |
| 154 { | |
| 155 Dsymbol s = a.toAlias(); | |
| 156 next = s.isDeclaration(); | |
| 157 if (next is a) | |
| 158 break; | |
| 159 if (next is fstart) | |
| 160 break; | |
| 161 } | |
| 162 else | |
| 163 { | |
| 164 f = d.isFuncDeclaration(); | |
| 165 if (f is null) | |
| 166 { | |
| 167 d.error("is aliased to a function"); | |
| 168 break; // BUG: should print error message? | |
| 169 } | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
170 if (dg(param, f)) |
| 0 | 171 return 1; |
| 172 | |
| 173 next = f.overnext; | |
| 174 } | |
| 175 } | |
| 176 } | |
| 177 return 0; | |
| 178 } | |
| 179 | |
| 180 /******************************************** | |
| 181 * Decide which function matches the arguments best. | |
| 182 */ | |
| 183 | |
| 184 struct Param2 | |
| 185 { | |
| 186 Match* m; | |
| 187 Expression ethis; | |
| 188 Expressions arguments; | |
| 189 | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
190 int fp2(void*, FuncDeclaration f) |
| 0 | 191 { |
| 192 MATCH match; | |
| 193 | |
| 194 if (f != m.lastf) // skip duplicates | |
| 195 { | |
| 196 m.anyf = f; | |
| 197 TypeFunction tf = cast(TypeFunction)f.type; | |
| 198 match = tf.callMatch(f.needThis() ? ethis : null, arguments); | |
| 199 //printf("match = %d\n", match); | |
| 200 if (match != MATCH.MATCHnomatch) | |
| 201 { | |
| 202 if (match > m.last) | |
| 203 goto LfIsBetter; | |
| 204 | |
| 205 if (match < m.last) | |
| 206 goto LlastIsBetter; | |
| 207 | |
| 208 /* See if one of the matches overrides the other. | |
| 209 */ | |
| 210 if (m.lastf.overrides(f)) | |
| 211 goto LlastIsBetter; | |
| 212 else if (f.overrides(m.lastf)) | |
| 213 goto LfIsBetter; | |
| 214 | |
| 215 /* Try to disambiguate using template-style partial ordering rules. | |
| 216 * In essence, if f() and g() are ambiguous, if f() can call g(), | |
| 217 * but g() cannot call f(), then pick f(). | |
| 218 * This is because f() is "more specialized." | |
| 219 */ | |
| 220 { | |
| 221 MATCH c1 = f.leastAsSpecialized(m.lastf); | |
| 222 MATCH c2 = m.lastf.leastAsSpecialized(f); | |
| 223 //printf("c1 = %d, c2 = %d\n", c1, c2); | |
| 224 if (c1 > c2) | |
| 225 goto LfIsBetter; | |
| 226 if (c1 < c2) | |
| 227 goto LlastIsBetter; | |
| 228 } | |
| 229 | |
| 230 Lambiguous: | |
| 231 m.nextf = f; | |
| 232 m.count++; | |
| 233 return 0; | |
| 234 | |
| 235 LfIsBetter: | |
| 236 m.last = match; | |
| 237 m.lastf = f; | |
| 238 m.count = 1; | |
| 239 return 0; | |
| 240 | |
| 241 LlastIsBetter: | |
| 242 return 0; | |
| 243 } | |
| 244 } | |
| 245 return 0; | |
| 246 } | |
| 247 } | |
| 248 | |
| 249 struct Param1 | |
| 250 { | |
| 251 Type t; // type to match | |
| 252 FuncDeclaration f; // return value | |
| 253 | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
254 int fp1(void*, FuncDeclaration f) |
| 0 | 255 { |
| 256 if (t.equals(f.type)) | |
| 257 { | |
| 258 this.f = f; | |
| 259 return 1; | |
| 260 } | |
| 261 | |
| 262 version (DMDV2) { | |
| 263 /* Allow covariant matches, if it's just a const conversion | |
| 264 * of the return type | |
| 265 */ | |
| 266 if (t.ty == Tfunction) | |
| 267 { | |
| 268 TypeFunction tf = cast(TypeFunction)f.type; | |
| 269 if (tf.covariant(t) == 1 && | |
| 270 tf.nextOf().implicitConvTo(t.nextOf()) >= MATCHconst) | |
| 271 { | |
| 272 this.f = f; | |
| 273 return 1; | |
| 274 } | |
| 275 } | |
| 276 } | |
| 277 return 0; | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 void overloadResolveX(Match* m, FuncDeclaration fstart, Expression ethis, Expressions arguments) | |
| 282 { | |
| 283 Param2 p; | |
| 284 p.m = m; | |
| 285 p.ethis = ethis; | |
| 286 p.arguments = arguments; | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
287 overloadApply(fstart, &p.fp2, &p); |
| 0 | 288 } |
| 289 | |
| 290 void templateResolve(Match* m, TemplateDeclaration td, Scope sc, Loc loc, Objects targsi, Expression ethis, Expressions arguments) | |
| 291 { | |
| 292 FuncDeclaration fd; | |
| 293 | |
| 294 assert(td); | |
| 295 fd = td.deduceFunctionTemplate(sc, loc, targsi, ethis, arguments); | |
| 296 if (!fd) | |
| 297 return; | |
| 298 m.anyf = fd; | |
| 299 if (m.last >= MATCH.MATCHexact) | |
| 300 { | |
| 301 m.nextf = fd; | |
| 302 m.count++; | |
| 303 } | |
| 304 else | |
| 305 { | |
| 306 m.last = MATCH.MATCHexact; | |
| 307 m.lastf = fd; | |
| 308 m.count = 1; | |
| 309 } | |
| 310 } | |
| 311 | |
| 312 /****************************** | |
| 313 * Perform semantic() on an array of Expressions. | |
| 314 */ | |
| 315 | |
| 316 void arrayExpressionSemantic(Expressions exps, Scope sc) | |
| 317 { | |
| 318 if (exps) | |
| 319 { | |
| 320 for (size_t i = 0; i < exps.dim; i++) | |
| 321 { | |
| 322 Expression e = cast(Expression)exps.data[i]; | |
| 323 | |
| 324 e = e.semantic(sc); | |
| 325 exps.data[i] = cast(void*)e; | |
| 326 } | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 /**************************************** | |
| 331 * Preprocess arguments to function. | |
| 332 */ | |
| 333 | |
| 334 void preFunctionArguments(Loc loc, Scope sc, Expressions exps) | |
| 335 { | |
| 336 if (exps) | |
| 337 { | |
| 338 expandTuples(exps); | |
| 57 | 339 |
| 0 | 340 for (size_t i = 0; i < exps.dim; i++) |
| 341 { | |
| 342 Expression arg = cast(Expression)exps.data[i]; | |
| 343 | |
| 344 if (!arg.type) | |
| 345 { | |
| 346 debug { | |
| 57 | 347 if (!global.gag) { |
| 0 | 348 writef("1: \n"); |
| 57 | 349 } |
| 0 | 350 } |
| 351 arg.error("%s is not an expression", arg.toChars()); | |
| 352 arg = new IntegerExp(arg.loc, 0, Type.tint32); | |
| 353 } | |
| 354 | |
| 355 arg = resolveProperties(sc, arg); | |
| 356 exps.data[i] = cast(void*) arg; | |
| 357 | |
| 358 //arg.rvalue(); | |
| 359 static if (false) { | |
| 360 if (arg.type.ty == TY.Tfunction) | |
| 361 { | |
| 362 arg = new AddrExp(arg.loc, arg); | |
| 363 arg = arg.semantic(sc); | |
| 364 exps.data[i] = cast(void*) arg; | |
| 365 } | |
| 366 } | |
| 367 } | |
| 368 } | |
| 369 } | |
| 370 | |
| 371 /************************************************************* | |
| 372 * Given var, we need to get the | |
| 373 * right 'this' pointer if var is in an outer class, but our | |
| 374 * existing 'this' pointer is in an inner class. | |
| 375 * Input: | |
| 376 * e1 existing 'this' | |
| 377 * ad struct or class we need the correct 'this' for | |
| 378 * var the specific member of ad we're accessing | |
| 379 */ | |
| 380 | |
| 381 Expression getRightThis(Loc loc, Scope sc, AggregateDeclaration ad, Expression e1, Declaration var) | |
| 382 { | |
| 383 //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1.toChars(), ad.toChars(), var.toChars()); | |
| 384 L1: | |
| 385 Type t = e1.type.toBasetype(); | |
| 386 //printf("e1.type = %s, var.type = %s\n", e1.type.toChars(), var.type.toChars()); | |
| 387 | |
| 388 /* If e1 is not the 'this' pointer for ad | |
| 389 */ | |
| 390 if (ad && !(t.ty == TY.Tpointer && t.nextOf().ty == TY.Tstruct && (cast(TypeStruct)t.nextOf()).sym == ad) && !(t.ty == TY.Tstruct && (cast(TypeStruct)t).sym == ad)) | |
| 391 { | |
| 392 ClassDeclaration cd = ad.isClassDeclaration(); | |
| 393 ClassDeclaration tcd = t.isClassHandle(); | |
| 394 | |
| 395 /* e1 is the right this if ad is a base class of e1 | |
| 396 */ | |
| 397 if (!cd || !tcd || !(tcd == cd || cd.isBaseOf(tcd, null))) | |
| 398 { | |
| 399 /* Only classes can be inner classes with an 'outer' | |
| 400 * member pointing to the enclosing class instance | |
| 401 */ | |
| 402 if (tcd && tcd.isNested()) | |
| 403 { | |
| 404 /* e1 is the 'this' pointer for an inner class: tcd. | |
| 405 * Rewrite it as the 'this' pointer for the outer class. | |
| 406 */ | |
| 407 | |
| 408 e1 = new DotVarExp(loc, e1, tcd.vthis); | |
| 409 e1.type = tcd.vthis.type; | |
| 410 // Do not call checkNestedRef() | |
| 411 //e1 = e1.semantic(sc); | |
| 412 | |
| 413 // Skip up over nested functions, and get the enclosing | |
| 414 // class type. | |
| 415 int n = 0; | |
| 416 Dsymbol s; | |
| 417 for (s = tcd.toParent(); s && s.isFuncDeclaration(); s = s.toParent()) | |
| 418 { | |
| 419 FuncDeclaration f = s.isFuncDeclaration(); | |
| 420 if (f.vthis) | |
| 421 { | |
| 422 //printf("rewriting e1 to %s's this\n", f.toChars()); | |
| 423 n++; | |
| 424 e1 = new VarExp(loc, f.vthis); | |
| 425 } | |
| 426 } | |
| 427 if (s && s.isClassDeclaration()) | |
| 428 { | |
| 429 e1.type = s.isClassDeclaration().type; | |
| 430 if (n > 1) | |
| 431 e1 = e1.semantic(sc); | |
| 432 } | |
| 433 else | |
| 434 e1 = e1.semantic(sc); | |
| 435 goto L1; | |
| 436 } | |
| 437 /* Can't find a path from e1 to ad | |
| 438 */ | |
| 439 e1.error("this for %s needs to be type %s not type %s", var.toChars(), ad.toChars(), t.toChars()); | |
| 440 } | |
| 441 } | |
| 442 return e1; | |
| 443 } | |
| 444 | |
| 445 /******************************************* | |
| 446 * Given a symbol that could be either a FuncDeclaration or | |
| 447 * a function template, resolve it to a function symbol. | |
| 448 * sc instantiation scope | |
| 449 * loc instantiation location | |
| 450 * targsi initial list of template arguments | |
| 451 * ethis if !null, the 'this' pointer argument | |
| 452 * fargs arguments to function | |
| 453 * flags 1: do not issue error message on no match, just return null | |
| 454 */ | |
| 455 | |
| 456 FuncDeclaration resolveFuncCall(Scope sc, Loc loc, Dsymbol s, | |
| 457 Objects tiargs, | |
| 458 Expression ethis, | |
| 459 Expressions arguments, | |
| 460 int flags) | |
| 461 { | |
| 462 if (!s) | |
| 463 return null; // no match | |
| 464 FuncDeclaration f = s.isFuncDeclaration(); | |
| 465 if (f) | |
| 466 f = f.overloadResolve(loc, ethis, arguments); | |
| 467 else | |
| 468 { | |
| 469 TemplateDeclaration td = s.isTemplateDeclaration(); | |
| 470 assert(td); | |
| 471 f = td.deduceFunctionTemplate(sc, loc, tiargs, null, arguments, flags); | |
| 472 } | |
| 473 return f; | |
| 474 } | |
| 475 | |
| 476 /**************************************** | |
| 477 * Now that we know the exact type of the function we're calling, | |
| 478 * the arguments[] need to be adjusted: | |
| 479 * 1. implicitly convert argument to the corresponding parameter type | |
| 480 * 2. add default arguments for any missing arguments | |
| 481 * 3. do default promotions on arguments corresponding to ... | |
| 482 * 4. add hidden _arguments[] argument | |
| 483 * 5. call copy constructor for struct value arguments | |
| 484 */ | |
| 485 | |
| 486 void functionArguments(Loc loc, Scope sc, TypeFunction tf, Expressions arguments) | |
| 487 { | |
| 488 uint n; | |
| 489 | |
| 490 //printf("functionArguments()\n"); | |
| 491 assert(arguments); | |
| 492 size_t nargs = arguments ? arguments.dim : 0; | |
| 493 size_t nparams = Argument.dim(tf.parameters); | |
| 494 | |
| 495 if (nargs > nparams && tf.varargs == 0) | |
| 496 error(loc, "expected %zu arguments, not %zu for non-variadic function type %s", nparams, nargs, tf.toChars()); | |
| 497 | |
| 498 n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams) | |
| 499 | |
| 500 int done = 0; | |
| 501 for (size_t i = 0; i < n; i++) | |
| 502 { | |
| 503 Expression arg; | |
| 504 | |
| 505 if (i < nargs) | |
| 506 arg = cast(Expression)arguments.data[i]; | |
| 507 else | |
| 508 arg = null; | |
| 509 | |
| 510 Type tb; | |
| 511 | |
| 512 if (i < nparams) | |
| 513 { | |
| 514 Argument p = Argument.getNth(tf.parameters, i); | |
| 515 | |
| 516 if (!arg) | |
| 517 { | |
| 518 if (!p.defaultArg) | |
| 519 { | |
| 520 if (tf.varargs == 2 && i + 1 == nparams) | |
| 521 goto L2; | |
| 522 | |
| 523 error(loc, "expected %d function arguments, not %d", nparams, nargs); | |
| 524 break; | |
| 525 } | |
| 526 arg = p.defaultArg; | |
| 527 version (DMDV2) { | |
| 528 if (arg.op == TOK.TOKdefault) | |
| 529 { | |
| 530 DefaultInitExp de = cast(DefaultInitExp)arg; | |
| 531 arg = de.resolve(loc, sc); | |
| 532 } | |
| 533 else | |
| 534 { | |
| 535 arg = arg.copy(); | |
| 536 } | |
| 537 } else { | |
| 538 arg = arg.copy(); | |
| 539 } | |
| 540 arguments.push(cast(void*)arg); | |
| 541 nargs++; | |
| 542 } | |
| 543 | |
| 544 if (tf.varargs == 2 && i + 1 == nparams) | |
| 545 { | |
| 546 //printf("\t\tvarargs == 2, p.type = '%s'\n", p.type.toChars()); | |
| 547 if (arg.implicitConvTo(p.type)) | |
| 548 { | |
| 549 if (nargs != nparams) | |
| 550 error(loc, "expected %zu function arguments, not %zu", nparams, nargs); | |
| 551 goto L1; | |
| 552 } | |
| 553 L2: | |
| 554 tb = p.type.toBasetype(); /// | |
| 555 Type tret = p.isLazyArray(); | |
| 556 switch (tb.ty) | |
| 557 { | |
| 558 case TY.Tsarray: | |
| 559 case TY.Tarray: | |
| 560 { // Create a static array variable v of type arg.type | |
| 561 version (IN_GCC) { | |
| 562 /* GCC 4.0 does not like zero length arrays used like | |
| 563 this; pass a null array value instead. Could also | |
| 564 just make a one-element array. */ | |
| 565 if (nargs - i == 0) | |
| 566 { | |
| 567 arg = new NullExp(loc); | |
| 568 break; | |
| 569 } | |
| 570 } | |
| 571 Identifier id = Lexer.uniqueId("__arrayArg"); | |
| 572 Type t = new TypeSArray((cast(TypeArray)tb).next, new IntegerExp(nargs - i)); | |
| 573 t = t.semantic(loc, sc); | |
| 574 VarDeclaration v = new VarDeclaration(loc, t, id, new VoidInitializer(loc)); | |
| 575 v.semantic(sc); | |
| 576 v.parent = sc.parent; | |
| 577 //sc.insert(v); | |
| 578 | |
| 579 Expression c = new DeclarationExp(Loc(0), v); | |
| 580 c.type = v.type; | |
| 581 | |
| 582 for (size_t u = i; u < nargs; u++) | |
| 583 { | |
| 584 Expression a = cast(Expression)arguments.data[u]; | |
| 585 if (tret && !(cast(TypeArray)tb).next.equals(a.type)) | |
| 586 a = a.toDelegate(sc, tret); | |
| 587 | |
| 588 Expression e = new VarExp(loc, v); | |
| 589 e = new IndexExp(loc, e, new IntegerExp(u + 1 - nparams)); | |
| 590 AssignExp ae = new AssignExp(loc, e, a); | |
| 591 | |
| 592 version (DMDV2) { | |
| 593 ae.op = TOK.TOKconstruct; | |
| 594 } | |
| 595 | |
| 596 if (c) | |
| 597 c = new CommaExp(loc, c, ae); | |
| 598 else | |
| 599 c = ae; | |
| 600 } | |
| 601 | |
| 602 arg = new VarExp(loc, v); | |
| 603 if (c) | |
| 604 arg = new CommaExp(loc, c, arg); | |
| 605 break; | |
| 606 } | |
| 607 | |
| 608 case TY.Tclass: | |
| 609 { /* Set arg to be: | |
| 610 * new Tclass(arg0, arg1, ..., argn) | |
| 611 */ | |
| 612 Expressions args = new Expressions(); | |
| 613 args.setDim(nargs - i); | |
| 614 for (size_t u = i; u < nargs; u++) | |
| 615 args.data[u - i] = arguments.data[u]; | |
| 616 arg = new NewExp(loc, null, null, p.type, args); | |
| 617 break; | |
| 618 } | |
| 619 | |
| 620 default: | |
| 621 if (!arg) | |
| 622 { | |
| 623 error(loc, "not enough arguments"); | |
| 624 return; | |
| 625 } | |
| 626 break; | |
| 627 } | |
| 628 | |
| 629 arg = arg.semantic(sc); | |
| 630 //printf("\targ = '%s'\n", arg.toChars()); | |
| 631 arguments.setDim(i + 1); | |
| 632 done = 1; | |
| 633 } | |
| 634 | |
| 635 L1: | |
| 636 if (!(p.storageClass & STC.STClazy && p.type.ty == TY.Tvoid)) | |
| 637 { | |
| 638 if (p.type != arg.type) | |
| 639 { | |
| 640 //printf("arg.type = %s, p.type = %s\n", arg.type.toChars(), p.type.toChars()); | |
| 641 arg = arg.implicitCastTo(sc, p.type); | |
| 642 arg = arg.optimize(WANT.WANTvalue); | |
| 643 } | |
| 644 } | |
| 645 if (p.storageClass & STC.STCref) | |
| 646 { | |
| 647 arg = arg.toLvalue(sc, arg); | |
| 648 } | |
| 649 else if (p.storageClass & STC.STCout) | |
| 650 { | |
| 651 arg = arg.modifiableLvalue(sc, arg); | |
| 652 } | |
| 653 | |
| 654 // Convert static arrays to pointers | |
| 655 tb = arg.type.toBasetype(); | |
| 656 if (tb.ty == TY.Tsarray) | |
| 657 { | |
| 658 arg = arg.checkToPointer(); | |
| 659 } | |
| 660 version (DMDV2) { | |
| 661 if (tb.ty == TY.Tstruct && !(p.storageClass & (STC.STCref | STC.STCout))) | |
| 662 { | |
| 663 arg = callCpCtor(loc, sc, arg); | |
| 664 } | |
| 665 } | |
| 666 | |
| 667 // Convert lazy argument to a delegate | |
| 668 if (p.storageClass & STC.STClazy) | |
| 669 { | |
| 670 arg = arg.toDelegate(sc, p.type); | |
| 671 } | |
| 672 version (DMDV2) { | |
| 673 /* Look for arguments that cannot 'escape' from the called | |
| 674 * function. | |
| 675 */ | |
| 676 if (!tf.parameterEscapes(p)) | |
| 677 { | |
| 678 /* Function literals can only appear once, so if this | |
| 679 * appearance was scoped, there cannot be any others. | |
| 680 */ | |
| 681 if (arg.op == TOK.TOKfunction) | |
| 682 { | |
| 683 FuncExp fe = cast(FuncExp)arg; | |
| 684 fe.fd.tookAddressOf = 0; | |
| 685 } | |
| 686 | |
| 687 /* For passing a delegate to a scoped parameter, | |
| 688 * this doesn't count as taking the address of it. | |
| 689 * We only worry about 'escaping' references to the function. | |
| 690 */ | |
| 691 else if (arg.op == TOK.TOKdelegate) | |
| 692 { | |
| 693 DelegateExp de = cast(DelegateExp)arg; | |
| 694 if (de.e1.op == TOK.TOKvar) | |
| 695 { | |
| 696 VarExp ve = cast(VarExp)de.e1; | |
| 697 FuncDeclaration f = ve.var.isFuncDeclaration(); | |
| 698 if (f) | |
| 699 { | |
| 700 f.tookAddressOf--; | |
| 701 //printf("tookAddressOf = %d\n", f.tookAddressOf); | |
| 702 } | |
| 703 } | |
| 704 } | |
| 705 } | |
| 706 } | |
| 707 } | |
| 708 else | |
| 709 { | |
| 710 // If not D linkage, do promotions | |
| 711 if (tf.linkage != LINK.LINKd) | |
| 712 { | |
| 713 // Promote bytes, words, etc., to ints | |
| 714 arg = arg.integralPromotions(sc); | |
| 715 | |
| 716 // Promote floats to doubles | |
| 717 switch (arg.type.ty) | |
| 718 { | |
| 719 case TY.Tfloat32: | |
| 720 arg = arg.castTo(sc, Type.tfloat64); | |
| 721 break; | |
| 722 | |
| 723 case TY.Timaginary32: | |
| 724 arg = arg.castTo(sc, Type.timaginary64); | |
| 725 break; | |
| 726 default: | |
| 727 break; | |
| 728 } | |
| 729 } | |
| 730 | |
| 731 // Convert static arrays to dynamic arrays | |
| 732 tb = arg.type.toBasetype(); | |
| 733 if (tb.ty == TY.Tsarray) | |
| 734 { | |
| 735 TypeSArray ts = cast(TypeSArray)tb; | |
| 736 Type ta = ts.next.arrayOf(); | |
| 737 if (ts.size(arg.loc) == 0) | |
| 738 { | |
| 739 arg = new NullExp(arg.loc); | |
| 740 arg.type = ta; | |
| 741 } | |
| 742 else | |
| 743 { | |
| 744 arg = arg.castTo(sc, ta); | |
| 745 } | |
| 746 } | |
| 747 version (DMDV2) { | |
| 748 if (tb.ty == TY.Tstruct) | |
| 749 { | |
| 750 arg = callCpCtor(loc, sc, arg); | |
| 751 } | |
| 752 | |
| 753 // Give error for overloaded function addresses | |
| 754 if (arg.op == TOK.TOKsymoff) | |
| 755 { | |
| 756 SymOffExp se = cast(SymOffExp)arg; | |
| 757 if (se.hasOverloads && !se.var.isFuncDeclaration().isUnique()) | |
| 758 arg.error("function %s is overloaded", arg.toChars()); | |
| 759 } | |
| 760 } | |
| 761 arg.rvalue(); | |
| 762 } | |
| 763 arg = arg.optimize(WANT.WANTvalue); | |
| 764 arguments.data[i] = cast(void*) arg; | |
| 765 if (done) | |
| 766 break; | |
| 767 } | |
| 768 | |
| 769 // If D linkage and variadic, add _arguments[] as first argument | |
| 770 if (tf.linkage == LINK.LINKd && tf.varargs == 1) | |
| 771 { | |
| 772 Expression e = createTypeInfoArray(sc, cast(Expression*)&arguments.data[nparams], arguments.dim - nparams); | |
| 773 arguments.insert(0, cast(void*)e); | |
| 774 } | |
| 775 } | |
| 776 | |
|
16
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
777 /****************************** |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
778 * Perform canThrow() on an array of Expressions. |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
779 */ |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
780 |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
781 version (DMDV2) { |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
782 bool arrayExpressionCanThrow(Expressions exps) |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
783 { |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
784 if (exps) |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
785 { |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
786 for (size_t i = 0; i < exps.dim; i++) |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
787 { Expression e = cast(Expression)exps.data[i]; |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
788 if (e && e.canThrow()) |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
789 return true; |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
790 } |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
791 } |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
792 return false; |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
793 } |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
794 } |
|
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
795 |
| 0 | 796 /**************************************** |
| 797 * Expand tuples. | |
| 798 */ | |
| 799 | |
| 800 void expandTuples(Expressions exps) | |
| 801 { | |
| 802 //printf("expandTuples()\n"); | |
| 803 if (exps) | |
| 804 { | |
| 805 for (size_t i = 0; i < exps.dim; i++) | |
| 806 { | |
| 807 Expression arg = cast(Expression)exps.data[i]; | |
| 808 if (!arg) | |
| 809 continue; | |
| 810 | |
| 811 // Look for tuple with 0 members | |
| 812 if (arg.op == TOK.TOKtype) | |
| 57 | 813 { |
| 0 | 814 TypeExp e = cast(TypeExp)arg; |
| 815 if (e.type.toBasetype().ty == TY.Ttuple) | |
| 816 { | |
| 817 TypeTuple tt = cast(TypeTuple)e.type.toBasetype(); | |
| 818 | |
| 819 if (!tt.arguments || tt.arguments.dim == 0) | |
| 820 { | |
| 821 exps.remove(i); | |
| 822 if (i == exps.dim) | |
| 823 return; | |
| 824 i--; | |
| 825 continue; | |
| 826 } | |
| 827 } | |
| 828 } | |
| 829 | |
| 830 // Inline expand all the tuples | |
| 831 while (arg.op == TOK.TOKtuple) | |
| 832 { | |
| 833 TupleExp te = cast(TupleExp)arg; | |
| 834 | |
| 835 exps.remove(i); // remove arg | |
| 57 | 836 exps.insert(i, te.exps); // replace with tuple contents |
| 0 | 837 |
| 838 if (i == exps.dim) | |
| 839 return; // empty tuple, no more arguments | |
| 840 | |
| 841 arg = cast(Expression)exps.data[i]; | |
| 842 } | |
| 843 } | |
| 844 } | |
| 845 } | |
| 846 | |
| 847 /************************************************** | |
| 848 * Write out argument types to buf. | |
| 849 */ | |
| 850 | |
| 851 void argExpTypesToCBuffer(OutBuffer buf, Expressions arguments, HdrGenState* hgs) | |
| 852 { | |
| 853 if (arguments) | |
| 854 { | |
| 855 scope OutBuffer argbuf = new OutBuffer(); | |
| 856 | |
| 857 for (size_t i = 0; i < arguments.dim; i++) | |
| 858 { | |
| 859 Expression arg = cast(Expression)arguments.data[i]; | |
| 860 | |
| 861 if (i) | |
| 862 buf.writeByte(','); | |
| 863 | |
| 864 argbuf.reset(); | |
| 865 arg.type.toCBuffer2(argbuf, hgs, MOD.MODundefined); | |
| 866 buf.write(argbuf); | |
| 867 } | |
| 868 } | |
| 869 } | |
| 870 | |
| 871 /**************************************** | |
| 872 * Determine if scope sc has package level access to s. | |
| 873 */ | |
| 874 | |
| 875 bool hasPackageAccess(Scope sc, Dsymbol s) | |
| 876 { | |
| 877 version (LOG) { | |
| 878 printf("hasPackageAccess(s = '%s', sc = '%p')\n", s.toChars(), sc); | |
| 879 } | |
| 880 | |
| 881 for (; s; s = s.parent) | |
| 882 { | |
| 883 if (s.isPackage() && !s.isModule()) | |
| 884 break; | |
| 885 } | |
| 886 version (LOG) { | |
| 887 if (s) | |
| 888 printf("\tthis is in package '%s'\n", s.toChars()); | |
| 889 } | |
| 890 | |
| 891 if (s && s == sc.module_.parent) | |
| 892 { | |
| 893 version (LOG) { | |
| 894 printf("\ts is in same package as sc\n"); | |
| 895 } | |
| 896 return true; | |
| 897 } | |
| 898 | |
| 899 | |
| 900 version (LOG) { | |
| 901 printf("\tno package access\n"); | |
| 902 } | |
| 903 | |
| 904 return false; | |
| 905 } | |
| 906 | |
| 907 /********************************************* | |
| 908 * Call copy constructor for struct value argument. | |
| 909 */ | |
| 910 version (DMDV2) { | |
| 911 Expression callCpCtor(Loc loc, Scope sc, Expression e) | |
| 912 { | |
| 913 Type tb = e.type.toBasetype(); | |
| 914 assert(tb.ty == Tstruct); | |
| 915 StructDeclaration sd = (cast(TypeStruct)tb).sym; | |
| 916 if (sd.cpctor) | |
| 917 { | |
| 918 /* Create a variable tmp, and replace the argument e with: | |
| 919 * (tmp = e),tmp | |
| 920 * and let AssignExp() handle the construction. | |
| 921 * This is not the most efficent, ideally tmp would be constructed | |
| 922 * directly onto the stack. | |
| 923 */ | |
| 924 Identifier idtmp = Lexer.uniqueId("__tmp"); | |
| 925 VarDeclaration tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(Loc(0), e)); | |
| 926 Expression ae = new DeclarationExp(loc, tmp); | |
| 927 e = new CommaExp(loc, ae, new VarExp(loc, tmp)); | |
| 928 e = e.semantic(sc); | |
| 929 } | |
| 930 return e; | |
| 931 } | |
| 932 } | |
| 933 | |
| 934 /*************************************** | |
| 935 * Create a static array of TypeInfo references | |
| 936 * corresponding to an array of Expression's. | |
| 937 * Used to supply hidden _arguments[] value for variadic D functions. | |
| 938 */ | |
| 939 | |
| 940 Expression createTypeInfoArray(Scope sc, Expression* exps, int dim) | |
| 941 { | |
| 57 | 942 static if (true) { |
| 943 /* Get the corresponding TypeInfo_Tuple and | |
| 944 * point at its elements[]. | |
| 945 */ | |
| 946 | |
| 947 /* Create the TypeTuple corresponding to the types of args[] | |
| 948 */ | |
| 949 Arguments args = new Arguments; | |
| 950 args.setDim(dim); | |
| 951 for (size_t i = 0; i < dim; i++) | |
| 952 { | |
| 953 Argument arg = new Argument(STCin, exps[i].type, null, null); | |
| 954 args.data[i] = cast(void*)arg; | |
| 955 } | |
| 956 TypeTuple tup = new TypeTuple(args); | |
| 957 Expression e = tup.getTypeInfo(sc); | |
| 958 e = e.optimize(WANTvalue); | |
| 959 assert(e.op == TOKsymoff); // should be SymOffExp | |
| 960 | |
| 961 version (BREAKABI) { | |
| 962 /* | |
| 963 * Should just pass a reference to TypeInfo_Tuple instead, | |
| 964 * but that would require existing code to be recompiled. | |
| 965 * Source compatibility can be maintained by computing _arguments[] | |
| 966 * at the start of the called function by offseting into the | |
| 967 * TypeInfo_Tuple reference. | |
| 968 */ | |
| 969 | |
| 970 } else { | |
| 971 // Advance to elements[] member of TypeInfo_Tuple | |
| 972 SymOffExp se = cast(SymOffExp)e; | |
| 973 se.offset += PTRSIZE + PTRSIZE; | |
| 974 | |
| 975 // Set type to TypeInfo[]* | |
| 976 se.type = Type.typeinfo.type.arrayOf().pointerTo(); | |
| 977 | |
| 978 // Indirect to get the _arguments[] value | |
| 979 e = new PtrExp(Loc(0), se); | |
| 980 e.type = se.type.next; | |
| 981 } | |
| 982 return e; | |
| 983 } else { | |
| 984 /* Improvements: | |
| 985 * 1) create an array literal instead, | |
| 986 * as it would eliminate the extra dereference of loading the | |
| 987 * static variable. | |
| 988 */ | |
| 989 | |
| 990 ArrayInitializer ai = new ArrayInitializer(Loc(0)); | |
| 991 VarDeclaration v; | |
| 992 Type t; | |
| 993 Expression e; | |
| 994 scope OutBuffer buf = new OutBuffer(); | |
| 995 Identifier id; | |
| 996 string name; | |
| 997 | |
| 998 // Generate identifier for _arguments[] | |
| 999 buf.writestring("_arguments_"); | |
| 1000 for (int i = 0; i < dim; i++) | |
| 1001 { | |
| 1002 t = exps[i].type; | |
| 1003 t.toDecoBuffer(buf); | |
| 1004 } | |
| 1005 buf.writeByte(0); | |
| 1006 id = Lexer.idPool(buf.extractString()); | |
| 1007 | |
| 1008 Module m = sc.module_; | |
| 1009 Dsymbol s = m.symtab.lookup(id); | |
| 1010 | |
| 1011 if (s && s.parent == m) | |
| 1012 { | |
| 1013 // Use existing one | |
| 1014 v = s.isVarDeclaration(); | |
| 1015 assert(v); | |
| 1016 } | |
| 1017 else | |
| 1018 { | |
| 1019 // Generate new one | |
| 1020 | |
| 1021 for (int i = 0; i < dim; i++) | |
| 1022 { | |
| 1023 t = exps[i].type; | |
| 1024 e = t.getTypeInfo(sc); | |
| 1025 ai.addInit(new IntegerExp(i), new ExpInitializer(0, e)); | |
| 1026 } | |
| 1027 | |
| 1028 t = Type.typeinfo.type.arrayOf(); | |
| 1029 ai.type = t; | |
| 1030 v = new VarDeclaration(0, t, id, ai); | |
| 1031 m.members.push(v); | |
| 1032 m.symtab.insert(v); | |
| 1033 sc = sc.push(); | |
| 1034 sc.linkage = LINKc; | |
| 1035 sc.stc = STCstatic | STCcomdat; | |
| 1036 ai.semantic(sc, t); | |
| 1037 v.semantic(sc); | |
| 1038 v.parent = m; | |
| 1039 sc = sc.pop(); | |
| 1040 } | |
| 1041 e = new VarExp(0, v); | |
| 1042 e = e.semantic(sc); | |
| 1043 return e; | |
| 1044 } | |
| 0 | 1045 } |
| 1046 | |
| 1047 /************************************** | |
| 1048 * Evaluate builtin function. | |
| 1049 * Return result: null if cannot evaluate it. | |
| 1050 */ | |
| 1051 | |
| 53 | 1052 extern(C) extern real sinl(real); |
| 1053 extern(C) extern real cosl(real); | |
| 1054 extern(C) extern real tanl(real); | |
| 1055 extern(C) extern real sqrtl(real); | |
| 1056 extern(C) extern real fabsl(real); | |
| 1057 | |
| 0 | 1058 Expression eval_builtin(BUILTIN builtin, Expressions arguments) |
| 1059 { | |
| 53 | 1060 assert(arguments && arguments.dim); |
| 1061 Expression arg0 = cast(Expression)arguments.data[0]; | |
| 1062 Expression e = null; | |
| 1063 switch (builtin) | |
| 1064 { | |
| 1065 case BUILTINsin: | |
| 1066 if (arg0.op == TOKfloat64) | |
| 1067 e = new RealExp(Loc(0), sinl(arg0.toReal()), arg0.type); | |
| 1068 break; | |
| 1069 | |
| 1070 case BUILTINcos: | |
| 1071 if (arg0.op == TOKfloat64) | |
| 1072 e = new RealExp(Loc(0), cosl(arg0.toReal()), arg0.type); | |
| 1073 break; | |
| 1074 | |
| 1075 case BUILTINtan: | |
| 1076 if (arg0.op == TOKfloat64) | |
| 1077 e = new RealExp(Loc(0), tanl(arg0.toReal()), arg0.type); | |
| 1078 break; | |
| 1079 | |
| 1080 case BUILTINsqrt: | |
| 1081 if (arg0.op == TOKfloat64) | |
| 1082 e = new RealExp(Loc(0), sqrtl(arg0.toReal()), arg0.type); | |
| 1083 break; | |
| 1084 | |
| 1085 case BUILTINfabs: | |
| 1086 if (arg0.op == TOKfloat64) | |
| 1087 e = new RealExp(Loc(0), fabsl(arg0.toReal()), arg0.type); | |
| 1088 break; | |
| 1089 } | |
| 1090 return e; | |
| 0 | 1091 } |
| 1092 | |
| 1093 Expression fromConstInitializer(int result, Expression e1) | |
| 1094 { | |
| 1095 //printf("fromConstInitializer(result = %x, %s)\n", result, e1.toChars()); | |
| 1096 //static int xx; if (xx++ == 10) assert(0); | |
| 1097 Expression e = e1; | |
| 1098 if (e1.op == TOK.TOKvar) | |
| 1099 { | |
| 1100 VarExp ve = cast(VarExp)e1; | |
| 1101 VarDeclaration v = ve.var.isVarDeclaration(); | |
| 1102 e = expandVar(result, v); | |
| 1103 if (e) | |
| 1104 { | |
| 1105 if (e.type != e1.type) | |
| 1106 { | |
| 1107 // Type 'paint' operation | |
| 1108 e = e.copy(); | |
| 1109 e.type = e1.type; | |
| 1110 } | |
| 1111 } | |
| 1112 else | |
| 1113 { | |
| 1114 e = e1; | |
| 1115 } | |
| 1116 } | |
| 1117 return e; | |
| 1118 } | |
| 1119 | |
| 1120 /************************************* | |
| 1121 * If variable has a const initializer, | |
| 1122 * return that initializer. | |
| 1123 */ | |
| 1124 | |
| 1125 Expression expandVar(int result, VarDeclaration v) | |
| 1126 { | |
| 1127 //printf("expandVar(result = %d, v = %p, %s)\n", result, v, v ? v.toChars() : "null"); | |
| 1128 | |
| 1129 Expression e = null; | |
| 1130 if (!v) | |
| 1131 return e; | |
| 1132 | |
| 1133 if (v.isConst() || v.isInvariant() || v.storage_class & STC.STCmanifest) | |
| 1134 { | |
| 1135 if (!v.type) | |
| 1136 { | |
| 1137 //error("ICE"); | |
| 1138 return e; | |
| 1139 } | |
| 1140 | |
| 1141 Type tb = v.type.toBasetype(); | |
| 1142 if (result & WANT.WANTinterpret || v.storage_class & STC.STCmanifest || (tb.ty != TY.Tsarray && tb.ty != TY.Tstruct)) | |
| 1143 { | |
| 1144 if (v.init) | |
| 1145 { | |
| 1146 if (v.inuse) | |
| 1147 { | |
| 1148 if (v.storage_class & STC.STCmanifest) | |
| 1149 v.error("recursive initialization of constant"); | |
| 1150 goto L1; | |
| 1151 } | |
| 1152 Expression ei = v.init.toExpression(); | |
| 1153 if (!ei) | |
| 1154 goto L1; | |
| 1155 if (ei.op == TOK.TOKconstruct || ei.op == TOK.TOKblit) | |
| 1156 { | |
| 1157 AssignExp ae = cast(AssignExp)ei; | |
| 1158 ei = ae.e2; | |
| 1159 if (ei.isConst() != 1 && ei.op != TOK.TOKstring) | |
| 1160 goto L1; | |
| 1161 if (ei.type != v.type) | |
| 1162 goto L1; | |
| 1163 } | |
| 1164 if (v.scope_) | |
| 1165 { | |
| 1166 v.inuse++; | |
| 1167 e = ei.syntaxCopy(); | |
| 1168 e = e.semantic(v.scope_); | |
| 1169 e = e.implicitCastTo(v.scope_, v.type); | |
| 1170 // enabling this line causes test22 in test suite to fail | |
| 1171 //ei.type = e.type; | |
| 1172 v.scope_ = null; | |
| 1173 v.inuse--; | |
| 1174 } | |
| 1175 else if (!ei.type) | |
| 1176 { | |
| 1177 goto L1; | |
| 1178 } | |
| 1179 else | |
| 1180 // Should remove the copy() operation by | |
| 1181 // making all mods to expressions copy-on-write | |
| 1182 e = ei.copy(); | |
| 1183 } | |
| 1184 else | |
| 1185 { | |
| 1186 static if (true) { | |
| 1187 goto L1; | |
| 1188 } else { | |
| 1189 // BUG: what if const is initialized in constructor? | |
| 1190 e = v.type.defaultInit(); | |
| 1191 e.loc = e1.loc; | |
| 1192 } | |
| 1193 } | |
| 1194 if (e.type != v.type) | |
| 1195 { | |
| 1196 e = e.castTo(null, v.type); | |
| 1197 } | |
| 1198 v.inuse++; | |
| 1199 e = e.optimize(result); | |
| 1200 v.inuse--; | |
| 1201 } | |
| 1202 } | |
| 1203 L1: | |
| 1204 //if (e) printf("\te = %s, e.type = %s\n", e.toChars(), e.type.toChars()); | |
| 1205 return e; | |
| 1206 } | |
| 1207 | |
| 1208 /**************************************** | |
| 1209 * Check access to d for expression e.d | |
| 1210 */ | |
| 1211 | |
| 1212 void accessCheck(Loc loc, Scope sc, Expression e, Declaration d) | |
| 1213 { | |
| 1214 version (LOG) { | |
| 1215 if (e) | |
| 1216 { | |
| 1217 printf("accessCheck(%s . %s)\n", e.toChars(), d.toChars()); | |
| 1218 printf("\te.type = %s\n", e.type.toChars()); | |
| 1219 } | |
| 1220 else | |
| 1221 { | |
| 1222 //printf("accessCheck(%s)\n", d.toChars()); | |
| 1223 } | |
| 1224 } | |
| 1225 if (!e) | |
| 1226 { | |
| 1227 if (d.prot() == PROT.PROTprivate && d.getModule() != sc.module_ || | |
| 1228 d.prot() == PROT.PROTpackage && !hasPackageAccess(sc, d)) | |
| 1229 | |
| 1230 error(loc, "%s %s.%s is not accessible from %s", | |
| 1231 d.kind(), d.getModule().toChars(), d.toChars(), sc.module_.toChars()); | |
| 1232 } | |
| 1233 else if (e.type.ty == TY.Tclass) | |
| 1234 { | |
| 1235 // Do access check | |
| 1236 ClassDeclaration cd; | |
| 1237 | |
| 1238 cd = cast(ClassDeclaration)((cast(TypeClass)e.type).sym); | |
| 1239 static if (true) { | |
| 1240 if (e.op == TOK.TOKsuper) | |
| 1241 { | |
| 1242 ClassDeclaration cd2 = sc.func.toParent().isClassDeclaration(); | |
| 1243 if (cd2) | |
| 1244 cd = cd2; | |
| 1245 } | |
| 1246 } | |
| 1247 cd.accessCheck(loc, sc, d); | |
| 1248 } | |
| 1249 else if (e.type.ty == TY.Tstruct) | |
| 1250 { | |
| 1251 // Do access check | |
| 1252 StructDeclaration cd = cast(StructDeclaration)((cast(TypeStruct)e.type).sym); | |
| 1253 cd.accessCheck(loc, sc, d); | |
| 1254 } | |
| 1255 } | |
| 1256 | |
| 1257 /***************************************** | |
| 1258 * Given array of arguments and an aggregate type, | |
| 1259 * if any of the argument types are missing, attempt to infer | |
| 1260 * them from the aggregate type. | |
| 1261 */ | |
| 1262 | |
| 1263 void inferApplyArgTypes(TOK op, Arguments arguments, Expression aggr) | |
| 1264 { | |
| 1265 if (!arguments || !arguments.dim) | |
| 1266 return; | |
| 1267 | |
| 1268 /* Return if no arguments need types. | |
| 1269 */ | |
| 1270 for (size_t u = 0; 1; u++) | |
| 1271 { | |
| 1272 if (u == arguments.dim) | |
| 1273 return; | |
| 1274 | |
| 1275 Argument arg = cast(Argument)arguments.data[u]; | |
| 1276 if (!arg.type) | |
| 1277 break; | |
| 1278 } | |
| 1279 | |
| 1280 AggregateDeclaration ad; | |
| 1281 | |
| 1282 Argument arg = cast(Argument)arguments.data[0]; | |
| 1283 Type taggr = aggr.type; | |
| 1284 if (!taggr) | |
| 1285 return; | |
| 1286 Type tab = taggr.toBasetype(); | |
| 1287 switch (tab.ty) | |
| 1288 { | |
| 1289 case TY.Tarray: | |
| 1290 case TY.Tsarray: | |
| 1291 case TY.Ttuple: | |
| 1292 if (arguments.dim == 2) | |
| 1293 { | |
| 1294 if (!arg.type) | |
| 1295 arg.type = Type.tsize_t; // key type | |
| 1296 arg = cast(Argument)arguments.data[1]; | |
| 1297 } | |
| 1298 if (!arg.type && tab.ty != TY.Ttuple) | |
| 1299 arg.type = tab.nextOf(); // value type | |
| 1300 break; | |
| 1301 | |
| 1302 case TY.Taarray: | |
| 1303 { | |
| 1304 TypeAArray taa = cast(TypeAArray)tab; | |
| 1305 | |
| 1306 if (arguments.dim == 2) | |
| 1307 { | |
| 1308 if (!arg.type) | |
| 1309 arg.type = taa.index; // key type | |
| 1310 arg = cast(Argument)arguments.data[1]; | |
| 1311 } | |
| 1312 if (!arg.type) | |
| 1313 arg.type = taa.next; // value type | |
| 1314 break; | |
| 1315 } | |
| 1316 | |
| 1317 case TY.Tclass: | |
| 1318 ad = (cast(TypeClass)tab).sym; | |
| 1319 goto Laggr; | |
| 1320 | |
| 1321 case TY.Tstruct: | |
| 1322 ad = (cast(TypeStruct)tab).sym; | |
| 1323 goto Laggr; | |
| 1324 | |
| 1325 Laggr: | |
| 1326 if (arguments.dim == 1) | |
| 1327 { | |
| 1328 if (!arg.type) | |
| 1329 { | |
| 1330 /* Look for a head() or rear() overload | |
| 1331 */ | |
| 1332 Identifier id = (op == TOK.TOKforeach) ? Id.Fhead : Id.Ftoe; | |
| 1333 Dsymbol s = search_function(ad, id); | |
| 1334 FuncDeclaration fd = s ? s.isFuncDeclaration() : null; | |
| 1335 if (!fd) | |
| 1336 { | |
| 1337 if (s && s.isTemplateDeclaration()) | |
| 1338 break; | |
| 1339 goto Lapply; | |
| 1340 } | |
| 1341 arg.type = fd.type.nextOf(); | |
| 1342 } | |
| 1343 break; | |
| 1344 } | |
| 1345 | |
| 1346 Lapply: | |
| 1347 { /* Look for an | |
| 1348 * int opApply(int delegate(ref Type [, ...]) dg); | |
| 1349 * overload | |
| 1350 */ | |
| 1351 Dsymbol s = search_function(ad, (op == TOK.TOKforeach_reverse) ? Id.applyReverse : Id.apply); | |
| 1352 if (s) | |
| 1353 { | |
| 1354 FuncDeclaration fd = s.isFuncDeclaration(); | |
| 1355 if (fd) | |
| 1356 { | |
| 1357 inferApplyArgTypesX(fd, arguments); | |
| 1358 break; | |
| 1359 } | |
| 1360 static if (false) { | |
| 1361 TemplateDeclaration td = s.isTemplateDeclaration(); | |
| 1362 if (td) | |
| 1363 { | |
| 1364 inferApplyArgTypesZ(td, arguments); | |
| 1365 break; | |
| 1366 } | |
| 1367 } | |
| 1368 } | |
| 1369 break; | |
| 1370 } | |
| 1371 | |
| 1372 case TY.Tdelegate: | |
| 1373 { | |
| 1374 if (0 && aggr.op == TOK.TOKdelegate) | |
| 1375 { | |
| 1376 DelegateExp de = cast(DelegateExp)aggr; | |
| 1377 | |
| 1378 FuncDeclaration fd = de.func.isFuncDeclaration(); | |
| 1379 if (fd) | |
| 1380 inferApplyArgTypesX(fd, arguments); | |
| 1381 } | |
| 1382 else | |
| 1383 { | |
| 1384 inferApplyArgTypesY(cast(TypeFunction)tab.nextOf(), arguments); | |
| 1385 } | |
| 1386 break; | |
| 1387 } | |
| 1388 | |
| 1389 default: | |
| 1390 break; // ignore error, caught later | |
| 1391 } | |
| 1392 } | |
| 1393 | |
| 1394 struct Param3 | |
| 1395 { | |
| 1396 /******************************** | |
| 1397 * Recursive helper function, | |
| 1398 * analogous to func.overloadResolveX(). | |
| 1399 */ | |
| 1400 | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
1401 int fp3(void*, FuncDeclaration f) |
| 0 | 1402 { |
| 1403 TypeFunction tf = cast(TypeFunction)f.type; | |
| 1404 if (inferApplyArgTypesY(tf, arguments) == 1) | |
| 1405 return 0; | |
| 1406 | |
| 1407 if (arguments.dim == 0) | |
| 1408 return 1; | |
| 1409 | |
| 1410 return 0; | |
| 1411 } | |
| 1412 | |
| 1413 Arguments arguments; | |
| 1414 } | |
| 1415 | |
| 1416 void inferApplyArgTypesX(FuncDeclaration fstart, Arguments arguments) | |
| 1417 { | |
| 1418 Param3 p3; | |
| 1419 p3.arguments = arguments; | |
|
17
ddae60498573
Implemented mixin statements, DefaultInitExps, FileInitExps, LineInitExps and __traits.
Robert Clipsham <robert@octarineparrot.com>
parents:
16
diff
changeset
|
1420 overloadApply(fstart, &p3.fp3, cast(void*)arguments); |
| 0 | 1421 } |
| 1422 | |
| 1423 /****************************** | |
| 1424 * Infer arguments from type of function. | |
| 1425 * Returns: | |
| 1426 * 0 match for this function | |
| 1427 * 1 no match for this function | |
| 1428 */ | |
| 1429 | |
| 1430 int inferApplyArgTypesY(TypeFunction tf, Arguments arguments) | |
| 1431 { | |
| 1432 size_t nparams; | |
| 1433 Argument p; | |
| 1434 | |
| 1435 if (Argument.dim(tf.parameters) != 1) | |
| 1436 goto Lnomatch; | |
| 1437 | |
| 1438 p = Argument.getNth(tf.parameters, 0); | |
| 1439 if (p.type.ty != TY.Tdelegate) | |
| 1440 goto Lnomatch; | |
| 1441 | |
| 1442 tf = cast(TypeFunction)p.type.nextOf(); | |
| 1443 assert(tf.ty == TY.Tfunction); | |
| 1444 | |
| 1445 /* We now have tf, the type of the delegate. Match it against | |
| 1446 * the arguments, filling in missing argument types. | |
| 1447 */ | |
| 1448 nparams = Argument.dim(tf.parameters); | |
| 1449 if (nparams == 0 || tf.varargs) | |
| 1450 goto Lnomatch; // not enough parameters | |
| 1451 if (arguments.dim != nparams) | |
| 1452 goto Lnomatch; // not enough parameters | |
| 1453 | |
| 1454 for (size_t u = 0; u < nparams; u++) | |
| 1455 { | |
| 1456 Argument arg = cast(Argument)arguments.data[u]; | |
| 1457 Argument param = Argument.getNth(tf.parameters, u); | |
| 1458 if (arg.type) | |
| 1459 { | |
| 1460 if (!arg.type.equals(param.type)) | |
| 1461 { | |
| 1462 /* Cannot resolve argument types. Indicate an | |
| 1463 * error by setting the number of arguments to 0. | |
| 1464 */ | |
| 1465 arguments.dim = 0; | |
| 1466 goto Lmatch; | |
| 1467 } | |
| 1468 continue; | |
| 1469 } | |
| 1470 arg.type = param.type; | |
| 1471 } | |
| 1472 | |
| 1473 Lmatch: | |
| 1474 return 0; | |
| 1475 | |
| 1476 Lnomatch: | |
| 1477 return 1; | |
| 1478 } | |
| 1479 | |
| 1480 /************************************************** | |
| 1481 * Write expression out to buf, but wrap it | |
| 1482 * in ( ) if its precedence is less than pr. | |
| 1483 */ | |
| 1484 | |
| 1485 void expToCBuffer(OutBuffer buf, HdrGenState* hgs, Expression e, PREC pr) | |
| 1486 { | |
| 1487 //if (precedence[e.op] == 0) e.dump(0); | |
| 1488 if (precedence[e.op] < pr || | |
| 1489 /* Despite precedence, we don't allow a<b<c expressions. | |
| 1490 * They must be parenthesized. | |
| 1491 */ | |
| 1492 (pr == PREC.PREC_rel && precedence[e.op] == pr)) | |
| 1493 { | |
| 1494 buf.writeByte('('); | |
| 1495 e.toCBuffer(buf, hgs); | |
| 1496 buf.writeByte(')'); | |
| 1497 } | |
| 1498 else | |
| 1499 e.toCBuffer(buf, hgs); | |
| 1500 } | |
| 1501 | |
| 1502 /************************************************** | |
| 1503 * Write out argument list to buf. | |
| 1504 */ | |
| 1505 | |
| 1506 void argsToCBuffer(OutBuffer buf, Expressions arguments, HdrGenState* hgs) | |
| 1507 { | |
| 1508 if (arguments) | |
| 1509 { | |
| 1510 for (size_t i = 0; i < arguments.dim; i++) | |
| 1511 { | |
| 1512 Expression arg = cast(Expression)arguments.data[i]; | |
| 1513 | |
| 1514 if (arg) | |
| 1515 { | |
| 1516 if (i) | |
| 1517 buf.writeByte(','); | |
| 1518 expToCBuffer(buf, hgs, arg, PREC.PREC_assign); | |
| 1519 } | |
| 1520 } | |
| 1521 } | |
|
16
5c9b78899f5d
Implemented methods for Tuples, fixed some linking issues.
Robert Clipsham <robert@octarineparrot.com>
parents:
0
diff
changeset
|
1522 } |
| 53 | 1523 |
| 1524 ulong getMask(ulong v) | |
| 1525 { | |
| 1526 ulong u = 0; | |
| 1527 if (v >= 0x80) | |
| 1528 u = 0xFF; | |
| 1529 while (u < v) | |
| 1530 u = (u << 1) | 1; | |
| 1531 return u; | |
| 64 | 1532 } |
| 1533 | |
| 1534 /****************************** | |
| 1535 * Perform scanForNestedRef() on an array of Expressions. | |
| 1536 */ | |
| 1537 | |
| 1538 void arrayExpressionScanForNestedRef(Scope sc, Expressions a) | |
| 1539 { | |
| 1540 //printf("arrayExpressionScanForNestedRef(%p)\n", a); | |
| 1541 if (a) | |
| 1542 { | |
| 1543 for (int i = 0; i < a.dim; i++) | |
| 1544 { | |
| 1545 Expression e = cast(Expression)a.data[i]; | |
| 1546 | |
| 1547 if (e) | |
| 1548 { | |
| 1549 e.scanForNestedRef(sc); | |
| 1550 } | |
| 1551 } | |
| 1552 } | |
| 53 | 1553 } |