root/trunk/rebuild/attrib.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2008 by Digital Mars
// All Rights Reserved
// written by Walter Bright
// http://www.digitalmars.com
// License for redistribution is by either the Artistic License
// in artistic.txt, or the GNU General Public License in gnu.txt.
// See the included readme.txt for details.

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#if _WIN32 || IN_GCC || IN_DMDFE
#include "mem.h"
#elif linux
#include "../root/mem.h"
#endif

#include "import.h"
#include "init.h"
#include "declaration.h"
#include "attrib.h"
#include "cond.h"
#include "scope.h"
#include "id.h"
#include "expression.h"
#include "dsymbol.h"
#include "aggregate.h"
#include "module.h"
#include "parse.h"
#include "config.h"
#include "version.h"

extern void obj_includelib(const char *name);
void obj_startaddress(Symbol *s);


/********************************* AttribDeclaration ****************************/

AttribDeclaration::AttribDeclaration(Array *decl)
    : Dsymbol()
{
    this->decl = decl;
}

Array *AttribDeclaration::include(Scope *sc, ScopeDsymbol *sd)
{
    return decl;
}

int AttribDeclaration::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
{
    int m = 0;
    Array *d = include(sc, sd);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        m |= s->addMember(sc, sd, m | memnum);
    }
    }
    return m;
}

void AttribDeclaration::semantic(Scope *sc)
{
    Array *d = include(sc, NULL);

    //printf("\tAttribDeclaration::semantic '%s', d = %p\n",toChars(), d);
    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)d->data[i];

        s->semantic(sc);
    }
    }
}

void AttribDeclaration::semantic2(Scope *sc)
{
    Array *d = include(sc, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        s->semantic2(sc);
    }
    }
}

void AttribDeclaration::semantic3(Scope *sc)
{
    Array *d = include(sc, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        s->semantic3(sc);
    }
    }
}

void AttribDeclaration::inlineScan()
{
    Array *d = include(NULL, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        //printf("AttribDeclaration::inlineScan %s\n", s->toChars());
        s->inlineScan();
    }
    }
}

void AttribDeclaration::addComment(unsigned char *comment)
{
    if (comment)
    {
    Array *d = include(NULL, NULL);

    if (d)
    {
        for (unsigned i = 0; i < d->dim; i++)
        {   Dsymbol *s = (Dsymbol *)d->data[i];
        //printf("AttribDeclaration::addComment %s\n", s->toChars());
        s->addComment(comment);
        }
    }
    }
}

void AttribDeclaration::emitComment(Scope *sc)
{
    //printf("AttribDeclaration::emitComment(sc = %p)\n", sc);

    /* If generating doc comment, skip this because if we're inside
     * a template, then include(NULL, NULL) will fail.
     */
//    if (sc->docbuf)
//  return;

    Array *d = include(NULL, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        //printf("AttribDeclaration::emitComment %s\n", s->toChars());
        s->emitComment(sc);
    }
    }
}

int AttribDeclaration::hasPointers()
{
    Array *d = include(NULL, NULL);

    if (d)
    {
    for (size_t i = 0; i < d->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)d->data[i];
        if (s->hasPointers())
        return 1;
    }
    }
    return 0;
}

const char *AttribDeclaration::kind()
{
    return "attribute";
}

int AttribDeclaration::oneMember(Dsymbol **ps)
{
    Array *d = include(NULL, NULL);

    return Dsymbol::oneMembers(d, ps);
}

void AttribDeclaration::checkCtorConstInit()
{
    Array *d = include(NULL, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        s->checkCtorConstInit();
    }
    }
}

/****************************************
 */

void AttribDeclaration::addLocalClass(ClassDeclarations *aclasses)
{
    Array *d = include(NULL, NULL);

    if (d)
    {
    for (unsigned i = 0; i < d->dim; i++)
    {   Dsymbol *s = (Dsymbol *)d->data[i];
        s->addLocalClass(aclasses);
    }
    }
}


void AttribDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{
    if (decl)
    {
    buf->writenl();
    buf->writeByte('{');
    buf->writenl();
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        buf->writestring("    ");
        s->toCBuffer(buf, hgs);
    }
    buf->writeByte('}');
    }
    else
    buf->writeByte(';');
    buf->writenl();
}

void AttribDeclaration::parsepragmas(Module *m)
{
    if (decl) {
        for (int i = 0; i < decl->dim; i++) {
            Dsymbol *ds = (Dsymbol *) decl->data[i];
            
            if (ds->isAttribDeclaration()) {
                AttribDeclaration *ad = (AttribDeclaration *) ds;
                ad->parsepragmas(m);
                
            } else if (ds->isImport()) {
                Import *im = (Import *) ds;
                im->load(m, NULL);
                im->mod->parsepragmas();
                
            } else if (dynamic_cast<VersionSymbol*>(ds)) {
                VersionSymbol *vs = (VersionSymbol *) ds;
                vs->addMember(NULL, m, 0);
                
            }
        }
    }
}

/************************* StorageClassDeclaration ****************************/

