root/branches/dmdfe/expression.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2007 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 <ctype.h>
#include <assert.h>
#include <complex>
#include <math.h>

#if _WIN32 && __DMC__
extern "C" char * __cdecl __locale_decpoint;
#endif

#if __WIN32 && __GNUC__
#define isnan _isnan
#elif __APPLE__
using std::isnan;
#endif

#if IN_GCC
// Issues with using -include total.h (defines integer_t) and then complex.h fails...
#undef integer_t
#endif

#ifdef __APPLE__
#define integer_t dmd_integer_t
#endif

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

//#include "port.h"
#include "mtype.h"
#include "init.h"
#include "expression.h"
#include "template.h"
#include "utf.h"
#include "enum.h"
#include "scope.h"
#include "statement.h"
#include "declaration.h"
#include "aggregate.h"
#include "import.h"
#include "id.h"
#include "dsymbol.h"
#include "module.h"
#include "attrib.h"
#include "hdrgen.h"
#include "parse.h"

//Expression *createTypeInfoArray(Scope *sc, Expression *args[], int dim);

#define LOGSEMANTIC 0

/**********************************
 * Set operator precedence for each operator.
 */

// Operator precedence - greater values are higher precedence

enum PREC
{
    PREC_zero,
    PREC_expr,
    PREC_assign,
    PREC_cond,
    PREC_oror,
    PREC_andand,
    PREC_or,
    PREC_xor,
    PREC_and,
    PREC_equal,
    PREC_rel,
    PREC_shift,
    PREC_add,
    PREC_mul,
    PREC_unary,
    PREC_primary,
};

enum PREC precedence[TOKMAX];

void initPrecedence()
{
    precedence[TOKimport] = PREC_primary;
    precedence[TOKidentifier] = PREC_primary;
    precedence[TOKthis] = PREC_primary;
    precedence[TOKsuper] = PREC_primary;
    precedence[TOKint64] = PREC_primary;
    precedence[TOKfloat64] = PREC_primary;
    precedence[TOKnull] = PREC_primary;
    precedence[TOKstring] = PREC_primary;
    precedence[TOKarrayliteral] = PREC_primary;
    precedence[TOKtypedot] = PREC_primary;
    precedence[TOKtypeid] = PREC_primary;
    precedence[TOKis] = PREC_primary;
    precedence[TOKassert] = PREC_primary;
    precedence[TOKfunction] = PREC_primary;
    precedence[TOKvar] = PREC_primary;

    // post
    precedence[TOKdotti] = PREC_primary;
    precedence[TOKdot] = PREC_primary;
//  precedence[TOKarrow] = PREC_primary;
    precedence[TOKplusplus] = PREC_primary;
    precedence[TOKminusminus] = PREC_primary;
    precedence[TOKcall] = PREC_primary;
    precedence[TOKslice] = PREC_primary;
    precedence[TOKarray] = PREC_primary;

    precedence[TOKaddress] = PREC_unary;
    precedence[TOKstar] = PREC_unary;
    precedence[TOKneg] = PREC_unary;
    precedence[TOKuadd] = PREC_unary;
    precedence[TOKnot] = PREC_unary;
    precedence[TOKtobool] = PREC_add;
    precedence[TOKtilde] = PREC_unary;
    precedence[TOKdelete] = PREC_unary;
    precedence[TOKnew] = PREC_unary;
    precedence[TOKcast] = PREC_unary;

    precedence[TOKmul] = PREC_mul;
    precedence[TOKdiv] = PREC_mul;
    precedence[TOKmod] = PREC_mul;

    precedence[TOKadd] = PREC_add;
    precedence[TOKmin] = PREC_add;
    precedence[TOKcat] = PREC_add;

    precedence[TOKshl] = PREC_shift;
    precedence[TOKshr] = PREC_shift;
    precedence[TOKushr] = PREC_shift;

    precedence[TOKlt] = PREC_rel;
    precedence[TOKle] = PREC_rel;
    precedence[TOKgt] = PREC_rel;
    precedence[TOKge] = PREC_rel;
    precedence[TOKunord] = PREC_rel;
    precedence[TOKlg] = PREC_rel;
    precedence[TOKleg] = PREC_rel;
    precedence[TOKule] = PREC_rel;
    precedence[TOKul] = PREC_rel;
    precedence[TOKuge] = PREC_rel;
    precedence[TOKug] = PREC_rel;
    precedence[TOKue] = PREC_rel;
    precedence[TOKin] = PREC_rel;

    precedence[TOKequal] = PREC_equal;
    precedence[TOKnotequal] = PREC_equal;
    precedence[TOKidentity] = PREC_equal;
    precedence[TOKnotidentity] = PREC_equal;

    precedence[TOKand] = PREC_and;

    precedence[TOKxor] = PREC_xor;

    precedence[TOKor] = PREC_or;

    precedence[TOKandand] = PREC_andand;

    precedence[TOKoror] = PREC_oror;

    precedence[TOKquestion] = PREC_cond;

    precedence[TOKassign] = PREC_assign;
    precedence[TOKaddass] = PREC_assign;
    precedence[TOKminass] = PREC_assign;
    precedence[TOKcatass] = PREC_assign;
    precedence[TOKmulass] = PREC_assign;
    precedence[TOKdivass] = PREC_assign;
    precedence[TOKmodass] = PREC_assign;
    precedence[TOKshlass] = PREC_assign;
    precedence[TOKshrass] = PREC_assign;
    precedence[TOKushrass] = PREC_assign;
    precedence[TOKandass] = PREC_assign;
    precedence[TOKorass] = PREC_assign;
    precedence[TOKxorass] = PREC_assign;

    precedence[TOKcomma] = PREC_expr;
}

