Changeset 223

Timestamp:

10/29/09 04:58:14 (15 years ago)

Author:

walter

Message:

bugzilla 3102

Files:

• trunk/src/expression.c (modified) (3 diffs)
• trunk/src/mtype.c (modified) (1 diff)
• trunk/src/mtype.h (modified) (2 diffs)
• trunk/src/template.c (modified) (1 diff)

trunk/src/expression.c

@@ -1392 +1392 @@
-        case Tenum:
-        {
-        TypeEnum *te = (TypeEnum *)t;
-        t = te->sym->memtype;
-        continue;
-        }
-
-        case Ttypedef:
-        {
-        TypeTypedef *tt = (TypeTypedef *)t;
-        t = tt->sym->basetype;
-        continue;
-        }
-
-        default:
-        /* This can happen if errors, such as
-         * the type is painted on like in fromConstInitializer().
-         */
-        if (!global.errors)
-        {
-printf("ty = %d, %d\n", type->ty, t->ty);
-if (type->ty == Tenum) printf("test1\n");
-            type->print();
-            assert(0);
-        }
-        break;
-    }
-    break;
-    }
-    return value;
-}
-
-real_t IntegerExp::toReal()
-{
-    Type *t;
-
-    toInteger();
-    t = type->toBasetype();
-    if (t->ty == Tuns64)
-    return (real_t)(d_uns64)value;
-    else
-    return (real_t)(d_int64)value;
@@ -4734 +4732 @@
-    p->setDim(parameters->dim);
-    for (int i = 0; i < p->dim; i++)
-    {   TemplateParameter *tp = (TemplateParameter *)parameters->data[i];
-        p->data[i] = (void *)tp->syntaxCopy();
-    }
-    }
-
-    return new IsExp(loc,
-    targ->syntaxCopy(),
-    id,
-    tok,
-    tspec ? tspec->syntaxCopy() : NULL,
-    tok2,
-    p);
-}
-
-Expression *IsExp::semantic(Scope *sc)
-{   Type *tded;
-
-    /* is(targ id tok tspec)
+     * is(targ id :  tok2)
-     * is(targ id == tok2)
-     */
-
-    //printf("IsExp::semantic(%s)\n", toChars());
-    if (id && !(sc->flags & SCOPEstaticif))
-    error("can only declare type aliases within static if conditionals");
-
-    Type *t = targ->trySemantic(loc, sc);
-    if (!t)
-    goto Lno;           // errors, so condition is false
-    targ = t;
-    if (tok2 != TOKreserved)
-    {
-    switch (tok2)
-    {
-        case TOKtypedef:
-        if (targ->ty != Ttypedef)
-            goto Lno;
-        tded = ((TypeTypedef *)targ)->sym->basetype;
-        break;
@@ -4886 +4885 @@
-        else if (targ->ty == Tpointer &&
-             ((TypePointer *)targ)->next->ty == Tfunction)
-        {   tded = ((TypePointer *)targ)->next;
-            tded = ((TypeFunction *)tded)->next;
-        }
-        else
-            goto Lno;
-        break;
-
-        default:
-        assert(0);
-    }
-    goto Lyes;
-    }
-    else if (id && tspec)
-    {
-    /* Evaluate to TRUE if targ matches tspec.
-     * If TRUE, declare id as an alias for the specialized type.
-     */
-
-    MATCH m;
-    assert(parameters && parameters->dim);
-
-    Objects dedtypes;
-    dedtypes.setDim(parameters->dim);
-    dedtypes.zero();
-
-
+
+
+
+
-    if (m == MATCHnomatch ||
-        (m != MATCHexact && tok == TOKequal))
-    {
-        goto Lno;
-    }
-    else
-    {
-        tded = (Type *)dedtypes.data[0];
-        if (!tded)
-        tded = targ;
-
-        Objects tiargs;
-        tiargs.setDim(1);
-        tiargs.data[0] = (void *)targ;
-
-        /* Declare trailing parameters
-         */
-        for (int i = 1; i < parameters->dim; i++)
-        {   TemplateParameter *tp = (TemplateParameter *)parameters->data[i];
-        Declaration *s = NULL;

trunk/src/mtype.c

@@ -328 +328 @@
- *  MATCHequal  'this' == 'to'
- *  MATCHconst  'to' is const
- *  MATCHnomatch    conversion to mutable or invariant
- */
-
-MATCH Type::constConv(Type *to)
-{
-    if (equals(to))
-    return MATCHexact;
-    if (ty == to->ty && to->mod == MODconst)
-    return MATCHconst;
-    return MATCHnomatch;
-}
-
-/********************************
- * Convert to 'const'.
- */
-
-Type *Type::constOf()
-{
-#if 0
-    //printf("Type::constOf() %p %s\n", this, toChars());
-    if (isConst())
-    return this;
-    if (cto)
-    return cto;
-    Type *t = makeConst();
-    t = t->merge();
-    cto = t;
-    if (ito)
-    ito->cto = t;
-    //if (t->nextOf()) assert(t->nextOf()->isConst());
-    //printf("-Type::constOf() %p %s\n", t, toChars());
-    return t;
-#else
-    //printf("Type::constOf() %p %s\n", this, toChars());
-    if (mod == MODconst)
-    return this;
-    if (cto)
-    {   assert(cto->mod == MODconst);
-    return cto;
-    }
-    Type *t = makeConst();
-    t = t->merge();
-    t->fixTo(this);
-    //printf("-Type::constOf() %p %s\n", t, toChars());
-    return t;
-#endif
-}
-
-/********************************
- * Convert to 'immutable'.
- */
-
-Type *Type::invariantOf()
-{
-#if 0
-    //printf("Type::invariantOf() %p %s\n", this, toChars());
-    if (isInvariant())
-    {
-    return this;
-    }
-    if (ito)
-    {
-    //if (!ito->isInvariant()) printf("\tito is %p %s\n", ito, ito->toChars());
-    assert(ito->isInvariant());
-    return ito;
-    }
-    Type *t = makeInvariant();
-    t = t->merge();
-    ito = t;
-    if (cto)
-    cto->ito = t;
-#if 0 // fails for function types
-    if (t->nextOf() && !t->nextOf()->isInvariant())
-    {
-    assert(0);
-    }
-#endif
-    //printf("\t%p\n", t);
-    return t;
-#else
-    //printf("Type::invariantOf() %p %s\n", this, toChars());
-    if (isInvariant())
-    {
-    return this;
-    }
-    if (ito)
-    {
-    assert(ito->isInvariant());
-    return ito;
-    }
-    Type *t = makeInvariant();
-    t = t->merge();
-    t->fixTo(this);
-    //printf("\t%p\n", t);
-    return t;
-#endif
-}
-
-/********************************
- * Make type mutable.
- */
-
-Type *Type::mutableOf()
-{
-#if 0
-    //printf("Type::mutableOf() %p, %s\n", this, toChars());
-    Type *t = this;
-    if (isConst())
-    {   t = cto;
-    assert(!t || t->isMutable());
-    }
-    else if (isInvariant())
-    {   t = ito;
-    assert(!t || t->isMutable());
-    }
-    if (!t)
-    {
-    unsigned sz = sizeTy[ty];
-    t = (Type *)mem.malloc(sz);
-    memcpy(t, this, sz);
-    t->mod = 0;
-    t->deco = NULL;
-    t->arrayof = NULL;
-    t->pto = NULL;
-    t->rto = NULL;
-    t->cto = NULL;
-    t->ito = NULL;
-    t->sto = NULL;
-    t->scto = NULL;
-    t->vtinfo = NULL;
-    if (ty == Tsarray)
-    {   TypeSArray *ta = (TypeSArray *)t;
-        //ta->next = ta->next->mutableOf();
-    }
-    t = t->merge();
-    if (isConst())
-    {   cto = t;
-        t->cto = this;
-        if (ito)
-        ito->cto = this;
-    }
-    else if (isInvariant())
-    {   ito = t;
-        t->ito = this;
-        if (cto)
-        cto->ito = this;
-    }
-    }
-    return t;
-#else
-    //printf("Type::mutableOf() %p, %s\n", this, toChars());
-    Type *t = this;
-    if (isConst())
-    {   if (isShared())
-        t = sto;        // shared const => shared
-    else
-        t = cto;
-    assert(!t || t->isMutable());
-    }
-    else if (isInvariant())
-    {   t = ito;
-    assert(!t || (t->isMutable() && !t->isShared()));
-    }
-    if (!t)
-    {
-    unsigned sz = sizeTy[ty];
-    t = (Type *)mem.malloc(sz);
-    memcpy(t, this, sz);
-0
+ mod & MODshared
-    t->deco = NULL;
-    t->arrayof = NULL;
-    t->pto = NULL;
-    t->rto = NULL;
-    t->cto = NULL;
-    t->ito = NULL;
-    t->sto = NULL;
-    t->scto = NULL;
-    t->vtinfo = NULL;
-    t = t->merge();
-
-    t->fixTo(this);
-
-    switch (mod)
-    {
-        case MODconst:
-        t->cto = this;
-        break;
-
-        case MODinvariant:
-        t->ito = this;
-        break;
-
-        case MODshared:
-        t->sto = this;
-        break;
-
-        case MODshared | MODconst:
-        t->scto = this;
-        break;
-
-        default:
-        assert(0);
-    }
-    }
-    return t;
-#endif
-}
-
-Type *Type::sharedOf()
-{
-    //printf("Type::sharedOf() %p, %s\n", this, toChars());
-    if (mod == MODshared)
-    {
-    return this;
-    }
-    if (sto)
-    {
-    assert(sto->isShared());
-    return sto;
-    }
-    Type *t = makeShared();
-    t = t->merge();
-    t->fixTo(this);
-    //printf("\t%p\n", t);
-    return t;
-}
-
-Type *Type::sharedConstOf()
-{
-    //printf("Type::sharedConstOf() %p, %s\n", this, toChars());
-    if (mod == (MODshared | MODconst))
-    {
-    return this;
-    }
-    if (scto)
-    {
-    assert(scto->mod == (MODshared | MODconst));
-    return scto;
-    }
-    Type *t = makeSharedConst();
-    t = t->merge();
-    t->fixTo(this);
-    //printf("\t%p\n", t);
-    return t;
-}
-
+
+/********************************
+ * Make type unshared.
+ */
+
+Type *Type::unSharedOf()
+{
+    //printf("Type::unSharedOf() %p, %s\n", this, toChars());
+    Type *t = this;
+
+    if (isShared())
+    {
+    if (isConst())
+        t = cto;    // shared const => const
+    else
+        t = sto;
+    assert(!t || !t->isShared());
+    }
+
+    if (!t)
+    {
+    unsigned sz = sizeTy[ty];
+    t = (Type *)mem.malloc(sz);
+    memcpy(t, this, sz);
+    t->mod = mod & ~MODshared;
+    t->deco = NULL;
+    t->arrayof = NULL;
+    t->pto = NULL;
+    t->rto = NULL;
+    t->cto = NULL;
+    t->ito = NULL;
+    t->sto = NULL;
+    t->scto = NULL;
+    t->vtinfo = NULL;
+    t = t->merge();
+
+    t->fixTo(this);
+
+    switch (mod)
+    {
+        case MODshared:
+        t->sto = this;
+        break;
+
+        case MODshared | MODconst:
+        t->scto = this;
+        break;
+
+        default:
+        assert(0);
+    }
+    }
+    assert(!t->isShared());
+    return t;
+}
-
-/**********************************
- * For our new type 'this', which is type-constructed from t,
- * fill in the cto, ito, sto, scto shortcuts.
- */
-
-void Type::fixTo(Type *t)
-{
-    ito = t->ito;
-#if 0
-    /* Cannot do these because these are not fully transitive:
-     * there can be a shared ptr to immutable, for example.
-     * Immutable subtypes are always immutable, though.
-     */
-    cto = t->cto;
-    sto = t->sto;
-    scto = t->scto;
-#endif
-
-    assert(mod != t->mod);

trunk/src/mtype.h

@@ -98 +98 @@
-    Ttuple,
-    Tslice,
-    Treturn,
-    TMAX
-};
-typedef unsigned char TY;   // ENUMTY
-
-#define Tascii Tchar
-
-extern int Tsize_t;
-extern int Tptrdiff_t;
-
-
-struct Type : Object
-{
-    TY ty;
-    unsigned char mod;  // modifiers MODxxxx
-    /* pick this order of numbers so switch statements work better
-     */
-    #define MODconst     1  // type is const
-
+
+
-    #define MODshared    2  // type is shared
-    char *deco;
-
-    /* These are cached values that are lazily evaluated by constOf(), invariantOf(), etc.
-     * They should not be referenced by anybody but mtype.c.
-     * They can be NULL if not lazily evaluated yet.
-     * Note that there is no "shared immutable", because that is just immutable
-     */
-
-    Type *cto;      // MODconst ? mutable version of this type : const version
-    Type *ito;      // MODinvariant ? mutable version of this type : invariant version
-    Type *sto;      // MODshared ? mutable version of this type : shared mutable version
-    Type *scto;     // MODshared|MODconst ? mutable version of this type : shared const version
-
-    Type *pto;      // merged pointer to this type
-    Type *rto;      // reference to this type
-    Type *arrayof;  // array of this type
-    TypeInfoDeclaration *vtinfo;    // TypeInfo object for this Type
-
-    type *ctype;    // for back end
@@ -236 +237 @@
-    virtual int isreal();
-    virtual int isimaginary();
-    virtual int iscomplex();
-    virtual int isscalar();
-    virtual int isunsigned();
-    virtual int isauto();
-    virtual int isString();
-    virtual int isAssignable();
-    virtual int checkBoolean(); // if can be converted to boolean value
-    virtual void checkDeprecated(Loc loc, Scope *sc);
-    int isConst()   { return mod & MODconst; }
-    int isInvariant()   { return mod & MODinvariant; }
-    int isMutable() { return !(mod & (MODconst | MODinvariant)); }
-    int isShared()  { return mod & MODshared; }
-    int isSharedConst() { return mod == (MODshared | MODconst); }
-    Type *constOf();
-    Type *invariantOf();
-    Type *mutableOf();
-    Type *sharedOf();
-    Type *sharedConstOf();
+    Type *unSharedOf();
-    void fixTo(Type *t);
-    void check();
-    Type *castMod(unsigned mod);
-    Type *addMod(unsigned mod);
-    Type *addStorageClass(unsigned stc);
-    Type *pointerTo();
-    Type *referenceTo();
-    Type *arrayOf();
-    virtual Type *makeConst();
-    virtual Type *makeInvariant();
-    virtual Type *makeShared();
-    virtual Type *makeSharedConst();
-    virtual Dsymbol *toDsymbol(Scope *sc);
-    virtual Type *toBasetype();
-    virtual Type *toHeadMutable();
-    virtual int isBaseOf(Type *t, int *poffset);
-    virtual MATCH constConv(Type *to);
-    virtual MATCH implicitConvTo(Type *to);
-    virtual ClassDeclaration *isClassHandle();
-    virtual Expression *getProperty(Loc loc, Identifier *ident);

trunk/src/template.c

@@ -1574 +1574 @@
-        TemplateParameter *tp = (TemplateParameter *)parameters->data[0];
-        loc = tp->loc;
-        }
-
-        /* BUG: what if tparam is a template instance, that
-         * has as an argument another Tident?
-         */
-        tparam = tparam->semantic(loc, sc);
-        assert(tparam->ty != Tident);
-        return deduceType(sc, tparam, parameters, dedtypes);
-    }
-
-    TemplateParameter *tp = (TemplateParameter *)parameters->data[i];
-
-    // Found the corresponding parameter tp
-    if (!tp->isTemplateTypeParameter())
-        goto Lnomatch;
-    Type *tt = this;
-    Type *at = (Type *)dedtypes->data[i];
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    if (tt->equals(at))
-        goto Lexact;
-    else if (tt->ty == Tclass && at->ty == Tclass)
-    {
-        return tt->implicitConvTo(at);
-    }
-    else if (tt->ty == Tsarray && at->ty == Tarray &&
-        tt->nextOf()->implicitConvTo(at->nextOf()) >= MATCHconst)
-    {
-        goto Lexact;
-    }
-    else
-        goto Lnomatch;
-    }
-
-    if (ty != tparam->ty)
-    return implicitConvTo(tparam);
-//  goto Lnomatch;
-