StorageClassDeclaration::StorageClassDeclaration(unsigned stc, Array *decl)
    : AttribDeclaration(decl)
{
    this->stc = stc;
}

Dsymbol *StorageClassDeclaration::syntaxCopy(Dsymbol *s)
{
    StorageClassDeclaration *scd;

    assert(!s);
    scd = new StorageClassDeclaration(stc, Dsymbol::arraySyntaxCopy(decl));
    return scd;
}

void StorageClassDeclaration::semantic(Scope *sc)
{
    if (decl)
    {   unsigned stc_save = sc->stc;

    /* These sets of storage classes are mutually exclusive,
     * so choose the innermost or most recent one.
     */
    if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest))
        sc->stc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest);
    if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest))
        sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest);
    if (stc & (STCconst | STCinvariant | STCmanifest))
        sc->stc &= ~(STCconst | STCinvariant | STCmanifest);
    sc->stc |= stc;
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic(sc);
    }
    sc->stc = stc_save;
    }
    else
    sc->stc = stc;
}

void StorageClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{
    struct SCstring
    {
    int stc;
    enum TOK tok;
    };

    static SCstring table[] =
    {
    { STCauto,         TOKauto },
    { STCscope,        TOKscope },
    { STCstatic,       TOKstatic },
    { STCextern,       TOKextern },
    { STCconst,        TOKconst },
    { STCinvariant,    TOKinvariant },
    { STCfinal,        TOKfinal },
    { STCabstract,     TOKabstract },
    { STCsynchronized, TOKsynchronized },
    { STCdeprecated,   TOKdeprecated },
    { STCoverride,     TOKoverride },
    { STCnothrow,      TOKnothrow },
    { STCpure,         TOKpure },
    { STCtls,          TOKtls },
    };

    int written = 0;
    for (int i = 0; i < sizeof(table)/sizeof(table[0]); i++)
    {
    if (stc & table[i].stc)
    {
        if (written)
        buf->writeByte(' ');
        written = 1;
        buf->writestring(Token::toChars(table[i].tok));
    }
    }

    AttribDeclaration::toCBuffer(buf, hgs);
}

/********************************* LinkDeclaration ****************************/

LinkDeclaration::LinkDeclaration(enum LINK p, Array *decl)
    : AttribDeclaration(decl)
{
    //printf("LinkDeclaration(linkage = %d, decl = %p)\n", p, decl);
    linkage = p;
}

Dsymbol *LinkDeclaration::syntaxCopy(Dsymbol *s)
{
    LinkDeclaration *ld;

    assert(!s);
    ld = new LinkDeclaration(linkage, Dsymbol::arraySyntaxCopy(decl));
    return ld;
}

void LinkDeclaration::semantic(Scope *sc)
{
    //printf("LinkDeclaration::semantic(linkage = %d, decl = %p)\n", linkage, decl);
    if (decl)
    {   enum LINK linkage_save = sc->linkage;

    sc->linkage = linkage;
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic(sc);
    }
    sc->linkage = linkage_save;
    }
    else
    {
    sc->linkage = linkage;
    }
}

void LinkDeclaration::semantic3(Scope *sc)
{
    //printf("LinkDeclaration::semantic3(linkage = %d, decl = %p)\n", linkage, decl);
    if (decl)
    {   enum LINK linkage_save = sc->linkage;

    sc->linkage = linkage;
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic3(sc);
    }
    sc->linkage = linkage_save;
    }
    else
    {
    sc->linkage = linkage;
    }
}

void LinkDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{   const char *p;

    switch (linkage)
    {
    case LINKd:     p = "D";        break;
    case LINKc:     p = "C";        break;
    case LINKcpp:       p = "C++";      break;
    case LINKwindows:   p = "Windows";      break;
    case LINKpascal:    p = "Pascal";       break;
    default:
        assert(0);
        break;
    }
    buf->writestring("extern (");
    buf->writestring(p);
    buf->writestring(") ");
    AttribDeclaration::toCBuffer(buf, hgs);
}

char *LinkDeclaration::toChars()
{
    return (char *)"extern ()";
}

/********************************* ProtDeclaration ****************************/

ProtDeclaration::ProtDeclaration(enum PROT p, Array *decl)
    : AttribDeclaration(decl)
{
    protection = p;
    //printf("decl = %p\n", decl);
}

Dsymbol *ProtDeclaration::syntaxCopy(Dsymbol *s)
{
    ProtDeclaration *pd;

    assert(!s);
    pd = new ProtDeclaration(protection, Dsymbol::arraySyntaxCopy(decl));
    return pd;
}

void ProtDeclaration::semantic(Scope *sc)
{
    if (decl)
    {   enum PROT protection_save = sc->protection;
    int explicitProtection_save = sc->explicitProtection;

    sc->protection = protection;
    sc->explicitProtection = 1;
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic(sc);
    }
    sc->protection = protection_save;
    sc->explicitProtection = explicitProtection_save;
    }
    else
    {   sc->protection = protection;
    sc->explicitProtection = 1;
    }
}

void ProtDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{   const char *p;

    switch (protection)
    {
    case PROTprivate:   p = "private";      break;
    case PROTpackage:   p = "package";      break;
    case PROTprotected: p = "protected";    break;
    case PROTpublic:    p = "public";       break;
    case PROTexport:    p = "export";       break;
    default:
        assert(0);
        break;
    }
    buf->writestring(p);
    AttribDeclaration::toCBuffer(buf, hgs);
}

/********************************* AlignDeclaration ****************************/

AlignDeclaration::AlignDeclaration(unsigned sa, Array *decl)
    : AttribDeclaration(decl)
{
    salign = sa;
}

Dsymbol *AlignDeclaration::syntaxCopy(Dsymbol *s)
{
    AlignDeclaration *ad;

    assert(!s);
    ad = new AlignDeclaration(salign, Dsymbol::arraySyntaxCopy(decl));
    return ad;
}

void AlignDeclaration::semantic(Scope *sc)
{
    //printf("\tAlignDeclaration::semantic '%s'\n",toChars());
    if (decl)
    {   unsigned salign_save = sc->structalign;

    sc->structalign = salign;
    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic(sc);
    }
    sc->structalign = salign_save;
    }
    else
    sc->structalign = salign;
}


void AlignDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{
    buf->printf("align (%d)", salign);
    AttribDeclaration::toCBuffer(buf, hgs);
}

/********************************* AnonDeclaration ****************************/

AnonDeclaration::AnonDeclaration(Loc loc, int isunion, Array *decl)
    : AttribDeclaration(decl)
{
    this->loc = loc;
    this->isunion = isunion;
    this->scope = NULL;
    this->sem = 0;
}

Dsymbol *AnonDeclaration::syntaxCopy(Dsymbol *s)
{
    AnonDeclaration *ad;

    assert(!s);
    ad = new AnonDeclaration(loc, isunion, Dsymbol::arraySyntaxCopy(decl));
    return ad;
}

void AnonDeclaration::semantic(Scope *sc)
{
    //printf("\tAnonDeclaration::semantic %s %p\n", isunion ? "union" : "struct", this);

    Scope *scx = NULL;
    if (scope)
    {   sc = scope;
    scx = scope;
    scope = NULL;
    }

    assert(sc->parent);

    Dsymbol *parent = sc->parent->pastMixin();
    AggregateDeclaration *ad = parent->isAggregateDeclaration();

    if (!ad || (!ad->isStructDeclaration() && !ad->isClassDeclaration()))
    {
    //error("can only be a part of an aggregate");
    return;
    }

    if (decl)
    {
    AnonymousAggregateDeclaration aad;
    int adisunion;

    if (sc->anonAgg)
    {   ad = sc->anonAgg;
        adisunion = sc->inunion;
    }
    else
        adisunion = ad->isUnionDeclaration() != NULL;

//  printf("\tsc->anonAgg = %p\n", sc->anonAgg);
//  printf("\tad  = %p\n", ad);
//  printf("\taad = %p\n", &aad);

    sc = sc->push();
    sc->anonAgg = &aad;
    sc->stc &= ~(STCauto | STCscope | STCstatic | STCtls);
    sc->inunion = isunion;
    sc->offset = 0;
    sc->flags = 0;
    aad.structalign = sc->structalign;
    aad.parent = ad;

    for (unsigned i = 0; i < decl->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)decl->data[i];

        s->semantic(sc);
        if (isunion)
        sc->offset = 0;
        if (aad.sizeok == 2)
        {
        break;
        }
    }
    sc = sc->pop();

    // If failed due to forward references, unwind and try again later
    if (aad.sizeok == 2)
    {
        ad->sizeok = 2;
        //printf("\tsetting ad->sizeok %p to 2\n", ad);
        if (!sc->anonAgg)
        {
        scope = scx ? scx : new Scope(*sc);
        scope->setNoFree();
        scope->module->addDeferredSemantic(this);
        }
        //printf("\tforward reference %p\n", this);
        return;
    }
    if (sem == 0)
    {   Module::dprogress++;
        sem = 1;
        //printf("\tcompleted %p\n", this);
    }
    else
        ;//printf("\talready completed %p\n", this);

    // 0 sized structs are set to 1 byte
    if (aad.structsize == 0)
    {
        aad.structsize = 1;
        aad.alignsize = 1;
    }

    // Align size of anonymous aggregate
//printf("aad.structalign = %d, aad.alignsize = %d, sc->offset = %d\n", aad.structalign, aad.alignsize, sc->offset);
    ad->alignmember(aad.structalign, aad.alignsize, &sc->offset);
    //ad->structsize = sc->offset;
//printf("sc->offset = %d\n", sc->offset);

    // Add members of aad to ad
    //printf("\tadding members of aad to '%s'\n", ad->toChars());
    for (unsigned i = 0; i < aad.fields.dim; i++)
    {
        VarDeclaration *v = (VarDeclaration *)aad.fields.data[i];