root/branches/dmdfe-2.0/expression.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 <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 *expandVar(int result, VarDeclaration *v);

#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[TOKdotvar] = PREC_primary;
    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;
#if V2
    precedence[TOKdefault] = PREC_primary;
#endif

    // 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[TOKconstruct] = PREC_assign;
    precedence[TOKblit] = 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;
}

/*************************************************************
 * Given var, we need to get the
 * right 'this' pointer if var is in an outer class, but our
 * existing 'this' pointer is in an inner class.
 * Input:
 *  e1  existing 'this'
 *  ad  struct or class we need the correct 'this' for
 *  var the specific member of ad we're accessing
 */

Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad,
    Expression *e1, Declaration *var)
{
    //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars());
 L1:
    Type *t = e1->type->toBasetype();
    //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars());

    /* If e1 is not the 'this' pointer for ad
     */
    if (ad &&
    !(t->ty == Tpointer && t->nextOf()->ty == Tstruct &&
      ((TypeStruct *)t->nextOf())->sym == ad)
    &&
    !(t->ty == Tstruct &&
      ((TypeStruct *)t)->sym == ad)
       )
    {
    ClassDeclaration *cd = ad->isClassDeclaration();
    ClassDeclaration *tcd = t->isClassHandle();

    /* e1 is the right this if ad is a base class of e1
     */
    if (!cd || !tcd ||
        !(tcd == cd || cd->isBaseOf(tcd, NULL))
       )
    {
        /* Only classes can be inner classes with an 'outer'
         * member pointing to the enclosing class instance
         */
        if (tcd && tcd->isNested())
        {   /* e1 is the 'this' pointer for an inner class: tcd.
         * Rewrite it as the 'this' pointer for the outer class.
         */

        e1 = new DotVarExp(loc, e1, tcd->vthis);
        e1->type = tcd->vthis->type;
        // Do not call checkNestedRef()
        //e1 = e1->semantic(sc);

        // Skip up over nested functions, and get the enclosing
        // class type.
        int n = 0;
        Dsymbol *s;
        for (s = tcd->toParent();
             s && s->isFuncDeclaration();
             s = s->toParent())
        {   FuncDeclaration *f = s->isFuncDeclaration();
            if (f->vthis)
            {
            //printf("rewriting e1 to %s's this\n", f->toChars());
            n++;
            e1 = new VarExp(loc, f->vthis);
            }
        }
        if (s && s->isClassDeclaration())
        {   e1->type = s->isClassDeclaration()->type;
            if (n > 1)
            e1 = e1->semantic(sc);
        }
        else
            e1 = e1->semantic(sc);
        goto L1;
        }
        /* Can't find a path from e1 to ad
         */
        e1->error("this for %s needs to be type %s not type %s",
        var->toChars(), ad->toChars(), t->toChars());
    }
    }
    return e1;
}

/*****************************************
 * 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->op == TOKoverloadset)
    {
        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;
    }
    }
}


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

#if V2
int arrayExpressionCanThrow(Expressions *exps)
{
    if (exps)
    {
    for (size_t i = 0; i < exps->dim; i++)
    {   Expression *e = (Expression *)exps->data[i];
        if (e && e->canThrow())
        return 1;
    }
    }
    return 0;
}
#endif

/****************************************
 * 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
    }
    }
}

/*********************************************
 * Call copy constructor for struct value argument.
 */
#if V2
Expression *callCpCtor(Loc loc, Scope *sc, Expression *e)
{
    Type *tb = e->type->toBasetype();
    assert(tb->ty == Tstruct);
    StructDeclaration *sd = ((TypeStruct *)tb)->sym;
    if (sd->cpctor)
    {
    /* Create a variable tmp, and replace the argument e with:
     *  (tmp = e),tmp
     * and let AssignExp() handle the construction.
     * This is not the most efficent, ideally tmp would be constructed
     * directly onto the stack.
     */
    Identifier *idtmp = Lexer::uniqueId("__tmp");
    VarDeclaration *tmp = new VarDeclaration(loc, tb, idtmp, new ExpInitializer(0, e));
    Expression *ae = new DeclarationExp(loc, tmp);
    e = new CommaExp(loc, ae, new VarExp(loc, tmp));
    e = e->semantic(sc);
    }
    return e;
}
#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
 *  5. call copy constructor for struct value arguments
 */

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

    //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)

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

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

    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;
#if V2
        if (arg->op == TOKdefault)
        {   DefaultInitExp *de = (DefaultInitExp *)arg;
            arg = de->resolve(loc, sc);
        }
        else
#endif
            arg = arg->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
            Identifier *id = Lexer::uniqueId("__arrayArg");
            Type *t = new TypeSArray(((TypeArray *)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 && !((TypeArray *)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));
                AssignExp *ae = new AssignExp(loc, e, a);
                ae->op = TOKconstruct;
                if (c)
                c = new CommaExp(loc, c, ae);
                else
                c = ae;
            }
            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,