dmd2/struct.c

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2008 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 "root.h"
  21 #include "aggregate.h"
  22 #include "scope.h"
  23 #include "mtype.h"
  24 #include "declaration.h"
  25 #include "module.h"
  26 #include "id.h"
  27 #include "statement.h"
  28
  29 /********************************* AggregateDeclaration ****************************/
  30
  31 AggregateDeclaration::AggregateDeclaration(Loc loc, Identifier *id)
  32     : ScopeDsymbol(id)
  33 {
  34     this->loc = loc;
  35
  36     storage_class = 0;
  37     protection = PROTpublic;
  38     type = NULL;
  39     handle = NULL;
  40     structsize = 0;             // size of struct
  41     alignsize = 0;              // size of struct for alignment purposes
  42     structalign = 0;            // struct member alignment in effect
  43     hasUnions = 0;
  44     sizeok = 0;                 // size not determined yet
  45     isdeprecated = 0;
  46     inv = NULL;
  47     aggNew = NULL;
  48     aggDelete = NULL;
  49
  50     attributes = NULL;
  51
  52     stag = NULL;
  53     sinit = NULL;
  54     scope = NULL;
  55     dtor = NULL;
  56 }
  57
  58 enum PROT AggregateDeclaration::prot()
  59 {
  60     return protection;
  61 }
  62
  63 void AggregateDeclaration::semantic2(Scope *sc)
  64 {
  65     //printf("AggregateDeclaration::semantic2(%s)\n", toChars());
  66     if (scope)
  67     {   error("has forward references");
  68         return;
  69     }
  70     if (members)
  71     {
  72         sc = sc->push(this);
  73         for (size_t i = 0; i < members->dim; i++)
  74         {
  75             Dsymbol *s = (Dsymbol *)members->data[i];
  76             s->semantic2(sc);
  77         }
  78         sc->pop();
  79     }
  80 }
  81
  82 void AggregateDeclaration::semantic3(Scope *sc)
  83 {   int i;
  84
  85     //printf("AggregateDeclaration::semantic3(%s)\n", toChars());
  86     if (members)
  87     {
  88         sc = sc->push(this);
  89         for (i = 0; i < members->dim; i++)
  90         {
  91             Dsymbol *s = (Dsymbol *)members->data[i];
  92             s->semantic3(sc);
  93         }
  94         sc->pop();
  95     }
  96 }
  97
  98 void AggregateDeclaration::inlineScan()
  99 {   int i;
 100
 101     //printf("AggregateDeclaration::inlineScan(%s)\n", toChars());
 102     if (members)
 103     {
 104         for (i = 0; i < members->dim; i++)
 105         {
 106             Dsymbol *s = (Dsymbol *)members->data[i];
 107             //printf("inline scan aggregate symbol '%s'\n", s->toChars());
 108             s->inlineScan();
 109         }
 110     }
 111 }
 112
 113 target_size_t AggregateDeclaration::size(Loc loc)
 114 {
 115     //printf("AggregateDeclaration::size() = %d\n", structsize);
 116     if (!members)
 117         error(loc, "unknown size");
 118     if (sizeok != 1)
 119     {   error(loc, "no size yet for forward reference");
 120         //*(char*)0=0;
 121     }
 122     return structsize;
 123 }
 124
 125 Type *AggregateDeclaration::getType()
 126 {
 127     return type;
 128 }
 129
 130 int AggregateDeclaration::isDeprecated()
 131 {
 132     return isdeprecated;
 133 }
 134
 135 /****************************
 136  * Do byte or word alignment as necessary.
 137  * Align sizes of 0, as we may not know array sizes yet.
 138  */
 139
 140 void AggregateDeclaration::alignmember(target_size_t salign, target_size_t size, target_size_t *poffset)
 141 {
 142     //printf("salign = %d, size = %d, offset = %d\n",salign,size,offset);
 143     if (salign > 1)
 144     {   int sa;
 145
 146         switch (size)
 147         {   case 1:
 148                 break;
 149             case 2:
 150             case_2:
 151                 *poffset = (*poffset + 1) & ~1; // align to word
 152                 break;
 153             case 3:
 154             case 4:
 155                 if (salign == 2)
 156                     goto case_2;
 157                 *poffset = (*poffset + 3) & ~3; // align to dword
 158                 break;
 159             default:
 160                 *poffset = (*poffset + salign - 1) & ~(salign - 1);
 161                 break;
 162         }
 163     }
 164     //printf("result = %d\n",offset);
 165 }
 166
 167
 168 void AggregateDeclaration::addField(Scope *sc, VarDeclaration *v)
 169 {
 170     target_size_t memsize;      // size of member
 171     target_size_t memalignsize; // size of member for alignment purposes
 172     target_size_t xalign;       // alignment boundaries
 173
 174     //printf("AggregateDeclaration::addField('%s') %s\n", v->toChars(), toChars());
 175     assert(!(v->storage_class & (STCstatic | STCextern | STCparameter | STCtls)));
 176
 177     // Check for forward referenced types which will fail the size() call
 178     Type *t = v->type->toBasetype();
 179     if (t->ty == Tstruct /*&& isStructDeclaration()*/)
 180     {   TypeStruct *ts = (TypeStruct *)t;
 181
 182         if (ts->sym == this)
 183         {
 184             error("cannot have field %s with same struct type", v->toChars());
 185         }
 186
 187         if (ts->sym->sizeok != 1)
 188         {
 189             sizeok = 2;         // cannot finish; flag as forward referenced
 190             return;
 191         }
 192     }
 193     if (t->ty == Tident)
 194     {
 195         sizeok = 2;             // cannot finish; flag as forward referenced
 196         return;
 197     }
 198
 199     memsize = v->type->size(loc);
 200     memalignsize = v->type->alignsize();
 201     xalign = v->type->memalign(sc->structalign);
 202     alignmember(xalign, memalignsize, &sc->offset);
 203     v->offset = sc->offset;
 204     sc->offset += memsize;
 205     if (sc->offset > structsize)
 206         structsize = sc->offset;
 207     if (sc->structalign < memalignsize)
 208         memalignsize = sc->structalign;
 209     if (alignsize < memalignsize)
 210         alignsize = memalignsize;
 211     //printf("\talignsize = %d\n", alignsize);
 212
 213     v->storage_class |= STCfield;
 214     //printf(" addField '%s' to '%s' at offset %d, size = %d\n", v->toChars(), toChars(), v->offset, memsize);
 215     fields.push(v);
 216 }
 217
 218
 219 /********************************* StructDeclaration ****************************/
 220
 221 StructDeclaration::StructDeclaration(Loc loc, Identifier *id)
 222     : AggregateDeclaration(loc, id)
 223 {
 224     zeroInit = 0;       // assume false until we do semantic processing
 225     hasIdentityAssign = 0;
 226     cpctor = NULL;
 227     postblit = NULL;
 228
 229     // For forward references
 230     type = new TypeStruct(this);
 231 }
 232
 233 Dsymbol *StructDeclaration::syntaxCopy(Dsymbol *s)
 234 {
 235     StructDeclaration *sd;
 236
 237     if (s)
 238         sd = (StructDeclaration *)s;
 239     else
 240         sd = new StructDeclaration(loc, ident);
 241     ScopeDsymbol::syntaxCopy(sd);
 242     return sd;
 243 }
 244
 245 void StructDeclaration::semantic(Scope *sc)
 246 {   int i;
 247     Scope *sc2;
 248
 249     //printf("+StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
 250
 251     //static int count; if (++count == 20) *(char*)0=0;
 252
 253     assert(type);
 254     if (!members)                       // if forward reference
 255         return;
 256
 257     if (symtab)
 258     {   if (!scope)
 259             return;             // semantic() already completed
 260     }
 261     else
 262         symtab = new DsymbolTable();
 263
 264     Scope *scx = NULL;
 265     if (scope)
 266     {   sc = scope;
 267         scx = scope;            // save so we don't make redundant copies
 268         scope = NULL;
 269     }
 270 #ifdef IN_GCC
 271     methods.setDim(0);
 272 #endif
 273
 274     parent = sc->parent;
 275     handle = type->pointerTo();
 276     structalign = sc->structalign;
 277     protection = sc->protection;
 278     storage_class |= sc->stc;
 279     assert(!isAnonymous());
 280     if (sc->stc & STCabstract)
 281         error("structs, unions cannot be abstract");
 282     if (storage_class & STCinvariant)
 283         type = type->invariantOf();
 284     else if (storage_class & STCconst)
 285         type = type->constOf();
 286     if (attributes)
 287         attributes->append(sc->attributes);
 288     else
 289         attributes = sc->attributes;
 290
 291     if (sizeok == 0)            // if not already done the addMember step
 292     {
 293         for (i = 0; i < members->dim; i++)
 294         {
 295             Dsymbol *s = (Dsymbol *)members->data[i];
 296             //printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
 297             s->addMember(sc, this, 1);
 298         }
 299     }
 300
 301     sizeok = 0;
 302     sc2 = sc->push(this);
 303     sc2->stc &= storage_class & (STCconst | STCinvariant);
 304     sc2->attributes = NULL;
 305     sc2->parent = this;
 306     if (isUnionDeclaration())
 307         sc2->inunion = 1;
 308     sc2->protection = PROTpublic;
 309     sc2->explicitProtection = 0;
 310
 311     int members_dim = members->dim;
 312     for (i = 0; i < members_dim; i++)
 313     {
 314         Dsymbol *s = (Dsymbol *)members->data[i];
 315         s->semantic(sc2);
 316         if (isUnionDeclaration())
 317             sc2->offset = 0;
 318 #if 0
 319         if (sizeok == 2)
 320         {   //printf("forward reference\n");
 321             break;
 322         }
 323 #endif
 324     }
 325
 326     /* The TypeInfo_Struct is expecting an opEquals and opCmp with
 327      * a parameter that is a pointer to the struct. But if there
 328      * isn't one, but is an opEquals or opCmp with a value, write
 329      * another that is a shell around the value:
 330      *  int opCmp(struct *p) { return opCmp(*p); }
 331      */
 332
 333     TypeFunction *tfeqptr;
 334     {
 335         Arguments *arguments = new Arguments;
 336         Argument *arg = new Argument(STCin, handle, Id::p, NULL);
 337
 338         arguments->push(arg);
 339         tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
 340         tfeqptr = (TypeFunction *)tfeqptr->semantic(0, sc);
 341     }
 342
 343     TypeFunction *tfeq;
 344     {
 345         Arguments *arguments = new Arguments;
 346         Argument *arg = new Argument(STCin, type, NULL, NULL);
 347
 348         arguments->push(arg);
 349         tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
 350         tfeq = (TypeFunction *)tfeq->semantic(0, sc);
 351     }
 352
 353     Identifier *id = Id::eq;
 354     for (int i = 0; i < 2; i++)
 355     {
 356         Dsymbol *s = search_function(this, id);
 357         FuncDeclaration *fdx = s ? s->isFuncDeclaration() : NULL;
 358         if (fdx)
 359         {   FuncDeclaration *fd = fdx->overloadExactMatch(tfeqptr);
 360             if (!fd)
 361             {   fd = fdx->overloadExactMatch(tfeq);
 362                 if (fd)
 363                 {   // Create the thunk, fdptr
 364                     FuncDeclaration *fdptr = new FuncDeclaration(loc, loc, fdx->ident, STCundefined, tfeqptr);
 365                     Expression *e = new IdentifierExp(loc, Id::p);
 366                     e = new PtrExp(loc, e);
 367                     Expressions *args = new Expressions();
 368                     args->push(e);
 369                     e = new IdentifierExp(loc, id);
 370                     e = new CallExp(loc, e, args);
 371                     fdptr->fbody = new ReturnStatement(loc, e);
 372                     ScopeDsymbol *s = fdx->parent->isScopeDsymbol();
 373                     assert(s);
 374                     s->members->push(fdptr);
 375                     fdptr->addMember(sc, s, 1);
 376                     fdptr->semantic(sc2);
 377                 }
 378             }
 379         }
 380
 381         id = Id::cmp;
 382     }
 383
 384     dtor = buildDtor(sc2);
 385     postblit = buildPostBlit(sc2);
 386     cpctor = buildCpCtor(sc2);
 387     buildOpAssign(sc2);
 388
 389     sc2->pop();
 390
 391     if (sizeok == 2)
 392     {   // semantic() failed because of forward references.
 393         // Unwind what we did, and defer it for later
 394         fields.setDim(0);
 395         structsize = 0;
 396         alignsize = 0;
 397         structalign = 0;
 398
 399         scope = scx ? scx : new Scope(*sc);
 400         scope->setNoFree();
 401         scope->module->addDeferredSemantic(this);
 402         //printf("\tdeferring %s\n", toChars());
 403         return;
 404     }
 405
 406     // 0 sized struct's are set to 1 byte
 407     if (structsize == 0)
 408     {
 409         structsize = 1;
 410         alignsize = 1;
 411     }
 412
 413     // Round struct size up to next alignsize boundary.
 414     // This will ensure that arrays of structs will get their internals
 415     // aligned properly.
 416     structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
 417
 418     sizeok = 1;
 419     Module::dprogress++;
 420
 421     //printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
 422
 423     // Determine if struct is all zeros or not
 424     zeroInit = 1;
 425     for (i = 0; i < fields.dim; i++)
 426     {
 427         Dsymbol *s = (Dsymbol *)fields.data[i];
 428         VarDeclaration *vd = s->isVarDeclaration();
 429         if (vd && !vd->isDataseg())
 430         {
 431             if (vd->init)
 432             {
 433                 // Should examine init to see if it is really all 0's
 434                 zeroInit = 0;
 435                 break;
 436             }
 437             else
 438             {
 439                 if (!vd->type->isZeroInit())
 440                 {
 441                     zeroInit = 0;
 442                     break;
 443                 }
 444             }
 445         }
 446     }
 447
 448     /* Look for special member functions.
 449      */
 450     inv =    (InvariantDeclaration *)search(0, Id::classInvariant, 0);
 451     aggNew =       (NewDeclaration *)search(0, Id::classNew,       0);
 452     aggDelete = (DeleteDeclaration *)search(0, Id::classDelete,    0);
 453
 454     if (sc->func)
 455     {
 456         semantic2(sc);
 457         semantic3(sc);
 458     }
 459 }
 460
 461 void StructDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 462 {   int i;
 463
 464     buf->printf("%s ", kind());
 465     if (!isAnonymous())
 466         buf->writestring(toChars());
 467     if (!members)
 468     {
 469         buf->writeByte(';');
 470         buf->writenl();
 471         return;
 472     }
 473     buf->writenl();
 474     buf->writeByte('{');
 475     buf->writenl();
 476     for (i = 0; i < members->dim; i++)
 477     {
 478         Dsymbol *s = (Dsymbol *)members->data[i];
 479
 480         buf->writestring("    ");
 481         s->toCBuffer(buf, hgs);
 482     }
 483     buf->writeByte('}');
 484     buf->writenl();
 485 }
 486
 487
 488 char *StructDeclaration::kind()
 489 {
 490     return "struct";
 491 }
 492
 493 /********************************* UnionDeclaration ****************************/
 494
 495 UnionDeclaration::UnionDeclaration(Loc loc, Identifier *id)
 496     : StructDeclaration(loc, id)
 497 {
 498 }
 499
 500 Dsymbol *UnionDeclaration::syntaxCopy(Dsymbol *s)
 501 {
 502     UnionDeclaration *ud;
 503
 504     if (s)
 505         ud = (UnionDeclaration *)s;
 506     else
 507         ud = new UnionDeclaration(loc, ident);
 508     StructDeclaration::syntaxCopy(ud);
 509     return ud;
 510 }
 511
 512
 513 char *UnionDeclaration::kind()
 514 {
 515     return "union";
 516 }
 517
 518