root/branches/dmdfe/cast.c

// Copyright (c) 1999-2006 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 <assert.h>

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

#include "expression.h"
#include "mtype.h"
#include "utf.h"
#include "declaration.h"
#include "aggregate.h"

/* ==================== implicitCast ====================== */

/**************************************
 * Do an implicit cast.
 * Issue error if it can't be done.
 */

Expression *Expression::implicitCastTo(Scope *sc, Type *t)
{
    //printf("implicitCastTo(%s) => %s\n", type->toChars(), t->toChars());
    if (implicitConvTo(t))
    {
    if (global.params.warnings &&
        Type::impcnvWarn[type->toBasetype()->ty][t->toBasetype()->ty] &&
        op != TOKint64)
    {
        Expression *e = optimize(WANTflags | WANTvalue);

        if (e->op == TOKint64)
        return e->implicitCastTo(sc, t);

        fprintf(stdmsg, "warning - ");
        error("implicit conversion of expression (%s) of type %s to %s can cause loss of data",
        toChars(), type->toChars(), t->toChars());
    }
    return castTo(sc, t);
    }

    Expression *e = optimize(WANTflags | WANTvalue);
    if (e != this)
    return e->implicitCastTo(sc, t);

#if 0
print();
type->print();
printf("to:\n");
t->print();
printf("%p %p type: %s to: %s\n", type->deco, t->deco, type->deco, t->deco);
//printf("%p %p %p\n", type->next->arrayOf(), type, t);
fflush(stdout);
#endif
    if (!t->deco)
    {   /* Can happen with:
     *    enum E { One }
     *    class A
     *    { static void fork(EDG dg) { dg(E.One); }
     *  alias void delegate(E) EDG;
     *    }
     * Should eventually make it work.
     */
    error("forward reference to type %s", t->toChars());
    }
    else if (t->reliesOnTident())
    error("forward reference to type %s", t->reliesOnTident()->toChars());

    error("cannot implicitly convert expression (%s) of type %s to %s",
    toChars(), type->toChars(), t->toChars());
    return castTo(sc, t);
}

/*******************************************
 * Return !=0 if we can implicitly convert this to type t.
 * Don't do the actual cast.
 */

