root/branches/dmdfe-2.0/class.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>

#include "root.h"
#include "mem.h"

#include "enum.h"
#include "init.h"
#include "attrib.h"
#include "declaration.h"
#include "aggregate.h"
#include "id.h"
#include "mtype.h"
#include "scope.h"
#include "module.h"
#include "expression.h"
#include "statement.h"

/********************************* ClassDeclaration ****************************/

ClassDeclaration *ClassDeclaration::classinfo;
ClassDeclaration *ClassDeclaration::object;

ClassDeclaration::ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses)
    : AggregateDeclaration(loc, id)
{
    static char msg[] = "only object.d can define this reserved class name";

    if (baseclasses)
    this->baseclasses = *baseclasses;
    baseClass = NULL;

    interfaces_dim = 0;
    interfaces = NULL;

    vtblInterfaces = NULL;

    //printf("ClassDeclaration(%s), dim = %d\n", id->toChars(), this->baseclasses.dim);

    // For forward references
    type = new TypeClass(this);
    handle = type;

    staticCtor = NULL;
    staticDtor = NULL;

    vtblsym = NULL;
    vclassinfo = NULL;

    if (id)
    {   // Look for special class names

    if (id == Id::__sizeof || id == Id::alignof || id == Id::mangleof)
        error("illegal class name");

    // BUG: What if this is the wrong TypeInfo, i.e. it is nested?
    if (id->toChars()[0] == 'T')
    {
        if (id == Id::TypeInfo)
        {   if (Type::typeinfo)
            Type::typeinfo->error("%s", msg);
        Type::typeinfo = this;
        }

        if (id == Id::TypeInfo_Class)
        {   if (Type::typeinfoclass)
            Type::typeinfoclass->error("%s", msg);
        Type::typeinfoclass = this;
        }

        if (id == Id::TypeInfo_Interface)
        {   if (Type::typeinfointerface)
            Type::typeinfointerface->error("%s", msg);
        Type::typeinfointerface = this;
        }

        if (id == Id::TypeInfo_Struct)
        {   if (Type::typeinfostruct)
            Type::typeinfostruct->error("%s", msg);
        Type::typeinfostruct = this;
        }

        if (id == Id::TypeInfo_Typedef)
        {   if (Type::typeinfotypedef)
            Type::typeinfotypedef->error("%s", msg);
        Type::typeinfotypedef = this;
        }

        if (id == Id::TypeInfo_Pointer)
        {   if (Type::typeinfopointer)
            Type::typeinfopointer->error("%s", msg);
        Type::typeinfopointer = this;
        }

        if (id == Id::TypeInfo_Array)
        {   if (Type::typeinfoarray)
            Type::typeinfoarray->error("%s", msg);
        Type::typeinfoarray = this;
        }

        if (id == Id::TypeInfo_StaticArray)
        {   //if (Type::typeinfostaticarray)
            //Type::typeinfostaticarray->error("%s", msg);
        Type::typeinfostaticarray = this;
        }

        if (id == Id::TypeInfo_AssociativeArray)
        {   if (Type::typeinfoassociativearray)
            Type::typeinfoassociativearray->error("%s", msg);
        Type::typeinfoassociativearray = this;
        }

        if (id == Id::TypeInfo_Enum)
        {   if (Type::typeinfoenum)
            Type::typeinfoenum->error("%s", msg);
        Type::typeinfoenum = this;
        }

        if (id == Id::TypeInfo_Function)
        {   if (Type::typeinfofunction)
            Type::typeinfofunction->error("%s", msg);
        Type::typeinfofunction = this;
        }

        if (id == Id::TypeInfo_Delegate)
        {   if (Type::typeinfodelegate)
            Type::typeinfodelegate->error("%s", msg);
        Type::typeinfodelegate = this;
        }

        if (id == Id::TypeInfo_Tuple)
        {   if (Type::typeinfotypelist)
            Type::typeinfotypelist->error("%s", msg);
        Type::typeinfotypelist = this;
        }

#if V2
        if (id == Id::TypeInfo_Const)
        {   if (Type::typeinfoconst)
            Type::typeinfoconst->error("%s", msg);
        Type::typeinfoconst = this;
        }

        if (id == Id::TypeInfo_Invariant)
        {   if (Type::typeinfoinvariant)
            Type::typeinfoinvariant->error("%s", msg);
        Type::typeinfoinvariant = this;
        }
#endif
    }

    if (id == Id::Object)
    {   if (object)
        object->error("%s", msg);
        object = this;
    }

    if (id == Id::ClassInfo)
    {   if (classinfo)
        classinfo->error("%s", msg);
        classinfo = this;
    }

    if (id == Id::ModuleInfo)
    {   if (Module::moduleinfo)
        Module::moduleinfo->error("%s", msg);
        Module::moduleinfo = this;
    }
    }

    com = 0;
    isauto = 0;
    isabstract = 0;
    isnested = 0;
    vthis = NULL;
    inuse = 0;
}