/*****************************************
 * Determine if 'this' is available.
 * If it is, return the FuncDeclaration that has it.
 */

FuncDeclaration *hasThis(Scope *sc)
{   FuncDeclaration *fd;
    FuncDeclaration *fdthis;

    //printf("hasThis()\n");
    fdthis = sc->parent->isFuncDeclaration();
    //printf("fdthis = %p, '%s'\n", fdthis, fdthis ? fdthis->toChars() : "");

    // Go upwards until we find the enclosing member function
    fd = fdthis;
    while (1)
    {
    if (!fd)
    {
        goto Lno;
    }
    if (!fd->isNested())
        break;

    Dsymbol *parent = fd->parent;
    while (parent)
    {
        TemplateInstance *ti = parent->isTemplateInstance();
        if (ti)
        parent = ti->parent;
        else
        break;
    }

    fd = fd->parent->isFuncDeclaration();
    }

    if (!fd->isThis())
    {   //printf("test '%s'\n", fd->toChars());
    goto Lno;
    }

    assert(fd->vthis);
    return fd;

Lno:
    return NULL;        // don't have 'this' available
}


/***************************************
 * Pull out any properties.
 */

Expression *resolveProperties(Scope *sc, Expression *e)
{
    //printf("resolveProperties(%s)\n", e->toChars());
    if (e->type)
    {
    Type *t = e->type->toBasetype();

    if (t->ty == Tfunction)
    {
        e = new CallExp(e->loc, e);
        e = e->semantic(sc);
    }

    /* Look for e being a lazy parameter; rewrite as delegate call
     */
    else if (e->op == TOKvar)
    {   VarExp *ve = (VarExp *)e;

        if (ve->var->storage_class & STClazy)
        {
        e = new CallExp(e->loc, e);
        e = e->semantic(sc);
        }
    }

    else if (e->op == TOKdotexp)
    {
        e->error("expression has no value");
    }
    }
    return e;
}

/******************************
 * Perform semantic() on an array of Expressions.
 */

void arrayExpressionSemantic(Expressions *exps, Scope *sc)
{
    if (exps)
    {
    for (size_t i = 0; i < exps->dim; i++)
    {   Expression *e = (Expression *)exps->data[i];

        e = e->semantic(sc);
        exps->data[i] = (void *)e;
    }
    }
}

/****************************************
 * Expand tuples.
 */

void expandTuples(Expressions *exps)
{
    //printf("expandTuples()\n");
    if (exps)
    {
    for (size_t i = 0; i < exps->dim; i++)
    {   Expression *arg = (Expression *)exps->data[i];
        if (!arg)
        continue;

        // Look for tuple with 0 members
        if (arg->op == TOKtype)
        {   TypeExp *e = (TypeExp *)arg;
        if (e->type->toBasetype()->ty == Ttuple)
        {   TypeTuple *tt = (TypeTuple *)e->type->toBasetype();

            if (!tt->arguments || tt->arguments->dim == 0)
            {
            exps->remove(i);
            if (i == exps->dim)
                return;
            i--;
            continue;
            }
        }
        }

        // Inline expand all the tuples
        while (arg->op == TOKtuple)
        {   TupleExp *te = (TupleExp *)arg;

        exps->remove(i);        // remove arg
        exps->insert(i, te->exps);  // replace with tuple contents
        if (i == exps->dim)
            return;     // empty tuple, no more arguments
        arg = (Expression *)exps->data[i];
        }
    }
    }
}