MATCH Expression::implicitConvTo(Type *t)
{
#if 0
    printf("Expression::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    if (!type)
    {   error("%s is not an expression", toChars());
    type = Type::terror;
    }
    if (t->ty == Tbit && isBit())
    return MATCHconvert;
    Expression *e = optimize(WANTvalue | WANTflags);
    if (e != this)
    {   //printf("optimzed to %s\n", e->toChars());
    return e->implicitConvTo(t);
    }
    MATCH match = type->implicitConvTo(t);
    if (match)
    return match;
#if 0
    Type *tb = t->toBasetype();
    if (tb->ty == Tdelegate)
    {   TypeDelegate *td = (TypeDelegate *)tb;
    TypeFunction *tf = (TypeFunction *)td->next;

    if (!tf->varargs &&
        !(tf->arguments && tf->arguments->dim)
       )
    {
        match = type->implicitConvTo(tf->next);
        if (match)
        return match;
        if (tf->next->toBasetype()->ty == Tvoid)
        return MATCHconvert;
    }
    }
#endif
    return MATCHnomatch;
}


MATCH IntegerExp::implicitConvTo(Type *t)
{
#if 0
    printf("IntegerExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    if (type->equals(t))
    return MATCHexact;

    enum TY ty = type->toBasetype()->ty;
    enum TY toty = t->toBasetype()->ty;

    if (type->implicitConvTo(t) == MATCHnomatch && t->ty == Tenum)
    {
    return MATCHnomatch;
    }

    switch (ty)
    {
    case Tbit:
    case Tbool:
        value &= 1;
        ty = Tint32;
        break;

    case Tint8:
        value = (signed char)value;
        ty = Tint32;
        break;

    case Tchar:
    case Tuns8:
        value &= 0xFF;
        ty = Tint32;
        break;

    case Tint16:
        value = (short)value;
        ty = Tint32;
        break;

    case Tuns16:
    case Twchar:
        value &= 0xFFFF;
        ty = Tint32;
        break;

    case Tint32:
        value = (int)value;
        break;

    case Tuns32:
    case Tdchar:
        value &= 0xFFFFFFFF;
        ty = Tuns32;
        break;

    default:
        break;
    }

    // Only allow conversion if no change in value
    switch (toty)
    {
    case Tbit:
    case Tbool:
        if ((value & 1) != value)
        goto Lno;
        goto Lyes;

    case Tint8:
        if ((signed char)value != value)
        goto Lno;
        goto Lyes;

    case Tchar:
    case Tuns8:
        //printf("value = %llu %llu\n", (integer_t)(unsigned char)value, value);
        if ((unsigned char)value != value)
        goto Lno;
        goto Lyes;

    case Tint16:
        if ((short)value != value)
        goto Lno;
        goto Lyes;

    case Tuns16:
        if ((unsigned short)value != value)
        goto Lno;
        goto Lyes;

    case Tint32:
        if (ty == Tuns32)
        {
        }
        else if ((int)value != value)
        goto Lno;
        goto Lyes;

    case Tuns32:
        if (ty == Tint32)
        {
        }
        else if ((unsigned)value != value)
        goto Lno;
        goto Lyes;

    case Tdchar:
        if (value > 0x10FFFFUL)
        goto Lno;
        goto Lyes;

    case Twchar:
        if ((unsigned short)value != value)
        goto Lno;
        goto Lyes;

    case Tfloat32:
    {
        volatile float f;
        if (type->isunsigned())
        {
        f = (float)value;
        if (f != value)
            goto Lno;
        }
        else
        {
        f = (float)(long long)value;
        if (f != (long long)value)
            goto Lno;
        }
        goto Lyes;
    }

    case Tfloat64:
    {
        volatile double f;
        if (type->isunsigned())
        {
        f = (double)value;
        if (f != value)
            goto Lno;
        }
        else
        {
        f = (double)(long long)value;
        if (f != (long long)value)
            goto Lno;
        }
        goto Lyes;
    }

    case Tfloat80:
    {
        volatile long double f;
        if (type->isunsigned())
        {
        f = (long double)value;
        if (f != value)
            goto Lno;
        }
        else
        {
        f = (long double)(long long)value;
        if (f != (long long)value)
            goto Lno;
        }
        goto Lyes;
    }
    }
    return Expression::implicitConvTo(t);

Lyes:
    //printf("MATCHconvert\n");
    return MATCHconvert;

Lno:
    //printf("MATCHnomatch\n");
    return MATCHnomatch;
}

MATCH NullExp::implicitConvTo(Type *t)
{
#if 0
    printf("NullExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    if (this->type->equals(t))
    return MATCHexact;
    // NULL implicitly converts to any pointer type or dynamic array
    if (type->ty == Tpointer && type->next->ty == Tvoid)
    {
    if (t->ty == Ttypedef)
        t = ((TypeTypedef *)t)->sym->basetype;
    if (t->ty == Tpointer || t->ty == Tarray ||
        t->ty == Taarray  || t->ty == Tclass ||
        t->ty == Tdelegate)
        return committed ? MATCHconvert : MATCHexact;
    }
    return Expression::implicitConvTo(t);
}

MATCH StringExp::implicitConvTo(Type *t)
{   MATCH m;

#if 0
    printf("StringExp::implicitConvTo(this=%s, committed=%d, type=%s, t=%s)\n",
    toChars(), committed, type->toChars(), t->toChars());
#endif
    if (!committed)
    {
    if (!committed && t->ty == Tpointer && t->next->ty == Tvoid)
    {
    return MATCHnomatch;
    }
    if (type->ty == Tsarray || type->ty == Tarray || type->ty == Tpointer)
    {
    if (type->next->ty == Tchar)
    {
        switch (t->ty)
        {
        case Tsarray:
            if (type->ty == Tsarray &&
            ((TypeSArray *)type)->dim->toInteger() !=
            ((TypeSArray *)t)->dim->toInteger())
            return MATCHnomatch;
            goto L1;
        case Tarray:
            goto L1;
        case Tpointer:
        L1:
            if (t->next->ty == Tchar)
            return MATCHexact;
            else if (t->next->ty == Twchar)
            return MATCHexact;
            else if (t->next->ty == Tdchar)
            return MATCHexact;
            break;
        }
    }
    }
    }
    return Expression::implicitConvTo(t);
#if 0
    m = (MATCH)type->implicitConvTo(t);
    if (m)
    {
    return m;
    }

    return MATCHnomatch;
#endif
}

MATCH ArrayLiteralExp::implicitConvTo(Type *t)
{   MATCH result = MATCHexact;

    Type *typeb = type->toBasetype();
    Type *tb = t->toBasetype();
    if ((tb->ty == Tarray || tb->ty == Tsarray) &&
    (typeb->ty == Tarray || typeb->ty == Tsarray))
    {
    if (tb->ty == Tsarray)
    {   TypeSArray *tsa = (TypeSArray *)tb;
        if (elements->dim != tsa->dim->toInteger())
        result = MATCHnomatch;
    }

    for (int i = 0; i < elements->dim; i++)
    {   Expression *e = (Expression *)elements->data[i];
        MATCH m = (MATCH)e->implicitConvTo(tb->next);
        if (m < result)
        result = m;         // remember worst match
        if (result == MATCHnomatch)
        break;              // no need to check for worse
    }
    return result;
    }
    else
    return Expression::implicitConvTo(t);
}

MATCH AssocArrayLiteralExp::implicitConvTo(Type *t)
{   MATCH result = MATCHexact;

    Type *typeb = type->toBasetype();
    Type *tb = t->toBasetype();
    if (tb->ty == Taarray && typeb->ty == Taarray)
    {
    for (size_t i = 0; i < keys->dim; i++)
    {   Expression *e = (Expression *)keys->data[i];
        MATCH m = (MATCH)e->implicitConvTo(((TypeAArray *)tb)->key);
        if (m < result)
        result = m;         // remember worst match
        if (result == MATCHnomatch)
        break;              // no need to check for worse
        e = (Expression *)values->data[i];
        m = (MATCH)e->implicitConvTo(tb->next);
        if (m < result)
        result = m;         // remember worst match
        if (result == MATCHnomatch)
        break;              // no need to check for worse
    }
    return result;
    }
    else
    return Expression::implicitConvTo(t);
}

MATCH AddrExp::implicitConvTo(Type *t)
{
#if 0
    printf("AddrExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    MATCH result;

    result = type->implicitConvTo(t);
    //printf("\tresult = %d\n", result);

    if (result == MATCHnomatch)
    {
    // Look for pointers to functions where the functions are overloaded.
    VarExp *ve;
    FuncDeclaration *f;

    t = t->toBasetype();
    if (type->ty == Tpointer && type->next->ty == Tfunction &&
        t->ty == Tpointer && t->next->ty == Tfunction &&
        e1->op == TOKvar)
    {
        ve = (VarExp *)e1;
        f = ve->var->isFuncDeclaration();
        if (f && f->overloadExactMatch(t->next))
        result = MATCHexact;
    }
    }
    //printf("\tresult = %d\n", result);
    return result;
}

MATCH SymOffExp::implicitConvTo(Type *t)
{
#if 0
    printf("SymOffExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    MATCH result;

    result = type->implicitConvTo(t);
    //printf("\tresult = %d\n", result);

    if (result == MATCHnomatch)
    {
    // Look for pointers to functions where the functions are overloaded.
    FuncDeclaration *f;

    t = t->toBasetype();
    if (type->ty == Tpointer && type->next->ty == Tfunction &&
        t->ty == Tpointer && t->next->ty == Tfunction)
    {
        f = var->isFuncDeclaration();
        if (f && f->overloadExactMatch(t->next))
        result = MATCHexact;
    }
    }
    //printf("\tresult = %d\n", result);
    return result;
}

MATCH DelegateExp::implicitConvTo(Type *t)
{
#if 0
    printf("DelegateExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    MATCH result;

    result = type->implicitConvTo(t);

    if (result == 0)
    {
    // Look for pointers to functions where the functions are overloaded.
    FuncDeclaration *f;

    t = t->toBasetype();
    if (type->ty == Tdelegate && type->next->ty == Tfunction &&
        t->ty == Tdelegate && t->next->ty == Tfunction)
    {
        if (func && func->overloadExactMatch(t->next))
        result = MATCHexact;
    }
    }
    return result;
}

MATCH CondExp::implicitConvTo(Type *t)
{
    MATCH m1;
    MATCH m2;

    m1 = e1->implicitConvTo(t);
    m2 = e2->implicitConvTo(t);

    // Pick the worst match
    return (m1 < m2) ? m1 : m2;
}


/* ==================== castTo ====================== */

/**************************************
 * Do an explicit cast.
 */

Expression *Expression::castTo(Scope *sc, Type *t)
{   Expression *e;
    Type *tb;

    //printf("Expression::castTo(this=%s, t=%s)\n", toChars(), t->toChars());
#if 0
    printf("Expression::castTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    e = this;
    tb = t->toBasetype();
    type = type->toBasetype();
    if (tb != type)
    {
    if (tb->ty == Tbit && isBit())
        ;

    // Do (type *) cast of (type [dim])
    else if (tb->ty == Tpointer &&
        type->ty == Tsarray
       )
    {
        //printf("Converting [dim] to *\n");

        if (type->size(loc) == 0)
        e = new NullExp(loc);
        else
        e = new AddrExp(loc, e);
    }
#if 0
    else if (tb->ty == Tdelegate && type->ty != Tdelegate)
    {
        TypeDelegate *td = (TypeDelegate *)tb;
        TypeFunction *tf = (TypeFunction *)td->next;
        return toDelegate(sc, tf->next);
    }
#endif
    else
    {
        e = new CastExp(loc, e, tb);
    }
    }
    e->type = t;
    //printf("Returning: %s\n", e->toChars());
    return e;
}


Expression *RealExp::castTo(Scope *sc, Type *t)
{
    if (type->isreal() && t->isreal())
    type = t;
    else if (type->isimaginary() && t->isimaginary())
    type = t;
    else
    return Expression::castTo(sc, t);
    return this;
}


Expression *ComplexExp::castTo(Scope *sc, Type *t)
{
    if (type->iscomplex() && t->iscomplex())
    type = t;
    else
    return Expression::castTo(sc, t);
    return this;
}


Expression *NullExp::castTo(Scope *sc, Type *t)
{   Expression *e;
    Type *tb;

    //printf("NullExp::castTo(t = %p)\n", t);
    committed = 1;
    e = this;
    tb = t->toBasetype();
    type = type->toBasetype();
    if (tb != type)
    {
    // NULL implicitly converts to any pointer type or dynamic array
    if (type->ty == Tpointer && type->next->ty == Tvoid &&
        (tb->ty == Tpointer || tb->ty == Tarray || tb->ty == Taarray ||
         tb->ty == Tdelegate))
    {
#if 0
        if (tb->ty == Tdelegate)
        {   TypeDelegate *td = (TypeDelegate *)tb;
        TypeFunction *tf = (TypeFunction *)td->next;

        if (!tf->varargs &&
            !(tf->arguments && tf->arguments->dim)
           )
        {
            return Expression::castTo(sc, t);
        }
        }
#endif
    }
    else
    {
        return Expression::castTo(sc, t);
        //e = new CastExp(loc, e, tb);
    }
    }
    e->type = t;
    return e;
}

Expression *StringExp::castTo(Scope *sc, Type *t)
{
    StringExp *se;
    Type *tb;
    int unique;

    //printf("StringExp::castTo(t = %s), '%s' committed = %d\n", t->toChars(), toChars(), committed);

    if (!committed && t->ty == Tpointer && t->next->ty == Tvoid)
    {
    error("cannot convert string literal to void*");
    }

    tb = t->toBasetype();
    //printf("\ttype = %s\n", type->toChars());
    if (tb->ty == Tdelegate && type->toBasetype()->ty != Tdelegate)
    return Expression::castTo(sc, t);

    se = this;
    unique = 0;
    if (!committed)
    {
    // Copy when committing the type
    void *s;

    s = (unsigned char *)mem.malloc((len + 1) * sz);
    memcpy(s, string, (len + 1) * sz);
    se = new StringExp(loc, s, len);
    se->type = type;
    se->sz = sz;
    se->committed = 0;
    unique = 1;     // this is the only instance
    }
    se->type = type->toBasetype();
    if (tb == se->