dmd2/init.c

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2007 by Digital Mars
   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 /* NOTE: This file has been patched from the original DMD distribution to
  12    work with the GDC compiler.
  13
  14    Modified by David Friedman, December 2006
  15 */
  16
  17 #include <stdio.h>
  18 #include <assert.h>
  19
  20 #include "mars.h"
  21 #include "init.h"
  22 #include "expression.h"
  23 #include "statement.h"
  24 #include "identifier.h"
  25 #include "declaration.h"
  26 #include "aggregate.h"
  27 #include "scope.h"
  28 #include "mtype.h"
  29 #include "hdrgen.h"
  30
  31 /********************************** Initializer *******************************/
  32
  33 Initializer::Initializer(Loc loc)
  34 {
  35     this->loc = loc;
  36 }
  37
  38 Initializer *Initializer::syntaxCopy()
  39 {
  40     return this;
  41 }
  42
  43 Initializer *Initializer::semantic(Scope *sc, Type *t)
  44 {
  45     return this;
  46 }
  47
  48 Type *Initializer::inferType(Scope *sc)
  49 {
  50     error(loc, "cannot infer type from initializer");
  51     return Type::terror;
  52 }
  53
  54 Initializers *Initializer::arraySyntaxCopy(Initializers *ai)
  55 {   Initializers *a = NULL;
  56
  57     if (ai)
  58     {
  59         a = new Initializers();
  60         a->setDim(ai->dim);
  61         for (int i = 0; i < a->dim; i++)
  62         {   Initializer *e = (Initializer *)ai->data[i];
  63
  64             e = e->syntaxCopy();
  65             a->data[i] = e;
  66         }
  67     }
  68     return a;
  69 }
  70
  71 char *Initializer::toChars()
  72 {   OutBuffer *buf;
  73     HdrGenState hgs;
  74
  75     memset(&hgs, 0, sizeof(hgs));
  76     buf = new OutBuffer();
  77     toCBuffer(buf, &hgs);
  78     return buf->toChars();
  79 }
  80
  81 /********************************** VoidInitializer ***************************/
  82
  83 VoidInitializer::VoidInitializer(Loc loc)
  84     : Initializer(loc)
  85 {
  86     type = NULL;
  87 }
  88
  89
  90 Initializer *VoidInitializer::syntaxCopy()
  91 {
  92     return new VoidInitializer(loc);
  93 }
  94
  95
  96 Initializer *VoidInitializer::semantic(Scope *sc, Type *t)
  97 {
  98     //printf("VoidInitializer::semantic(t = %p)\n", t);
  99     type = t;
 100     return this;
 101 }
 102
 103
 104 Expression *VoidInitializer::toExpression()
 105 {
 106     error(loc, "void initializer has no value");
 107     return new IntegerExp(0);
 108 }
 109
 110
 111 void VoidInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 112 {
 113     buf->writestring("void");
 114 }
 115
 116
 117 /********************************** StructInitializer *************************/
 118
 119 StructInitializer::StructInitializer(Loc loc)
 120     : Initializer(loc)
 121 {
 122     ad = NULL;
 123 }
 124
 125 Initializer *StructInitializer::syntaxCopy()
 126 {
 127     StructInitializer *ai = new StructInitializer(loc);
 128
 129     assert(field.dim == value.dim);
 130     ai->field.setDim(field.dim);
 131     ai->value.setDim(value.dim);
 132     for (int i = 0; i < field.dim; i++)
 133     {
 134         ai->field.data[i] = field.data[i];
 135
 136         Initializer *init = (Initializer *)value.data[i];
 137         init = init->syntaxCopy();
 138         ai->value.data[i] = init;
 139     }
 140     return ai;
 141 }
 142
 143 void StructInitializer::addInit(Identifier *field, Initializer *value)
 144 {
 145     //printf("StructInitializer::addInit(field = %p, value = %p)\n", field, value);
 146     this->field.push(field);
 147     this->value.push(value);
 148 }
 149
 150 Initializer *StructInitializer::semantic(Scope *sc, Type *t)
 151 {
 152     TypeStruct *ts;
 153     int errors = 0;
 154
 155     //printf("StructInitializer::semantic(t = %s) %s\n", t->toChars(), toChars());
 156     vars.setDim(field.dim);
 157     t = t->toBasetype();
 158     if (t->ty == Tstruct)
 159     {   unsigned i;
 160         unsigned fieldi = 0;
 161
 162         ts = (TypeStruct *)t;
 163         ad = ts->sym;
 164         for (i = 0; i < field.dim; i++)
 165         {
 166             Identifier *id = (Identifier *)field.data[i];
 167             Initializer *val = (Initializer *)value.data[i];
 168             Dsymbol *s;
 169             VarDeclaration *v;
 170
 171             if (id == NULL)
 172             {
 173                 if (fieldi >= ad->fields.dim)
 174                 {   error(loc, "too many initializers for %s", ad->toChars());
 175                     field.remove(i);
 176                     i--;
 177                     continue;
 178                 }
 179                 else
 180                 {
 181                     s = (Dsymbol *)ad->fields.data[fieldi];
 182                 }
 183             }
 184             else
 185             {
 186                 //s = ad->symtab->lookup(id);
 187                 s = ad->search(loc, id, 0);
 188                 if (!s)
 189                 {
 190                     error(loc, "'%s' is not a member of '%s'", id->toChars(), t->toChars());
 191                     continue;
 192                 }
 193
 194                 // Find out which field index it is
 195                 for (fieldi = 0; 1; fieldi++)
 196                 {
 197                     if (fieldi >= ad->fields.dim)
 198                     {
 199                         s->error("is not a per-instance initializable field");
 200                         break;
 201                     }
 202                     if (s == (Dsymbol *)ad->fields.data[fieldi])
 203                         break;
 204                 }
 205             }
 206             if (s && (v = s->isVarDeclaration()) != NULL)
 207             {
 208                 val = val->semantic(sc, v->type);
 209                 value.data[i] = (void *)val;
 210                 vars.data[i] = (void *)v;
 211             }
 212             else
 213             {   error(loc, "%s is not a field of %s", id ? id->toChars() : s->toChars(), ad->toChars());
 214                 errors = 1;
 215             }
 216             fieldi++;
 217         }
 218     }
 219     else if (t->ty == Tdelegate && value.dim == 0)
 220     {   /* Rewrite as empty delegate literal { }
 221          */
 222         Arguments *arguments = new Arguments;
 223         Type *tf = new TypeFunction(arguments, NULL, 0, LINKd);
 224         FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(loc, 0, tf, TOKdelegate, NULL);
 225         fd->fbody = new CompoundStatement(loc, new Statements());
 226         fd->endloc = loc;
 227         Expression *e = new FuncExp(loc, fd);
 228         ExpInitializer *ie = new ExpInitializer(loc, e);
 229         return ie->semantic(sc, t);
 230     }
 231     else
 232     {
 233         error(loc, "a struct is not a valid initializer for a %s", t->toChars());
 234         errors = 1;
 235     }
 236     if (errors)
 237     {
 238         field.setDim(0);
 239         value.setDim(0);
 240         vars.setDim(0);
 241     }
 242     return this;
 243 }
 244
 245
 246 /***************************************
 247  * This works by transforming a struct initializer into
 248  * a struct literal. In the future, the two should be the
 249  * same thing.
 250  */
 251 Expression *StructInitializer::toExpression()
 252 {   Expression *e;
 253
 254     //printf("StructInitializer::toExpression() %s\n", toChars());
 255     if (!ad)                            // if fwd referenced
 256     {
 257         return NULL;
 258     }
 259     StructDeclaration *sd = ad->isStructDeclaration();
 260     if (!sd)
 261         return NULL;
 262     Expressions *elements = new Expressions();
 263     for (size_t i = 0; i < value.dim; i++)
 264     {
 265         if (field.data[i])
 266             goto Lno;
 267         Initializer *iz = (Initializer *)value.data[i];
 268         if (!iz)
 269             goto Lno;
 270         Expression *ex = iz->toExpression();
 271         if (!ex)
 272             goto Lno;
 273         elements->push(ex);
 274     }
 275     e = new StructLiteralExp(loc, sd, elements);
 276     e->type = sd->type;
 277     return e;
 278
 279 Lno:
 280     delete elements;
 281     //error(loc, "struct initializers as expressions are not allowed");
 282     return NULL;
 283 }
 284
 285
 286 void StructInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 287 {
 288     //printf("StructInitializer::toCBuffer()\n");
 289     buf->writebyte('{');
 290     for (int i = 0; i < field.dim; i++)
 291     {
 292         if (i > 0)
 293             buf->writebyte(',');
 294         Identifier *id = (Identifier *)field.data[i];
 295         if (id)
 296         {
 297             buf->writestring(id->toChars());
 298             buf->writebyte(':');
 299         }
 300         Initializer *iz = (Initializer *)value.data[i];
 301         if (iz)
 302             iz->toCBuffer(buf, hgs);
 303     }
 304     buf->writebyte('}');
 305 }
 306
 307 /********************************** ArrayInitializer ************************************/
 308
 309 ArrayInitializer::ArrayInitializer(Loc loc)
 310     : Initializer(loc)
 311 {
 312     dim = 0;
 313     type = NULL;
 314     sem = 0;
 315 }
 316
 317 Initializer *ArrayInitializer::syntaxCopy()
 318 {
 319     //printf("ArrayInitializer::syntaxCopy()\n");
 320
 321     ArrayInitializer *ai = new ArrayInitializer(loc);
 322
 323     assert(index.dim == value.dim);
 324     ai->index.setDim(index.dim);
 325     ai->value.setDim(value.dim);
 326     for (int i = 0; i < ai->value.dim; i++)
 327     {   Expression *e = (Expression *)index.data[i];
 328         if (e)
 329             e = e->syntaxCopy();
 330         ai->index.data[i] = e;
 331
 332         Initializer *init = (Initializer *)value.data[i];
 333         init = init->syntaxCopy();
 334         ai->value.data[i] = init;
 335     }
 336     return ai;
 337 }
 338
 339 void ArrayInitializer::addInit(Expression *index, Initializer *value)
 340 {
 341     this->index.push(index);
 342     this->value.push(value);
 343     dim = 0;
 344     type = NULL;
 345 }
 346
 347 Initializer *ArrayInitializer::semantic(Scope *sc, Type *t)
 348 {   unsigned i;
 349     unsigned length;
 350
 351     //printf("ArrayInitializer::semantic(%s)\n", t->toChars());
 352     if (sem)                            // if semantic() already run
 353         return this;
 354     sem = 1;
 355     type = t;
 356     t = t->toBasetype();
 357     switch (t->ty)
 358     {
 359         case Tpointer:
 360         case Tsarray:
 361         case Tarray:
 362             break;
 363
 364         default:
 365             error(loc, "cannot use array to initialize %s", type->toChars());
 366             return this;
 367     }
 368
 369     length = 0;
 370     for (i = 0; i < index.dim; i++)
 371     {   Expression *idx;
 372         Initializer *val;
 373
 374         idx = (Expression *)index.data[i];
 375         if (idx)
 376         {   idx = idx->semantic(sc);
 377             idx = idx->optimize(WANTvalue | WANTinterpret);
 378             index.data[i] = (void *)idx;
 379             length = idx->toInteger();
 380         }
 381
 382         val = (Initializer *)value.data[i];
 383         val = val->semantic(sc, t->nextOf());
 384         value.data[i] = (void *)val;
 385         length++;
 386         if (length == 0)
 387             error("array dimension overflow");
 388         if (length > dim)
 389             dim = length;
 390     }
 391     uintmax_t amax = 0x80000000;
 392     if ((uintmax_t) dim * t->nextOf()->size() >= amax)
 393         error(loc, "array dimension %"PRIuTSIZE" exceeds max of %"PRIuMAX, dim, amax / t->nextOf()->size());
 394     return this;
 395 }
 396
 397 /********************************
 398  * If possible, convert array initializer to array literal.
 399  */
 400
 401 Expression *ArrayInitializer::toExpression()
 402 {   Expressions *elements;
 403     Expression *e;
 404
 405     //printf("ArrayInitializer::toExpression()\n");
 406     //static int i; if (++i == 2) halt();
 407     elements = new Expressions();
 408     for (size_t i = 0; i < value.dim; i++)
 409     {
 410         if (index.data[i])
 411             goto Lno;
 412         Initializer *iz = (Initializer *)value.data[i];
 413         if (!iz)
 414             goto Lno;
 415         Expression *ex = iz->toExpression();
 416         if (!ex)
 417             goto Lno;
 418         elements->push(ex);
 419     }
 420     e = new ArrayLiteralExp(loc, elements);
 421     e->type = type;
 422     return e;
 423
 424 Lno:
 425     delete elements;
 426     error(loc, "array initializers as expressions are not allowed");
 427     return NULL;
 428 }
 429
 430
 431 /********************************
 432  * If possible, convert array initializer to associative array initializer.
 433  */
 434
 435 Initializer *ArrayInitializer::toAssocArrayInitializer()
 436 {   Expressions *keys;
 437     Expressions *values;
 438     Expression *e;
 439
 440     //printf("ArrayInitializer::toAssocArrayInitializer()\n");
 441     //static int i; if (++i == 2) halt();
 442     keys = new Expressions();
 443     keys->setDim(value.dim);
 444     values = new Expressions();
 445     values->setDim(value.dim);
 446
 447     for (size_t i = 0; i < value.dim; i++)
 448     {
 449         e = (Expression *)index.data[i];
 450         if (!e)
 451             goto Lno;
 452         keys->data[i] = (void *)e;
 453
 454         Initializer *iz = (Initializer *)value.data[i];
 455         if (!iz)
 456             goto Lno;
 457         e = iz->toExpression();
 458         if (!e)
 459             goto Lno;
 460         values->data[i] = (void *)e;
 461     }
 462     e = new AssocArrayLiteralExp(loc, keys, values);
 463     return new ExpInitializer(loc, e);
 464
 465 Lno:
 466     delete keys;
 467     delete values;
 468     error(loc, "not an associative array initializer");
 469     return this;
 470 }
 471
 472
 473 Type *ArrayInitializer::inferType(Scope *sc)
 474 {
 475     for (size_t i = 0; i < value.dim; i++)
 476     {
 477         if (index.data[i])
 478             goto Lno;
 479     }
 480     if (value.dim)
 481     {
 482         Initializer *iz = (Initializer *)value.data[0];
 483         if (iz)
 484         {   Type *t = iz->inferType(sc);
 485             t = new TypeSArray(t, new IntegerExp(value.dim));
 486             t = t->semantic(loc, sc);
 487             return t;
 488         }
 489     }
 490
 491 Lno:
 492     error(loc, "cannot infer type from this array initializer");
 493     return Type::terror;
 494 }
 495
 496
 497 void ArrayInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 498 {
 499     buf->writebyte('[');
 500     for (int i = 0; i < index.dim; i++)
 501     {
 502         if (i > 0)
 503             buf->writebyte(',');
 504         Expression *ex = (Expression *)index.data[i];
 505         if (ex)
 506         {
 507             ex->toCBuffer(buf, hgs);
 508             buf->writebyte(':');
 509         }
 510         Initializer *iz = (Initializer *)value.data[i];
 511         if (iz)
 512             iz->toCBuffer(buf, hgs);
 513     }
 514     buf->writebyte(']');
 515 }
 516
 517
 518 /********************************** ExpInitializer ************************************/
 519
 520 ExpInitializer::ExpInitializer(Loc loc, Expression *exp)
 521     : Initializer(loc)
 522 {
 523     this->exp = exp;
 524 }
 525
 526 Initializer *ExpInitializer::syntaxCopy()
 527 {
 528     return new ExpInitializer(loc, exp->syntaxCopy());
 529 }
 530
 531 Initializer *ExpInitializer::semantic(Scope *sc, Type *t)
 532 {
 533     //printf("ExpInitializer::semantic(%s), type = %s\n", exp->toChars(), t->toChars());
 534     exp = exp->semantic(sc);
 535     exp = exp->optimize(WANTvalue | WANTinterpret);
 536     Type *tb = t->toBasetype();
 537
 538     /* Look for case of initializing a static array with a too-short
 539      * string literal, such as:
 540      *  char[5] foo = "abc";
 541      * Allow this by doing an explicit cast, which will lengthen the string
 542      * literal.
 543      */
 544     if (exp->op == TOKstring && tb->ty == Tsarray && exp->type->ty == Tsarray)
 545     {   StringExp *se = (StringExp *)exp;
 546
 547         if (!se->committed && se->type->ty == Tsarray &&
 548             ((TypeSArray *)se->type)->dim->toInteger() <
 549             ((TypeSArray *)t)->dim->toInteger())
 550         {
 551             exp = se->castTo(sc, t);
 552             goto L1;
 553         }
 554     }
 555
 556     // Look for the case of statically initializing an array
 557     // with a single member.
 558     if (tb->ty == Tsarray &&
 559         !tb->nextOf()->equals(exp->type->toBasetype()->nextOf()) &&
 560         exp->implicitConvTo(tb->nextOf())
 561        )
 562     {
 563         t = tb->nextOf();
 564     }
 565
 566     exp = exp->implicitCastTo(sc, t);
 567 L1:
 568     exp = exp->optimize(WANTvalue | WANTinterpret);
 569     //printf("-ExpInitializer::semantic(): "); exp->print();
 570     return this;
 571 }
 572
 573 Type *ExpInitializer::inferType(Scope *sc)
 574 {
 575     //printf("ExpInitializer::inferType() %s\n", toChars());
 576     exp = exp->semantic(sc);
 577     exp = resolveProperties(sc, exp);
 578
 579     // Give error for overloaded function addresses
 580     if (exp->op == TOKsymoff)
 581     {   SymOffExp *se = (SymOffExp *)exp;
 582         if (se->hasOverloads && !se->var->isFuncDeclaration()->isUnique())
 583             exp->error("cannot infer type from overloaded function symbol %s", exp->toChars());
 584     }
 585
 586     Type *t = exp->type;
 587     return t;
 588     //return t->ty == Tsarray ? t : t->toHeadMutable();
 589 }
 590
 591 Expression *ExpInitializer::toExpression()
 592 {
 593     return exp;
 594 }
 595
 596
 597 void ExpInitializer::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 598 {
 599     exp->toCBuffer(buf, hgs);
 600 }
 601
 602
 603