root/trunk/rebuild/cast.c

// 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 <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("Expression::implicitCastTo(%s of type %s) => %s\n", toChars(), type->toChars(), t->toChars());

    MATCH match = implicitConvTo(t);
    if (match)
    {
    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());*/
    }
#if V2
    if (match == MATCHconst && t == type->constOf())
    {
        Expression *e = copy();
        e->type = t;
        return e;
    }
#endif
    return castTo(sc, t);
    }

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

#if 0
printf("ty = %d\n", type->ty);
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->nextOf()->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
    //static int nest; if (++nest == 10) halt();
    if (!type)
    {   //error("%s is not an expression", toChars());
    type = Type::terror;
    }
    Expression *e = optimize(WANTvalue | WANTflags);
    if (e->type == t)
    return MATCHexact;
    if (e != this)
    {   //printf("\toptimized to %s of type %s\n", e->toChars(), e->type->toChars());
    return e->implicitConvTo(t);
    }
    MATCH match = type->implicitConvTo(t);
    if (match != MATCHnomatch)
    return match;
#if 0
    Type *tb = t->toBasetype();
    if (tb->ty == Tdelegate)
    {   TypeDelegate *td = (TypeDelegate *)tb;
    TypeFunction *tf = (TypeFunction *)td->nextOf();

    if (!tf->varargs &&
        !(tf->arguments && tf->arguments->dim)
       )
    {
        match = type->implicitConvTo(tf->nextOf());
        if (match)
        return match;
        if (tf->nextOf()->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
    MATCH m = type->implicitConvTo(t);
    if (m >= MATCHconst)
    return m;

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

    if (m == MATCHnomatch && t->ty == Tenum)
    goto Lno;

    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;
    }

    case Tpointer:
//printf("type = %s\n", type->toBasetype()->toChars());
//printf("t = %s\n", t->toBasetype()->toChars());
        if (ty == Tpointer &&
            type->toBasetype()->nextOf()->ty == t->toBasetype()->nextOf()->ty)
        {   /* Allow things like:
         *  const char* P = cast(char *)3;
         *  char* q = P;
         */
        goto Lyes;
        }
        break;
    }
    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;

    /* Allow implicit conversions from invariant to mutable|const,
     * and mutable to invariant. It works because, after all, a null
     * doesn't actually point to anything.
     */
    if (t->invariantOf()->equals(type->invariantOf()))
    return MATCHconst;

    // NULL implicitly converts to any pointer type or dynamic array
    if (type->ty == Tpointer && type->nextOf()->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);
}

#if V2
MATCH StructLiteralExp::implicitConvTo(Type *t)
{
#if 0
    printf("StructLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    MATCH m = Expression::implicitConvTo(t);
    if (m != MATCHnomatch)
    return m;
    if (type->ty == t->ty && type->ty == Tstruct &&
    ((TypeStruct *)type)->sym == ((TypeStruct *)t)->sym)
    {
    m = MATCHconst;
    for (int i = 0; i < elements->dim; i++)
    {   Expression *e = (Expression *)elements->data[i];
        Type *te = e->type;
        if (t->mod == 0)
        te = te->mutableOf();
        else
        {   assert(t->mod == MODinvariant);
        te = te->invariantOf();
        }
        MATCH m2 = e->implicitConvTo(te);
        //printf("\t%s => %s, match = %d\n", e->toChars(), te->toChars(), m2);
        if (m2 < m)
        m = m2;
    }
    }
    return m;
}
#endif

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->nextOf()->ty == Tvoid)
    {
    return MATCHnomatch;
    }
    if (type->ty == Tsarray || type->ty == Tarray || type->ty == Tpointer)
    {
    TY tyn = type->nextOf()->ty;
    if (tyn == Tchar || tyn == Twchar || tyn == Tdchar)
    {   Type *tn;
        MATCH m;

        switch (t->ty)
        {
        case Tsarray:
            if (type->ty == Tsarray)
            {
            if (((TypeSArray *)type)->dim->toInteger() !=
                ((TypeSArray *)t)->dim->toInteger())
                return MATCHnomatch;
            TY tynto = t->nextOf()->ty;
            if (tynto == Tchar || tynto == Twchar || tynto == Tdchar)
                return MATCHexact;
            }
        case Tarray:
        case Tpointer:
            tn = t->nextOf();
            m = MATCHexact;
            if (type->nextOf()->mod != tn->mod)
            {   if (!tn->isConst())
                return MATCHnomatch;
            m = MATCHconst;
            }
            switch (tn->ty)
            {
            case Tchar:
            case Twchar:
            case Tdchar:
                return m;
            }
            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;

#if 0
    printf("ArrayLiteralExp::implicitConvTo(this=%s, type=%s, t=%s)\n",
    toChars(), type->toChars(), t->toChars());
#endif
    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->nextOf());
        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)->index);
        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->nextOf());
        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.

    t = t->toBasetype();

    if (e1->op == TOKoverloadset &&
        (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction)
    {   OverExp *eo = (OverExp *)e1;
        FuncDeclaration *f = NULL;
        for (int i = 0; i < eo->vars->a.dim; i++)
        {   Dsymbol *s = (Dsymbol *)eo->vars->a.data[i];
        FuncDeclaration *f2 = s->isFuncDeclaration();
        assert(f2);
        if (f2->overloadExactMatch(t->nextOf()))
        {   if (f)
            /* Error if match in more than one overload set,
             * even if one is a 'better' match than the other.
             */
            ScopeDsymbol::multiplyDefined(loc, f, f2);
            else
            f = f2;
            result = MATCHexact;
        }
        }
    }

    if (type->ty == Tpointer && type->nextOf()->ty == Tfunction &&
        t->ty == Tpointer && t->nextOf()->ty == Tfunction &&
        e1->op == TOKvar)
    {
        /* I don't think this can ever happen -
         * it should have been
         * converted to a SymOffExp.
         */
        assert(0);
        VarExp *ve = (VarExp *)e1;
        FuncDeclaration *f = ve->var->isFuncDeclaration();
        if (f && f->overloadExactMatch(t->nextOf()))
        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->nextOf()->ty == Tfunction &&
        (t->ty == Tpointer || t->ty == Tdelegate) && t->nextOf()->ty == Tfunction)
    {
        f = var->isFuncDeclaration();
        if (f)
        {   f = f->overloadExactMatch(t->nextOf());
        if (f)
        {   if ((t->ty == Tdelegate && (f->needThis() || f->isNested())) ||
            (t->ty == Tpointer && !(f->needThis() || f->isNested())))
            {
            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 == MATCHnomatch)
    {
    // Look for pointers to functions where the functions are overloaded.
    FuncDeclaration *f;

    t = t->toBasetype();
    if (type->ty == Tdelegate && type->nextOf()->ty == Tfunction &&
        t->ty == Tdelegate && t->nextOf()->ty == Tfunction)
    {
        if (func && func->overloadExactMatch(t->nextOf()))
        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)
{
    //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
    if (type == t)
    return this;
    Expression *e = this;
    Type *tb = t->toBasetype();
    Type *typeb = type->toBasetype();
    if (tb != typeb)
    {
    // Do (type *) cast of (type [dim])