/****************************************
 * Preprocess arguments to function.
 */

void preFunctionArguments(Loc loc, Scope *sc, Expressions *exps)
{
    if (exps)
    {
    expandTuples(exps);

    for (size_t i = 0; i < exps->dim; i++)
    {   Expression *arg = (Expression *)exps->data[i];

        if (!arg->type)
        {
#ifdef DEBUG
        if (!global.gag)
            printf("1: \n");
#endif
        arg->error("%s is not an expression", arg->toChars());
        arg = new IntegerExp(arg->loc, 0, Type::tint32);
        }

        arg = resolveProperties(sc, arg);
        exps->data[i] = (void *) arg;

        //arg->rvalue();
#if 0
        if (arg->type->ty == Tfunction)
        {
        arg = new AddrExp(arg->loc, arg);
        arg = arg->semantic(sc);
        exps->data[i] = (void *) arg;
        }
#endif
    }
    }
}


/****************************************
 * Now that we know the exact type of the function we're calling,
 * the arguments[] need to be adjusted:
 *  1) implicitly convert argument to the corresponding parameter type
 *  2) add default arguments for any missing arguments
 *  3) do default promotions on arguments corresponding to ...
 *  4) add hidden _arguments[] argument
 */

void functionArguments(Loc loc, Scope *sc, TypeFunction *tf, Expressions *arguments)
{
    unsigned n;
    int done;
    Type *tb;

    //printf("functionArguments()\n");
    assert(arguments);
    size_t nargs = arguments ? arguments->dim : 0;
    size_t nparams = Argument::dim(tf->parameters);

    if (nargs > nparams && tf->varargs == 0)
    error(loc, "expected " ZU " arguments, not " ZU, nparams, nargs);

    n = (nargs > nparams) ? nargs : nparams;    // n = max(nargs, nparams)

    done = 0;
    for (size_t i = 0; i < n; i++)
    {
    Expression *arg;

    if (i < nargs)
        arg = (Expression *)arguments->data[i];
    else
        arg = NULL;

    if (i < nparams)
    {
        Argument *p = Argument::getNth(tf->parameters, i);

        if (!arg)
        {
        if (!p->defaultArg)
        {
            if (tf->varargs == 2 && i + 1 == nparams)
            goto L2;
            error(loc, "expected " ZU " arguments, not " ZU, nparams, nargs);
            break;
        }
        arg = p->defaultArg->copy();
        arguments->push(arg);
        nargs++;
        }

        if (tf->varargs == 2 && i + 1 == nparams)
        {
        //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars());
        if (arg->implicitConvTo(p->type))
        {
            if (nargs != nparams)
                error(loc, "expected " ZU " arguments, not " ZU, nparams, nargs);
            goto L1;
        }
         L2:
        Type *tb = p->type->toBasetype();
        Type *tret = p->isLazyArray();
        switch (tb->ty)
        {
            case Tsarray:
            case Tarray:
            {   // Create a static array variable v of type arg->type
#ifdef IN_GCC
            /* GCC 4.0 does not like zero length arrays used like
               this; pass a null array value instead. Could also
               just make a one-element array. */
            if (nargs - i == 0)
            {
                arg = new NullExp(loc);
                break;
            }
#endif
            static int idn;
            char name[10 + sizeof(idn)*3 + 1];
            sprintf(name, "__arrayArg%d", ++idn);
            Identifier *id = Lexer::idPool(name);
            Type *t = new TypeSArray(tb->next, new IntegerExp(nargs - i));
            t = t->semantic(loc, sc);
            VarDeclaration *v = new VarDeclaration(loc, t, id, new VoidInitializer(loc));
            v->semantic(sc);
            v->parent = sc->parent;
            //sc->insert(v);

            Expression *c = new DeclarationExp(0, v);
            c->type = v->type;

            for (size_t u = i; u < nargs; u++)
            {   Expression *a = (Expression *)arguments->data[u];
                if (tret && !tb->next->equals(a->type))
                a = a->toDelegate(sc, tret);

                Expression *e = new VarExp(loc, v);
                e = new IndexExp(loc, e, new IntegerExp(u + 1 - nparams));
                e = new AssignExp(loc, e, a);
                if (c)
                c = new CommaExp(loc, c, e);
                else
                c = e;
            }
            arg = new VarExp(loc, v);
            if (c)
                arg = new CommaExp(loc, c, arg);
            break;
            }
            case Tclass:
            {   /* Set arg to be:
             *  new Tclass(arg0, arg1, ..., argn)
             */
            Expressions *args = new Expressions();
            args->setDim(nargs - i);
            for (size_t u = i; u < nargs; u++)
                args->data[u - i] = arguments->data[u];
            arg = new NewExp(loc, NULL, NULL, p->type, args);
            break;
            }
            default:
            if (!arg)
            {   error(loc, "not enough arguments");
                return;
                }
            break;
        }
        arg = arg->semantic(sc);
        //printf("\targ = '%s'\n", arg->toChars());
        arguments->setDim(i + 1);
        done = 1;
        }

    L1:
        if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
        arg = arg->implicitCastTo(sc, p->type);
        if (p->storageClass & (STCout | STCref))
        {
        // BUG: should check that argument to ref is type 'invariant'
        // BUG: assignments to ref should also be type 'invariant'
        arg = arg->modifiableLvalue(sc, NULL);

        //if (arg->op == TOKslice)
            //arg->error("cannot modify slice %s", arg->toChars());
        }

        // Convert static arrays to pointers
        tb = arg->type->toBasetype();
        if (tb->ty == Tsarray)
        {
        arg = arg->checkToPointer();
        }

        // Convert lazy argument to a delegate
        if (p->storageClass & STClazy)
        {
        arg = arg->toDelegate(sc, p->type);
        }
    }
    else
    {

        // If not D linkage, do promotions
        if (tf->linkage != LINKd)
        {
        // Promote bytes, words, etc., to ints
        arg = arg->integralPromotions(sc);

        // Promote floats to doubles
        switch (arg->type->ty)
        {
            case Tfloat32:
            arg = arg->castTo(sc, Type::tfloat64);
            break;

            case Timaginary32:
            arg = arg->castTo(sc, Type::timaginary64);
            break;
        }
        }

        // Convert static arrays to dynamic arrays
        tb = arg->type->toBasetype();
        if (tb->ty == Tsarray)
        {   TypeSArray *ts = (TypeSArray *)tb;
        Type *ta = tb->next->arrayOf();
        if (ts->size(arg->loc) == 0)
        {   arg = new NullExp(arg->loc);
            arg->type = ta;
        }
        else
            arg = arg->castTo(sc, ta);
        }

        arg->rvalue();
    }
    arg = arg->optimize(WANTvalue);
    arguments->data[i] = (void *) arg;
    if (done)
        break;
    }

    // If D linkage and variadic, add _arguments[] as first argument
    if (tf->linkage == LINKd && tf->varargs == 1)
    {
    Expression *e;

    /*e = createTypeInfoArray(sc, (Expression **)&arguments->data[nparams],
        arguments->dim - nparams);
    arguments->insert(0, e);*/
        
        e = new NullExp(loc);
        e->type = Type::tint32;
    }
}

/**************************************************
 * Write expression out to buf, but wrap it
 * in ( ) if its precedence is less than pr.
 */

void expToCBuffer(OutBuffer *buf, HdrGenState *hgs, Expression *e, enum PREC pr)
{
    if (precedence[e->op] < pr)
    {
    buf->writeByte('(');
    e->toCBuffer(buf, hgs);
    buf->writeByte(')');
    }
    else
    e->toCBuffer(buf, hgs);
}

/**************************************************
 * Write out argument list to buf.
 */

void argsToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs)
{
    if (arguments)
    {
    for (size_t i = 0; i < arguments->dim; i++)
    {   Expression *arg = (Expression *)arguments->data[i];

        if (i)
        buf->writeByte(',');
        expToCBuffer(buf, hgs, arg, PREC_assign);
    }
    }
}

/**************************************************
 * Write out argument types to buf.
 */

void argExpTypesToCBuffer(OutBuffer *buf, Expressions *arguments, HdrGenState *hgs)
{
    if (arguments)
    {   OutBuffer argbuf;

    for (size_t i = 0; i < arguments->dim; i++)
    {   Expression *arg = (Expression *)arguments->data[i];

        if (i)
        buf->writeByte(',');