Dsymbol *ClassDeclaration::syntaxCopy(Dsymbol *s)
{
    ClassDeclaration *cd;

    //printf("ClassDeclaration::syntaxCopy('%s')\n", toChars());
    if (s)
    cd = (ClassDeclaration *)s;
    else
    cd = new ClassDeclaration(loc, ident, NULL);

    cd->storage_class |= storage_class;

    cd->baseclasses.setDim(this->baseclasses.dim);
    for (int i = 0; i < cd->baseclasses.dim; i++)
    {
    BaseClass *b = (BaseClass *)this->baseclasses.data[i];
    BaseClass *b2 = new BaseClass(b->type->syntaxCopy(), b->protection);
    cd->baseclasses.data[i] = b2;
    }

    ScopeDsymbol::syntaxCopy(cd);
    return cd;
}

void ClassDeclaration::semantic(Scope *sc)
{   int i;
    unsigned offset;

    //printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
    //printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
    //printf("sc->stc = %x\n", sc->stc);

    //{ static int n;  if (++n == 20) *(char*)0=0; }

    if (!ident)     // if anonymous class
    {   const char *id = "__anonclass";

    ident = Identifier::generateId(id);
    }

    if (!scope)
    {
    if (!parent && sc->parent && !sc->parent->isModule())
        parent = sc->parent;

    type = type->semantic(loc, sc);
    handle = handle->semantic(loc, sc);
    }
    if (!members)           // if forward reference
    {   //printf("\tclass '%s' is forward referenced\n", toChars());
    return;
    }
    if (symtab)
    {   if (!scope)
    {   //printf("\tsemantic for '%s' is already completed\n", toChars());
        return;     // semantic() already completed
    }
    }
    else
    symtab = new DsymbolTable();

    Scope *scx = NULL;
    if (scope)
    {   sc = scope;
    scx = scope;        // save so we don't make redundant copies
    scope = NULL;
    }
#ifdef IN_GCC
    methods.setDim(0);
#endif

    if (sc->stc & STCdeprecated)
    {
    isdeprecated = 1;
    }

    if (sc->linkage == LINKcpp)
    error("cannot create C++ classes");

    // Expand any tuples in baseclasses[]
    for (i = 0; i < baseclasses.dim; )
    {   BaseClass *b = (BaseClass *)baseclasses.data[i];
    b->type = b->type->semantic(loc, sc);
    Type *tb = b->type->toBasetype();

    if (tb->ty == Ttuple)
    {   TypeTuple *tup = (TypeTuple *)tb;
        enum PROT protection = b->protection;
        baseclasses.remove(i);
        size_t dim = Argument::dim(tup->arguments);
        for (size_t j = 0; j < dim; j++)
        {   Argument *arg = Argument::getNth(tup->arguments, j);
        b = new BaseClass(arg->type, protection);
        baseclasses.insert(i + j, b);
        }
    }
    else
        i++;
    }

    // See if there's a base class as first in baseclasses[]
    if (baseclasses.dim)
    {   TypeClass *tc;
    BaseClass *b;
    Type *tb;

    b = (BaseClass *)baseclasses.data[0];
    //b->type = b->type->semantic(loc, sc);
    tb = b->type->toBasetype();
    if (tb->ty != Tclass)
    {   error("base type must be class or interface, not %s", b->type->toChars());
        baseclasses.remove(0);
    }
    else
    {
        tc = (TypeClass *)(tb);

        if (tc->sym->isDeprecated())
        {
        if (!isDeprecated())
        {
            // Deriving from deprecated class makes this one deprecated too
            isdeprecated = 1;

            tc->checkDeprecated(loc, sc);
        }
        }

        if (tc->sym->isInterfaceDeclaration())
        ;
        else
        {
        for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
        {
            if (cdb == this)
            {
            error("circular inheritance");
            baseclasses.remove(0);
            goto L7;
            }
        }
        if (!tc->sym->symtab || tc->sym->scope || tc->sym->sizeok == 0)
        {
            //error("forward reference of base class %s", baseClass->toChars());
            // Forward reference of base class, try again later
            //printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
            scope = scx ? scx : new Scope(*sc);
            scope->setNoFree();
            scope->module->addDeferredSemantic(this);
            return;
        }
        else
        {   baseClass = tc->sym;
            b->base = baseClass;
        }
         L7: ;
        }
    }
    }

    // Treat the remaining entries in baseclasses as interfaces
    // Check for errors, handle forward references
    for (i = (baseClass ? 1 : 0); i < baseclasses.dim; )
    {   TypeClass *tc;
    BaseClass *b;
    Type *tb;

    b = (BaseClass *)baseclasses.data[i];
    b->type = b->type->semantic(loc, sc);
    tb = b->type->toBasetype();
    if (tb->ty == Tclass)
        tc = (TypeClass *)tb;
    else
        tc = NULL;
    if (!tc || !tc->sym->isInterfaceDeclaration())
    {
        error("base type must be interface, not %s", b->type->toChars());
        baseclasses.remove(i);
        continue;
    }
    else
    {
        if (tc->sym->isDeprecated())
        {
        if (!isDeprecated())
        {
            // Deriving from deprecated class makes this one deprecated too
            isdeprecated = 1;

            tc->checkDeprecated(loc, sc);
        }
        }

        // Check for duplicate interfaces
        for (size_t j = (baseClass ? 1 : 0); j < i; j++)
        {
        BaseClass *b2 = (BaseClass *)baseclasses.data[j];
        if (b2->base == tc->sym)
            error("inherits from duplicate interface %s", b2->base->toChars());
        }

        b->base = tc->sym;
        if (!b->base->symtab || b->base->scope)
        {
        //error("forward reference of base class %s", baseClass->toChars());
        // Forward reference of base, try again later
        //printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
        scope = scx ? scx : new Scope(*sc);
        scope->setNoFree();
        scope->module->addDeferredSemantic(this);
        return;
        }
    }
    i++;
    }


    // If no base class, and this is not an Object, use Object as base class
    if (!baseClass && ident != Id::Object)
    {
    // BUG: what if Object is redefined in an inner scope?
    Type *tbase = new TypeIdentifier(0, Id::Object);
    BaseClass *b;
    TypeClass *tc;
    Type *bt;

    if (!object)
    {
        error("missing or corrupt object.d");
        fatal();
    }
    bt = tbase->semantic(loc, sc)->toBasetype();
    b = new BaseClass(bt, PROTpublic);
    baseclasses.shift(b);
    assert(b->type->ty == Tclass);
    tc = (TypeClass *)(b->type);
    baseClass = tc->sym;
    assert(!baseClass->isInterfaceDeclaration());
    b->base = baseClass;
    }

    interfaces_dim = baseclasses.dim;
    interfaces = (BaseClass **)baseclasses.data;


    if (baseClass)
    {
    if (baseClass->storage_class & STCfinal)
        error("cannot inherit from final class %s", baseClass->toChars());

    interfaces_dim--;
    interfaces++;

    // Copy vtbl[] from base class
    vtbl.setDim(baseClass->vtbl.dim);
    memcpy(vtbl.data, baseClass->vtbl.data, sizeof(void *) * vtbl.dim);

    // Inherit properties from base class
    com = baseClass->isCOMclass();
    isauto = baseClass->isauto;
    vthis = baseClass->vthis;
    storage_class |= baseClass->storage_class & (STCconst | STCinvariant);
    }
    else
    {
    // No base class, so this is the root of the class hierarchy
    vtbl.setDim(0);
    vtbl.push(this);        // leave room for classinfo as first member
    }

    protection = sc->protection;
    storage_class |= sc->stc;

    if (sizeok == 0)
    {
    interfaceSemantic(sc);

    for (i = 0; i < members->dim; i++)
    {
        Dsymbol *s = (Dsymbol *)members->data[i];
        s->addMember(sc, this, 1);
    }

    /* If this is a nested class, add the hidden 'this'
     * member which is a pointer to the enclosing scope.
     */
    if (vthis)      // if inheriting from nested class
    {   // Use the base class's 'this' member
        isnested = 1;
        if (storage_class & STCstatic)
        error("static class cannot inherit from nested class %s", baseClass->toChars());
        if (toParent2() != baseClass->toParent2())
        {
        if (toParent2())
        {
            error("is nested within %s, but super class %s is nested within %s",
            toParent2()->toChars(),
            baseClass->toChars(),
            baseClass->toParent2()->toChars());
        }
        else
        {
            error("is not nested, but super class %s is nested within %s",
            baseClass->toChars(),
            baseClass->toParent2()->toChars());
        }
        isnested = 0;
        }
    }
    else if (!(storage_class & STCstatic))
    {   Dsymbol *s = toParent2();
        if (s)
        {
        ClassDeclaration *cd = s->isClassDeclaration();
        FuncDeclaration *fd = s->isFuncDeclaration();


        if (cd || fd)
        {   isnested = 1;
            Type *t;
            if (cd)
            t = cd->type;
            else if (fd)
            {   AggregateDeclaration *ad = fd->isMember2();
            if (ad)
                t = ad->handle;
            else
            {
                t = new TypePointer(Type::tvoid);
                t = t->semantic(0, sc);
            }
            }
            else
            assert(0);
            assert(!vthis);
            vthis = new ThisDeclaration(t);
            members->push(vthis);
        }
        }
    }
    }

    if (storage_class & (STCauto | STCscope))
    isauto = 1;
    if (storage_class & STCabstract)
    isabstract = 1;
    if (storage_class & STCinvariant)
    type = type->invariantOf();
    else if (storage_class & STCconst)
    type = type->constOf();

    sc = sc->push(this);
    sc->stc &= ~(STCfinal | STCauto | STCscope | STCstatic |
         STCabstract | STCdeprecated | STCconst | STCinvariant | STCtls);
    sc->stc |= storage_class & (STCconst | STCinvariant);
    sc->parent = this;
    sc->inunion = 0;

    if (isCOMclass())
    sc->linkage = LINKwindows;
    sc->protection = PROTpublic;
    sc->explicitProtection = 0;
    sc->structalign = 8;
    structalign = sc->structalign;
    if (baseClass)
    {   sc->offset = baseClass->structsize;
    alignsize = baseClass->alignsize;
//  if (isnested)
//      sc->offset += PTRSIZE;  // room for uplevel context pointer
    }
    else
    {   sc->offset = PTRSIZE * 2;   // allow room for __vptr and __monitor
    alignsize = 4;
    }
    structsize = sc->offset;
    Scope scsave = *sc;
    int members_dim = members->dim;
    sizeok = 0;
    for (i = 0; i < members_dim; i++)
    {
    Dsymbol *s = (Dsymbol *)members->data[i];
    s->semantic(sc);
    }

    if (sizeok == 2)
    {   // semantic() failed because of forward references.
    // Unwind what we did, and defer it for later
    fields.setDim(0);
    structsize = 0;
    alignsize = 0;
    structalign = 0;

    sc = sc->pop();

    scope = scx ? scx : new Scope(*sc);
    scope->setNoFree();
    scope->module->addDeferredSemantic(this);

    //printf("\tsemantic('%s') failed due to forward references\n", toChars());
    return;
    }

    //printf("\tsemantic('%s') successful\n", toChars());

    structsize = sc->offset;
    //members->print();

    /* Look for special member functions.
     * They must be in this class, not in a base class.
     */
    ctor = (CtorDeclaration *)search(0, Id::ctor, 0);
    if (ctor && (ctor->toParent() != this || !ctor->isCtorDeclaration()))
    ctor = NULL;

//    dtor = (DtorDeclaration *)search(Id::dtor, 0);
//    if (dtor && dtor->toParent() != this)
//  dtor = NULL;

//    inv = (InvariantDeclaration *)search(Id::classInvariant, 0);
//    if (inv && inv->toParent() != this)
//  inv = NULL;

    // Can be in base class
    aggNew    = (NewDeclaration *)search(0, Id::classNew, 0);
    aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);

    // If this class has no constructor, but base class does, create
    // a constructor:
    //    this() { }
    if (!ctor && baseClass && baseClass->ctor)
    {
    //printf("Creating default this(){} for class %s\n", toChars());
    ctor = new