/*
 * Copyright 2008 Jacek Caban for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "config.h"
#include "wine/port.h"

#include <math.h>

#include "jscript.h"
#include "engine.h"

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(jscript);

#define EXPR_NOVAL   0x0001
#define EXPR_NEWREF  0x0002
#define EXPR_STRREF  0x0004

static inline HRESULT stat_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
{
    return stat->eval(ctx, stat, rt, ret);
}

static inline HRESULT expr_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    return _expr->eval(ctx, _expr, flags, ei, ret);
}

static void exprval_release(exprval_t *val)
{
    switch(val->type) {
    case EXPRVAL_VARIANT:
        if(V_VT(&val->u.var) != VT_EMPTY)
            VariantClear(&val->u.var);
        return;
    case EXPRVAL_IDREF:
        if(val->u.idref.disp)
            IDispatch_Release(val->u.idref.disp);
        return;
    case EXPRVAL_NAMEREF:
        if(val->u.nameref.disp)
            IDispatch_Release(val->u.nameref.disp);
        SysFreeString(val->u.nameref.name);
        return;
    case EXPRVAL_INVALID:
        SysFreeString(val->u.identifier);
    }
}

/* ECMA-262 3rd Edition    8.7.1 */
static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
{
    V_VT(ret) = VT_EMPTY;

    switch(val->type) {
    case EXPRVAL_VARIANT:
        return VariantCopy(ret, &val->u.var);
    case EXPRVAL_IDREF:
        if(!val->u.idref.disp) {
            FIXME("throw ReferenceError\n");
            return E_FAIL;
        }

        return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
    case EXPRVAL_NAMEREF:
        break;
    case EXPRVAL_INVALID:
        return throw_type_error(ctx, ei, IDS_UNDEFINED, val->u.identifier);
    }

    ERR("type %d\n", val->type);
    return E_FAIL;
}

static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
{
    if(val->type == EXPRVAL_VARIANT) {
        *ret = val->u.var;
        V_VT(&val->u.var) = VT_EMPTY;
        return S_OK;
    }

    return exprval_value(ctx, val, ei, ret);
}

static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
{
    if(exprval->type != EXPRVAL_VARIANT) {
        VARIANT val;
        HRESULT hres;

        hres = exprval_to_value(ctx, exprval, ei, &val);
        if(FAILED(hres))
            return hres;

        hres = to_boolean(&val, b);
        VariantClear(&val);
        return hres;
    }

    return to_boolean(&exprval->u.var, b);
}

static void exprval_init(exprval_t *val)
{
    val->type = EXPRVAL_VARIANT;
    V_VT(&val->u.var) = VT_EMPTY;
}

static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
{
    val->type = EXPRVAL_IDREF;
    val->u.idref.disp = disp;
    val->u.idref.id = id;

    if(disp)
        IDispatch_AddRef(disp);
}

HRESULT scope_push(scope_chain_t *scope, DispatchEx *obj, scope_chain_t **ret)
{
    scope_chain_t *new_scope;

    new_scope = heap_alloc(sizeof(scope_chain_t));
    if(!new_scope)
        return E_OUTOFMEMORY;

    new_scope->ref = 1;

    IDispatchEx_AddRef(_IDispatchEx_(obj));
    new_scope->obj = obj;

    if(scope) {
        scope_addref(scope);
        new_scope->next = scope;
    }else {
        new_scope->next = NULL;
    }

    *ret = new_scope;
    return S_OK;
}

static void scope_pop(scope_chain_t **scope)
{
    scope_chain_t *tmp;

    tmp = *scope;
    *scope = tmp->next;
    scope_release(tmp);
}

void scope_release(scope_chain_t *scope)
{
    if(--scope->ref)
        return;

    if(scope->next)
        scope_release(scope->next);

    jsdisp_release(scope->obj);
    heap_free(scope);
}

HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, DispatchEx *var_disp,
        scope_chain_t *scope, exec_ctx_t **ret)
{
    exec_ctx_t *ctx;

    ctx = heap_alloc_zero(sizeof(exec_ctx_t));
    if(!ctx)
        return E_OUTOFMEMORY;

    ctx->ref = 1;

    if(this_obj)
        ctx->this_obj = this_obj;
    else if(script_ctx->host_global)
        ctx->this_obj = script_ctx->host_global;
    else
        ctx->this_obj = (IDispatch*)_IDispatchEx_(script_ctx->global);
    IDispatch_AddRef(ctx->this_obj);

    IDispatchEx_AddRef(_IDispatchEx_(var_disp));
    ctx->var_disp = var_disp;

    if(scope) {
        scope_addref(scope);
        ctx->scope_chain = scope;
    }

    *ret = ctx;
    return S_OK;
}

void exec_release(exec_ctx_t *ctx)
{
    if(--ctx->ref)
        return;

    if(ctx->scope_chain)
        scope_release(ctx->scope_chain);
    if(ctx->var_disp)
        jsdisp_release(ctx->var_disp);
    if(ctx->this_obj)
        IDispatch_Release(ctx->this_obj);
    heap_free(ctx);
}

static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
{
    IDispatchEx *dispex;
    HRESULT hres;

    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
    if(FAILED(hres)) {
        TRACE("unsing IDispatch\n");

        *id = 0;
        return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
    }

    *id = 0;
    hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
    IDispatchEx_Release(dispex);
    return hres;
}

/* ECMA-262 3rd Edition    8.7.2 */
static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
{
    if(ref->type != EXPRVAL_IDREF)
        return throw_reference_error(ctx, ei, IDS_ILLEGAL_ASSIGN, NULL);

    return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
}

static inline BOOL is_null(const VARIANT *v)
{
    return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
}

static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
{
    IObjectIdentity *identity;
    IUnknown *unk1, *unk2;
    HRESULT hres;

    if(disp1 == disp2) {
        *ret = TRUE;
        return S_OK;
    }

    if(!disp1 || !disp2) {
        *ret = FALSE;
        return S_OK;
    }

    hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
    if(FAILED(hres))
        return hres;

    hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
    if(FAILED(hres)) {
        IUnknown_Release(unk1);
        return hres;
    }

    if(unk1 == unk2) {
        *ret = TRUE;
    }else {
        hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
        if(SUCCEEDED(hres)) {
            hres = IObjectIdentity_IsEqualObject(identity, unk2);
            IObjectIdentity_Release(identity);
            *ret = hres == S_OK;
        }else {
            *ret = FALSE;
        }
    }

    IUnknown_Release(unk1);
    IUnknown_Release(unk2);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.9.6 */
static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
{
    TRACE("\n");

    if(V_VT(lval) != V_VT(rval)) {
        if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
            *ret = num_val(lval) == num_val(rval);
        else if(is_null(lval))
            *ret = is_null(rval);
        else
            *ret = FALSE;
        return S_OK;
    }

    switch(V_VT(lval)) {
    case VT_EMPTY:
    case VT_NULL:
        *ret = VARIANT_TRUE;
        break;
    case VT_I4:
        *ret = V_I4(lval) == V_I4(rval);
        break;
    case VT_R8:
        *ret = V_R8(lval) == V_R8(rval);
        break;
    case VT_BSTR:
        if(!V_BSTR(lval))
            *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
        else if(!V_BSTR(rval))
            *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
        else
            *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
        break;
    case VT_DISPATCH:
        return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
    case VT_BOOL:
        *ret = !V_BOOL(lval) == !V_BOOL(rval);
        break;
    default:
        FIXME("unimplemented vt %d\n", V_VT(lval));
        return E_NOTIMPL;
    }

    return S_OK;
}

static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
{
    switch(literal->type) {
    case LT_NULL:
        V_VT(v) = VT_NULL;
        break;
    case LT_INT:
        V_VT(v) = VT_I4;
        V_I4(v) = literal->u.lval;
        break;
    case LT_DOUBLE:
        V_VT(v) = VT_R8;
        V_R8(v) = literal->u.dval;
        break;
    case LT_STRING: {
        BSTR str = SysAllocString(literal->u.wstr);
        if(!str)
            return E_OUTOFMEMORY;

        V_VT(v) = VT_BSTR;
        V_BSTR(v) = str;
        break;
    }
    case LT_BOOL:
        V_VT(v) = VT_BOOL;
        V_BOOL(v) = literal->u.bval;
        break;
    case LT_REGEXP: {
        DispatchEx *regexp;
        HRESULT hres;

        hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
                             literal->u.regexp.flags, &regexp);
        if(FAILED(hres))
            return hres;

        V_VT(v) = VT_DISPATCH;
        V_DISPATCH(v) = (IDispatch*)_IDispatchEx_(regexp);
    }
    }

    return S_OK;
}

static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
{
    named_item_t *item;
    DISPID id;
    HRESULT hres;

    for(item = ctx->named_items; item; item = item->next) {
        if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
            hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
            if(SUCCEEDED(hres)) {
                if(ret)
                    exprval_set_idref(ret, item->disp, id);
                return TRUE;
            }
        }
    }

    return FALSE;
}

HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, exec_type_t exec_type,
        jsexcept_t *ei, VARIANT *retv)
{
    script_ctx_t *script = parser->script;
    function_declaration_t *func;
    parser_ctx_t *prev_parser;
    var_list_t *var;
    VARIANT val, tmp;
    statement_t *stat;
    exec_ctx_t *prev_ctx;
    return_type_t rt;
    HRESULT hres = S_OK;

    for(func = source->functions; func; func = func->next) {
        DispatchEx *func_obj;
        VARIANT var;

        hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
                ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
        if(FAILED(hres))
            return hres;

        V_VT(&var) = VT_DISPATCH;
        V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(func_obj);
        hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
        jsdisp_release(func_obj);
        if(FAILED(hres))
            return hres;
    }

    for(var = source->variables; var; var = var->next) {
        DISPID id = 0;
        BSTR name;

        name = SysAllocString(var->identifier);
        if(!name)
            return E_OUTOFMEMORY;

        if(!lookup_global_members(parser->script, name, NULL))
            hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
        SysFreeString(name);
        if(FAILED(hres))
            return hres;
    }

    prev_ctx = script->exec_ctx;
    script->exec_ctx = ctx;

    prev_parser = ctx->parser;
    ctx->parser = parser;

    V_VT(&val) = VT_EMPTY;
    memset(&rt, 0, sizeof(rt));
    rt.type = RT_NORMAL;

    for(stat = source->statement; stat; stat = stat->next) {
        hres = stat_eval(ctx, stat, &rt, &tmp);
        if(FAILED(hres))
            break;

        VariantClear(&val);
        val = tmp;
        if(rt.type != RT_NORMAL)
            break;
    }

    script->exec_ctx = prev_ctx;
    ctx->parser = prev_parser;

    if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
        FIXME("wrong rt %d\n", rt.type);
        hres = E_FAIL;
    }

    *ei = rt.ei;
    if(FAILED(hres)) {
        VariantClear(&val);
        return hres;
    }

    if(retv && (exec_type == EXECT_EVAL || rt.type == RT_RETURN))
        *retv = val;
    else {
        if (retv) {
            VariantInit(retv);
        }
        VariantClear(&val);
    }
    return S_OK;
}

/* ECMA-262 3rd Edition    10.1.4 */
static HRESULT identifier_eval(exec_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    scope_chain_t *scope;
    named_item_t *item;
    DISPID id = 0;
    HRESULT hres;

    TRACE("%s\n", debugstr_w(identifier));

    for(scope = ctx->scope_chain; scope; scope = scope->next) {
        hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
        if(SUCCEEDED(hres))
            break;
    }

    if(scope) {
        exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(scope->obj), id);
        return S_OK;
    }

    hres = jsdisp_get_id(ctx->parser->script->global, identifier, 0, &id);
    if(SUCCEEDED(hres)) {
        exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->global), id);
        return S_OK;
    }

    for(item = ctx->parser->script->named_items; item; item = item->next) {
        if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
            if(!item->disp) {
                IUnknown *unk;

                if(!ctx->parser->script->site)
                    break;

                hres = IActiveScriptSite_GetItemInfo(ctx->parser->script->site, identifier,
                                                     SCRIPTINFO_IUNKNOWN, &unk, NULL);
                if(FAILED(hres)) {
                    WARN("GetItemInfo failed: %08x\n", hres);
                    break;
                }

                hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
                IUnknown_Release(unk);
                if(FAILED(hres)) {
                    WARN("object does not implement IDispatch\n");
                    break;
                }
            }

            ret->type = EXPRVAL_VARIANT;
            V_VT(&ret->u.var) = VT_DISPATCH;
            V_DISPATCH(&ret->u.var) = item->disp;
            IDispatch_AddRef(item->disp);
            return S_OK;
        }
    }

    if(lookup_global_members(ctx->parser->script, identifier, ret))
        return S_OK;

    if(flags & EXPR_NEWREF) {
        hres = jsdisp_get_id(ctx->parser->script->global, identifier, fdexNameEnsure, &id);
        if(FAILED(hres))
            return hres;

        exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->global), id);
        return S_OK;
    }

    ret->type = EXPRVAL_INVALID;
    ret->u.identifier = SysAllocString(identifier);
    if(!ret->u.identifier)
        return E_OUTOFMEMORY;

    return S_OK;
}

/* ECMA-262 3rd Edition    12.1 */
HRESULT block_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    block_statement_t *stat = (block_statement_t*)_stat;
    VARIANT val, tmp;
    statement_t *iter;
    HRESULT hres = S_OK;

    TRACE("\n");

    V_VT(&val) = VT_EMPTY;
    for(iter = stat->stat_list; iter; iter = iter->next) {
        hres = stat_eval(ctx, iter, rt, &tmp);
        if(FAILED(hres))
            break;

        VariantClear(&val);
        val = tmp;
        if(rt->type != RT_NORMAL)
            break;
    }

    if(FAILED(hres)) {
        VariantClear(&val);
        return hres;
    }

    *ret = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.2 */
static HRESULT variable_list_eval(exec_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
{
    variable_declaration_t *iter;
    HRESULT hres = S_OK;

    for(iter = var_list; iter; iter = iter->next) {
        exprval_t exprval;
        VARIANT val;

        if(!iter->expr)
            continue;

        hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
        if(FAILED(hres))
            break;

        hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
        exprval_release(&exprval);
        if(FAILED(hres))
            break;

        hres = jsdisp_propput_name(ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
        VariantClear(&val);
        if(FAILED(hres))
            break;
    }

    return hres;
}

/* ECMA-262 3rd Edition    12.2 */
HRESULT var_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    var_statement_t *stat = (var_statement_t*)_stat;
    HRESULT hres;

    TRACE("\n");

    hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
    if(FAILED(hres))
        return hres;

    V_VT(ret) = VT_EMPTY;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.3 */
HRESULT empty_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
{
    TRACE("\n");

    V_VT(ret) = VT_EMPTY;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.4 */
HRESULT expression_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    expression_statement_t *stat = (expression_statement_t*)_stat;
    exprval_t exprval;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    *ret = val;
    TRACE("= %s\n", debugstr_variant(ret));
    return S_OK;
}

/* ECMA-262 3rd Edition    12.5 */
HRESULT if_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    if_statement_t *stat = (if_statement_t*)_stat;
    exprval_t exprval;
    VARIANT_BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_boolean(ctx->parser->script, &exprval, &rt->ei, &b);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    if(b)
        hres = stat_eval(ctx, stat->if_stat, rt, ret);
    else if(stat->else_stat)
        hres = stat_eval(ctx, stat->else_stat, rt, ret);
    else
        V_VT(ret) = VT_EMPTY;

    return hres;
}

/* ECMA-262 3rd Edition    12.6.2 */
HRESULT while_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    while_statement_t *stat = (while_statement_t*)_stat;
    exprval_t exprval;
    VARIANT val, tmp;
    VARIANT_BOOL b;
    BOOL test_expr;
    HRESULT hres;

    TRACE("\n");

    V_VT(&val) = VT_EMPTY;
    test_expr = !stat->do_while;

    while(1) {
        if(test_expr) {
            hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
            if(FAILED(hres))
                break;

            hres = exprval_to_boolean(ctx->parser->script, &exprval, &rt->ei, &b);
            exprval_release(&exprval);
            if(FAILED(hres) || !b)
                break;
        }else {
            test_expr = TRUE;
        }

        hres = stat_eval(ctx, stat->statement, rt, &tmp);
        if(FAILED(hres))
            break;

        VariantClear(&val);
        val = tmp;

        if(rt->type == RT_CONTINUE)
            rt->type = RT_NORMAL;
        if(rt->type != RT_NORMAL)
            break;
    }

    if(FAILED(hres)) {
        VariantClear(&val);
        return hres;
    }

    if(rt->type == RT_BREAK)
        rt->type = RT_NORMAL;

    *ret = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.6.3 */
HRESULT for_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    for_statement_t *stat = (for_statement_t*)_stat;
    VARIANT val, tmp, retv;
    exprval_t exprval;
    VARIANT_BOOL b;
    HRESULT hres;

    TRACE("\n");

    if(stat->variable_list) {
        hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
        if(FAILED(hres))
            return hres;
    }else if(stat->begin_expr) {
        hres = expr_eval(ctx, stat->begin_expr, EXPR_NEWREF, &rt->ei, &exprval);
        if(FAILED(hres))
            return hres;

        hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
        exprval_release(&exprval);
        if(FAILED(hres))
            return hres;

        VariantClear(&val);
    }

    V_VT(&retv) = VT_EMPTY;

    while(1) {
        if(stat->expr) {
            hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
            if(FAILED(hres))
                break;

            hres = exprval_to_boolean(ctx->parser->script, &exprval, &rt->ei, &b);
            exprval_release(&exprval);
            if(FAILED(hres) || !b)
                break;
        }

        hres = stat_eval(ctx, stat->statement, rt, &tmp);
        if(FAILED(hres))
            break;

        VariantClear(&retv);
        retv = tmp;

        if(rt->type == RT_CONTINUE)
            rt->type = RT_NORMAL;
        else if(rt->type != RT_NORMAL)
            break;

        if(stat->end_expr) {
            hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
            if(FAILED(hres))
                break;

            hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
            exprval_release(&exprval);
            if(FAILED(hres))
                break;

            VariantClear(&val);
        }
    }

    if(FAILED(hres)) {
        VariantClear(&retv);
        return hres;
    }

    if(rt->type == RT_BREAK)
        rt->type = RT_NORMAL;

    *ret = retv;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.6.4 */
HRESULT forin_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    forin_statement_t *stat = (forin_statement_t*)_stat;
    VARIANT val, name, retv, tmp;
    DISPID id = DISPID_STARTENUM;
    BSTR str, identifier = NULL;
    IDispatchEx *in_obj;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    if(stat->variable) {
        hres = variable_list_eval(ctx, stat->variable, &rt->ei);
        if(FAILED(hres))
            return hres;
    }

    hres = expr_eval(ctx, stat->in_expr, EXPR_NEWREF, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    if(V_VT(&val) != VT_DISPATCH) {
        TRACE("in vt %d\n", V_VT(&val));
        VariantClear(&val);
        V_VT(ret) = VT_EMPTY;
        return S_OK;
    }

    hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
    IDispatch_Release(V_DISPATCH(&val));
    if(FAILED(hres)) {
        FIXME("Object doesn't support IDispatchEx\n");
        return E_NOTIMPL;
    }

    V_VT(&retv) = VT_EMPTY;

    if(stat->variable)
        identifier = SysAllocString(stat->variable->identifier);

    while(1) {
        hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
        if(FAILED(hres) || hres == S_FALSE)
            break;

        hres = IDispatchEx_GetMemberName(in_obj, id, &str);
        if(FAILED(hres))
            break;

        TRACE("iter %s\n", debugstr_w(str));

        if(stat->variable)
            hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
        else
            hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
        if(SUCCEEDED(hres)) {
            V_VT(&name) = VT_BSTR;
            V_BSTR(&name) = str;
            hres = put_value(ctx->parser->script, &exprval, &name, &rt->ei);
            exprval_release(&exprval);
        }
        SysFreeString(str);
        if(FAILED(hres))
            break;

        hres = stat_eval(ctx, stat->statement, rt, &tmp);
        if(FAILED(hres))
            break;

        VariantClear(&retv);
        retv = tmp;

        if(rt->type == RT_CONTINUE)
            rt->type = RT_NORMAL;
        else if(rt->type != RT_NORMAL)
            break;
    }

    SysFreeString(identifier);
    IDispatchEx_Release(in_obj);
    if(FAILED(hres)) {
        VariantClear(&retv);
        return hres;
    }

    if(rt->type == RT_BREAK)
        rt->type = RT_NORMAL;

    *ret = retv;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.7 */
HRESULT continue_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    branch_statement_t *stat = (branch_statement_t*)_stat;

    TRACE("\n");

    if(stat->identifier) {
        FIXME("indentifier not implemented\n");
        return E_NOTIMPL;
    }

    rt->type = RT_CONTINUE;
    V_VT(ret) = VT_EMPTY;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.8 */
HRESULT break_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    branch_statement_t *stat = (branch_statement_t*)_stat;

    TRACE("\n");

    if(stat->identifier) {
        FIXME("indentifier not implemented\n");
        return E_NOTIMPL;
    }

    rt->type = RT_BREAK;
    V_VT(ret) = VT_EMPTY;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.9 */
HRESULT return_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    expression_statement_t *stat = (expression_statement_t*)_stat;
    HRESULT hres;

    TRACE("\n");

    if(stat->expr) {
        exprval_t exprval;

        hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
        if(FAILED(hres))
            return hres;

        hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, ret);
        exprval_release(&exprval);
        if(FAILED(hres))
            return hres;
    }else {
        V_VT(ret) = VT_EMPTY;
    }

    TRACE("= %s\n", debugstr_variant(ret));
    rt->type = RT_RETURN;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.10 */
HRESULT with_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    with_statement_t *stat = (with_statement_t*)_stat;
    exprval_t exprval;
    IDispatch *disp;
    DispatchEx *obj;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_object(ctx->parser->script, &val, &disp);
    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    obj = iface_to_jsdisp((IUnknown*)disp);
    IDispatch_Release(disp);
    if(!obj) {
        FIXME("disp id not jsdisp\n");
        return E_NOTIMPL;
    }

    hres = scope_push(ctx->scope_chain, obj, &ctx->scope_chain);
    jsdisp_release(obj);
    if(FAILED(hres))
        return hres;

    hres = stat_eval(ctx, stat->statement, rt, ret);

    scope_pop(&ctx->scope_chain);
    return hres;
}

/* ECMA-262 3rd Edition    12.12 */
HRESULT labelled_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
{
    FIXME("\n");
    return E_NOTIMPL;
}

/* ECMA-262 3rd Edition    12.13 */
HRESULT switch_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    switch_statement_t *stat = (switch_statement_t*)_stat;
    case_clausule_t *iter, *default_clausule = NULL;
    statement_t *stat_iter;
    VARIANT val, cval;
    exprval_t exprval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    for(iter = stat->case_list; iter; iter = iter->next) {
        if(!iter->expr) {
            default_clausule = iter;
            continue;
        }

        hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
        if(FAILED(hres))
            break;

        hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &cval);
        exprval_release(&exprval);
        if(FAILED(hres))
            break;

        hres = equal2_values(&val, &cval, &b);
        VariantClear(&cval);
        if(FAILED(hres) || b)
            break;
    }

    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    if(!iter)
        iter = default_clausule;

    V_VT(&val) = VT_EMPTY;
    if(iter) {
        VARIANT tmp;

        for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
            hres = stat_eval(ctx, stat_iter, rt, &tmp);
            if(FAILED(hres))
                break;

            VariantClear(&val);
            val = tmp;

            if(rt->type != RT_NORMAL)
                break;
        }
    }

    if(FAILED(hres)) {
        VariantClear(&val);
        return hres;
    }

    if(rt->type == RT_BREAK)
        rt->type = RT_NORMAL;

    *ret = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.13 */
HRESULT throw_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    expression_statement_t *stat = (expression_statement_t*)_stat;
    exprval_t exprval;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    rt->ei.var = val;
    return DISP_E_EXCEPTION;
}

/* ECMA-262 3rd Edition    12.14 */
static HRESULT catch_eval(exec_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
{
    DispatchEx *var_disp;
    VARIANT ex, val;
    HRESULT hres;

    ex = rt->ei.var;
    memset(&rt->ei, 0, sizeof(jsexcept_t));

    hres = create_dispex(ctx->parser->script, NULL, NULL, &var_disp);
    if(SUCCEEDED(hres)) {
        hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
        if(SUCCEEDED(hres)) {
            hres = scope_push(ctx->scope_chain, var_disp, &ctx->scope_chain);
            if(SUCCEEDED(hres)) {
                hres = stat_eval(ctx, block->statement, rt, &val);
                scope_pop(&ctx->scope_chain);
            }
        }

        jsdisp_release(var_disp);
    }

    VariantClear(&ex);
    if(FAILED(hres))
        return hres;

    *ret = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    12.14 */
HRESULT try_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
{
    try_statement_t *stat = (try_statement_t*)_stat;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = stat_eval(ctx, stat->try_statement, rt, &val);
    if(FAILED(hres)) {
        TRACE("EXCEPTION\n");
        if(!stat->catch_block)
            return hres;

        hres = catch_eval(ctx, stat->catch_block, rt, &val);
        if(FAILED(hres))
            return hres;
    }

    if(stat->finally_statement) {
        VariantClear(&val);
        hres = stat_eval(ctx, stat->finally_statement, rt, &val);
        if(FAILED(hres))
            return hres;
    }

    *ret = val;
    return S_OK;
}

static HRESULT return_bool(exprval_t *ret, DWORD b)
{
    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_BOOL;
    V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;

    return S_OK;
}

static HRESULT get_binary_expr_values(exec_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
{
    exprval_t exprval;
    HRESULT hres;

    hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, lval);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
    if(SUCCEEDED(hres)) {
        hres = exprval_to_value(ctx->parser->script, &exprval, ei, rval);
        exprval_release(&exprval);
    }

    if(FAILED(hres)) {
        VariantClear(lval);
        return hres;
    }

    return S_OK;
}

typedef HRESULT (*oper_t)(exec_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);

static HRESULT binary_expr_eval(exec_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
        exprval_t *ret)
{
    VARIANT lval, rval, retv;
    HRESULT hres;

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = oper(ctx, &lval, &rval, ei, &retv);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = retv;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.13.2 */
static HRESULT assign_oper_eval(exec_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
                                jsexcept_t *ei, exprval_t *ret)
{
    VARIANT retv, lval, rval;
    exprval_t exprval, exprvalr;
    HRESULT hres;

    hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_value(ctx->parser->script, &exprval, ei, &lval);
    if(SUCCEEDED(hres)) {
        hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
        if(SUCCEEDED(hres)) {
            hres = exprval_value(ctx->parser->script, &exprvalr, ei, &rval);
            exprval_release(&exprvalr);
        }
        if(SUCCEEDED(hres)) {
            hres = oper(ctx, &lval, &rval, ei, &retv);
            VariantClear(&rval);
        }
        VariantClear(&lval);
    }

    if(SUCCEEDED(hres)) {
        hres = put_value(ctx->parser->script, &exprval, &retv, ei);
        if(FAILED(hres))
            VariantClear(&retv);
    }
    exprval_release(&exprval);

    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = retv;
    return S_OK;
}

/* ECMA-262 3rd Edition    13 */
HRESULT function_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    function_expression_t *expr = (function_expression_t*)_expr;
    VARIANT var;
    HRESULT hres;

    TRACE("\n");

    if(expr->identifier) {
        hres = jsdisp_propget_name(ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
        if(FAILED(hres))
            return hres;
    }else {
        DispatchEx *dispex;

        hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain,
                expr->src_str, expr->src_len, &dispex);
        if(FAILED(hres))
            return hres;

        V_VT(&var) = VT_DISPATCH;
        V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
    }

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = var;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.12 */
HRESULT conditional_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    conditional_expression_t *expr = (conditional_expression_t*)_expr;
    exprval_t exprval;
    VARIANT_BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    return expr_eval(ctx, b ? expr->true_expression : expr->false_expression, flags, ei, ret);
}

/* ECMA-262 3rd Edition    11.2.1 */
HRESULT array_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    array_expression_t *expr = (array_expression_t*)_expr;
    exprval_t exprval;
    VARIANT member, val;
    DISPID id;
    BSTR str;
    IDispatch *obj = NULL;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->member_expr, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(SUCCEEDED(hres)) {
        hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
        exprval_release(&exprval);
    }

    if(SUCCEEDED(hres)) {
        hres = to_object(ctx->parser->script, &member, &obj);
        if(FAILED(hres))
            VariantClear(&val);
    }
    VariantClear(&member);
    if(SUCCEEDED(hres)) {
        hres = to_string(ctx->parser->script, &val, ei, &str);
        VariantClear(&val);
        if(SUCCEEDED(hres)) {
            if(flags & EXPR_STRREF) {
                ret->type = EXPRVAL_NAMEREF;
                ret->u.nameref.disp = obj;
                ret->u.nameref.name = str;
                return S_OK;
            }

            hres = disp_get_id(ctx->parser->script, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
            SysFreeString(str);
        }

        if(SUCCEEDED(hres)) {
            exprval_set_idref(ret, obj, id);
        }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
            exprval_init(ret);
            hres = S_OK;
        }

        IDispatch_Release(obj);
    }

    return hres;
}

/* ECMA-262 3rd Edition    11.2.1 */
HRESULT member_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    member_expression_t *expr = (member_expression_t*)_expr;
    IDispatch *obj = NULL;
    exprval_t exprval;
    VARIANT member;
    DISPID id;
    BSTR str;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_object(ctx->parser->script, &member, &obj);
    VariantClear(&member);
    if(FAILED(hres))
        return hres;

    str = SysAllocString(expr->identifier);
    if(flags & EXPR_STRREF) {
        ret->type = EXPRVAL_NAMEREF;
        ret->u.nameref.disp = obj;
        ret->u.nameref.name = str;
        return S_OK;
    }

    hres = disp_get_id(ctx->parser->script, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
    SysFreeString(str);
    if(SUCCEEDED(hres)) {
        exprval_set_idref(ret, obj, id);
    }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
        exprval_init(ret);
        hres = S_OK;
    }

    IDispatch_Release(obj);
    return hres;
}

static void free_dp(DISPPARAMS *dp)
{
    DWORD i;

    for(i=0; i < dp->cArgs; i++)
        VariantClear(dp->rgvarg+i);
    heap_free(dp->rgvarg);
}

static HRESULT args_to_param(exec_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
{
    VARIANTARG *vargs;
    exprval_t exprval;
    argument_t *iter;
    DWORD cnt = 0, i;
    HRESULT hres = S_OK;

    memset(dp, 0, sizeof(*dp));
    if(!args)
        return S_OK;

    for(iter = args; iter; iter = iter->next)
        cnt++;

    vargs = heap_alloc_zero(cnt * sizeof(*vargs));
    if(!vargs)
        return E_OUTOFMEMORY;

    for(i = cnt, iter = args; iter; iter = iter->next) {
        hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
        if(FAILED(hres))
            break;

        hres = exprval_to_value(ctx->parser->script, &exprval, ei, vargs + (--i));
        exprval_release(&exprval);
        if(FAILED(hres))
            break;
    }

    if(FAILED(hres)) {
        free_dp(dp);
        return hres;
    }

    dp->rgvarg = vargs;
    dp->cArgs = cnt;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.2.2 */
HRESULT new_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    call_expression_t *expr = (call_expression_t*)_expr;
    exprval_t exprval;
    VARIANT constr, var;
    DISPPARAMS dp;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = args_to_param(ctx, expr->argument_list, ei, &dp);
    if(SUCCEEDED(hres))
        hres = exprval_to_value(ctx->parser->script, &exprval, ei, &constr);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    if(V_VT(&constr) != VT_DISPATCH) {
        FIXME("throw TypeError\n");
        VariantClear(&constr);
        return E_FAIL;
    }

    hres = disp_call(ctx->parser->script, V_DISPATCH(&constr), DISPID_VALUE,
                     DISPATCH_CONSTRUCT, &dp, &var, ei, NULL/*FIXME*/);
    IDispatch_Release(V_DISPATCH(&constr));
    free_dp(&dp);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = var;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.2.3 */
HRESULT call_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    call_expression_t *expr = (call_expression_t*)_expr;
    VARIANT var;
    exprval_t exprval;
    DISPPARAMS dp;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = args_to_param(ctx, expr->argument_list, ei, &dp);
    if(SUCCEEDED(hres)) {
        switch(exprval.type) {
        case EXPRVAL_VARIANT:
            if(V_VT(&exprval.u.var) == VT_DISPATCH)
                hres = disp_call(ctx->parser->script, V_DISPATCH(&exprval.u.var), DISPID_VALUE,
                        DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
            else
                hres = throw_type_error(ctx->parser->script, ei, IDS_NO_PROPERTY, NULL);
            break;
        case EXPRVAL_IDREF:
            hres = disp_call(ctx->parser->script, exprval.u.idref.disp, exprval.u.idref.id,
                    DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
            break;
        case EXPRVAL_INVALID:
            hres = throw_type_error(ctx->parser->script, ei, IDS_OBJECT_EXPECTED, NULL);
            break;
        default:
            FIXME("unimplemented type %d\n", exprval.type);
            hres = E_NOTIMPL;
        }

        free_dp(&dp);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    if(flags & EXPR_NOVAL) {
        V_VT(&ret->u.var) = VT_EMPTY;
    }else {
        TRACE("= %s\n", debugstr_variant(&var));
        ret->u.var = var;
    }
    return S_OK;
}

/* ECMA-262 3rd Edition    11.1.1 */
HRESULT this_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    TRACE("\n");

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_DISPATCH;
    V_DISPATCH(&ret->u.var) = ctx->this_obj;
    IDispatch_AddRef(ctx->this_obj);
    return S_OK;
}

/* ECMA-262 3rd Edition    10.1.4 */
HRESULT identifier_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    identifier_expression_t *expr = (identifier_expression_t*)_expr;
    BSTR identifier;
    HRESULT hres;

    TRACE("\n");

    identifier = SysAllocString(expr->identifier);
    if(!identifier)
        return E_OUTOFMEMORY;

    hres = identifier_eval(ctx, identifier, flags, ei, ret);

    SysFreeString(identifier);
    return hres;
}

/* ECMA-262 3rd Edition    7.8 */
HRESULT literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    literal_expression_t *expr = (literal_expression_t*)_expr;
    VARIANT var;
    HRESULT hres;

    TRACE("\n");

    hres = literal_to_var(ctx->parser->script, expr->literal, &var);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = var;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.1.4 */
HRESULT array_literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
    DWORD length = 0, i = 0;
    array_element_t *elem;
    DispatchEx *array;
    exprval_t exprval;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    for(elem = expr->element_list; elem; elem = elem->next)
        length += elem->elision+1;
    length += expr->length;

    hres = create_array(ctx->parser->script, length, &array);
    if(FAILED(hres))
        return hres;

    for(elem = expr->element_list; elem; elem = elem->next) {
        i += elem->elision;

        hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
        if(FAILED(hres))
            break;

        hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
        exprval_release(&exprval);
        if(FAILED(hres))
            break;

        hres = jsdisp_propput_idx(array, i, &val, ei, NULL/*FIXME*/);
        VariantClear(&val);
        if(FAILED(hres))
            break;

        i++;
    }

    if(FAILED(hres)) {
        jsdisp_release(array);
        return hres;
    }

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_DISPATCH;
    V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(array);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.1.5 */
HRESULT property_value_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    property_value_expression_t *expr = (property_value_expression_t*)_expr;
    VARIANT val, tmp;
    DispatchEx *obj;
    prop_val_t *iter;
    exprval_t exprval;
    BSTR name;
    HRESULT hres;

    TRACE("\n");

    hres = create_object(ctx->parser->script, NULL, &obj);
    if(FAILED(hres))
        return hres;

    for(iter = expr->property_list; iter; iter = iter->next) {
        hres = literal_to_var(ctx->parser->script, iter->name, &tmp);
        if(FAILED(hres))
            break;

        hres = to_string(ctx->parser->script, &tmp, ei, &name);
        VariantClear(&tmp);
        if(FAILED(hres))
            break;

        hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
        if(SUCCEEDED(hres)) {
            hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
            exprval_release(&exprval);
            if(SUCCEEDED(hres)) {
                hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
                VariantClear(&val);
            }
        }

        SysFreeString(name);
        if(FAILED(hres))
            break;
    }

    if(FAILED(hres)) {
        jsdisp_release(obj);
        return hres;
    }

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_DISPATCH;
    V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(obj);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.14 */
HRESULT comma_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT lval, rval;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    VariantClear(&lval);

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = rval;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.11 */
HRESULT logical_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT_BOOL b;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_boolean(&val, &b);
    if(SUCCEEDED(hres) && b) {
        ret->type = EXPRVAL_VARIANT;
        ret->u.var = val;
        return S_OK;
    }

    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.11 */
HRESULT logical_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT_BOOL b;
    VARIANT val;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_boolean(&val, &b);
    if(SUCCEEDED(hres) && !b) {
        ret->type = EXPRVAL_VARIANT;
        ret->u.var = val;
        return S_OK;
    }

    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.10 */
static HRESULT bitor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    INT li, ri;
    HRESULT hres;

    hres = to_int32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_int32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li|ri;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.10 */
HRESULT binary_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, bitor_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.10 */
static HRESULT xor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    INT li, ri;
    HRESULT hres;

    hres = to_int32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_int32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li^ri;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.10 */
HRESULT binary_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, xor_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.10 */
static HRESULT bitand_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    INT li, ri;
    HRESULT hres;

    hres = to_int32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_int32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li&ri;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.10 */
HRESULT binary_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.8.6 */
static HRESULT instanceof_eval(exec_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
{
    DispatchEx *obj, *iter, *tmp = NULL;
    VARIANT_BOOL ret = VARIANT_FALSE;
    BOOL b;
    VARIANT var;
    HRESULT hres;

    static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};

    if(V_VT(objv) != VT_DISPATCH) {
        FIXME("throw TypeError\n");
        return E_FAIL;
    }

    obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
    if(!obj) {
        FIXME("throw TypeError\n");
        return E_FAIL;
    }

    if(is_class(obj, JSCLASS_FUNCTION)) {
        hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
    }else {
        FIXME("throw TypeError\n");
        hres = E_FAIL;
    }
    jsdisp_release(obj);
    if(FAILED(hres))
        return hres;

    if(V_VT(&var) == VT_DISPATCH) {
        if(V_VT(inst) == VT_DISPATCH)
            tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
        for(iter = tmp; iter; iter = iter->prototype) {
            hres = disp_cmp(V_DISPATCH(&var), (IDispatch*)_IDispatchEx_(iter), &b);
            if(FAILED(hres))
                break;
            if(b) {
                ret = VARIANT_TRUE;
                break;
            }
        }

        if(tmp)
            jsdisp_release(tmp);
    }else {
        FIXME("prototype is not an object\n");
        hres = E_FAIL;
    }

    VariantClear(&var);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_BOOL;
    V_BOOL(retv) = ret;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.8.6 */
HRESULT instanceof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.8.7 */
static HRESULT in_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *obj, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT_BOOL ret;
    DISPID id;
    BSTR str;
    HRESULT hres;

    if(V_VT(obj) != VT_DISPATCH) {
        FIXME("throw TypeError\n");
        return E_FAIL;
    }

    hres = to_string(ctx->parser->script, lval, ei, &str);
    if(FAILED(hres))
        return hres;

    hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
    SysFreeString(str);
    if(SUCCEEDED(hres))
        ret = VARIANT_TRUE;
    else if(hres == DISP_E_UNKNOWNNAME)
        ret = VARIANT_FALSE;
    else
        return hres;

    V_VT(retv) = VT_BOOL;
    V_BOOL(retv) = ret;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.8.7 */
HRESULT in_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, in_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.6.1 */
static HRESULT add_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT r, l;
    HRESULT hres;

    hres = to_primitive(ctx->parser->script, lval, ei, &l, NO_HINT);
    if(FAILED(hres))
        return hres;

    hres = to_primitive(ctx->parser->script, rval, ei, &r, NO_HINT);
    if(FAILED(hres)) {
        VariantClear(&l);
        return hres;
    }

    if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
        BSTR lstr = NULL, rstr = NULL;

        if(V_VT(&l) == VT_BSTR)
            lstr = V_BSTR(&l);
        else
            hres = to_string(ctx->parser->script, &l, ei, &lstr);

        if(SUCCEEDED(hres)) {
            if(V_VT(&r) == VT_BSTR)
                rstr = V_BSTR(&r);
            else
                hres = to_string(ctx->parser->script, &r, ei, &rstr);
        }

        if(SUCCEEDED(hres)) {
            int len1, len2;

            len1 = SysStringLen(lstr);
            len2 = SysStringLen(rstr);

            V_VT(retv) = VT_BSTR;
            V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
            memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
            memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
        }

        if(V_VT(&l) != VT_BSTR)
            SysFreeString(lstr);
        if(V_VT(&r) != VT_BSTR)
            SysFreeString(rstr);
    }else {
        VARIANT nl, nr;

        hres = to_number(ctx->parser->script, &l, ei, &nl);
        if(SUCCEEDED(hres)) {
            hres = to_number(ctx->parser->script, &r, ei, &nr);
            if(SUCCEEDED(hres))
                num_set_val(retv, num_val(&nl) + num_val(&nr));
        }
    }

    VariantClear(&r);
    VariantClear(&l);
    return hres;
}

/* ECMA-262 3rd Edition    11.6.1 */
HRESULT add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, add_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.6.2 */
static HRESULT sub_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT lnum, rnum;
    HRESULT hres;

    hres = to_number(ctx->parser->script, lval, ei, &lnum);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, rval, ei, &rnum);
    if(FAILED(hres))
        return hres;

    num_set_val(retv, num_val(&lnum) - num_val(&rnum));
    return S_OK;
}

/* ECMA-262 3rd Edition    11.6.2 */
HRESULT sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, sub_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.5.1 */
static HRESULT mul_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT lnum, rnum;
    HRESULT hres;

    hres = to_number(ctx->parser->script, lval, ei, &lnum);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, rval, ei, &rnum);
    if(FAILED(hres))
        return hres;

    num_set_val(retv, num_val(&lnum) * num_val(&rnum));
    return S_OK;
}

/* ECMA-262 3rd Edition    11.5.1 */
HRESULT mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, mul_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.5.2 */
static HRESULT div_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT lnum, rnum;
    HRESULT hres;

    hres = to_number(ctx->parser->script, lval, ei, &lnum);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, rval, ei, &rnum);
    if(FAILED(hres))
        return hres;

    num_set_val(retv, num_val(&lnum) / num_val(&rnum));
    return S_OK;
}

/* ECMA-262 3rd Edition    11.5.2 */
HRESULT div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, div_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.5.3 */
static HRESULT mod_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    VARIANT lnum, rnum;
    HRESULT hres;

    hres = to_number(ctx->parser->script, lval, ei, &lnum);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, rval, ei, &rnum);
    if(FAILED(hres))
        return hres;

    num_set_val(retv, fmod(num_val(&lnum), num_val(&rnum)));
    return S_OK;
}

/* ECMA-262 3rd Edition    11.5.3 */
HRESULT mod_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, mod_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.4.2 */
HRESULT delete_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    VARIANT_BOOL b = VARIANT_FALSE;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_STRREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    switch(exprval.type) {
    case EXPRVAL_IDREF: {
        IDispatchEx *dispex;

        hres = IDispatch_QueryInterface(exprval.u.nameref.disp, &IID_IDispatchEx, (void**)&dispex);
        if(SUCCEEDED(hres)) {
            hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
            b = VARIANT_TRUE;
            IDispatchEx_Release(dispex);
        }
        break;
    }
    case EXPRVAL_NAMEREF: {
        IDispatchEx *dispex;

        hres = IDispatch_QueryInterface(exprval.u.nameref.disp, &IID_IDispatchEx, (void**)&dispex);
        if(SUCCEEDED(hres)) {
            hres = IDispatchEx_DeleteMemberByName(dispex, exprval.u.nameref.name,
                    make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
            b = VARIANT_TRUE;
            IDispatchEx_Release(dispex);
        }
        break;
    }
    default:
        FIXME("unsupported type %d\n", exprval.type);
        hres = E_NOTIMPL;
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.4.2 */
HRESULT void_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT tmp;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &tmp);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    VariantClear(&tmp);

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_EMPTY;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.3 */
static HRESULT typeof_exprval(exec_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
{
    VARIANT val;
    HRESULT hres;

    static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
    static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
    static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
    static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
    static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
    static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};

    if(exprval->type == EXPRVAL_INVALID) {
        *ret = undefinedW;
        return S_OK;
    }

    hres = exprval_to_value(ctx->parser->script, exprval, ei, &val);
    if(FAILED(hres))
        return hres;

    switch(V_VT(&val)) {
    case VT_EMPTY:
        *ret = undefinedW;
        break;
    case VT_NULL:
        *ret = objectW;
        break;
    case VT_BOOL:
        *ret = booleanW;
        break;
    case VT_I4:
    case VT_R8:
        *ret = numberW;
        break;
    case VT_BSTR:
        *ret = stringW;
        break;
    case VT_DISPATCH: {
        DispatchEx *dispex;

        if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
            *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
            jsdisp_release(dispex);
        }else {
            *ret = objectW;
        }
        break;
    }
    default:
        FIXME("unhandled vt %d\n", V_VT(&val));
        hres = E_NOTIMPL;
    }

    VariantClear(&val);
    return S_OK;
}

HRESULT typeof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    const WCHAR *str = NULL;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = typeof_exprval(ctx, &exprval, ei, &str);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_BSTR;
    V_BSTR(&ret->u.var) = SysAllocString(str);
    if(!V_BSTR(&ret->u.var))
        return E_OUTOFMEMORY;

    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.7 */
HRESULT minus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT val, num;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, &val, ei, &num);
    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    num_set_val(&ret->u.var, -num_val(&num));
    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.6 */
HRESULT plus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT val, num;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_number(ctx->parser->script, &val, ei, &num);
    VariantClear(&val);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = num;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.3.1 */
HRESULT post_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    VARIANT val, num;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
    if(SUCCEEDED(hres)) {
        hres = to_number(ctx->parser->script, &val, ei, &num);
        VariantClear(&val);
    }

    if(SUCCEEDED(hres)) {
        VARIANT inc;
        num_set_val(&inc, num_val(&num)+1.0);
        hres = put_value(ctx->parser->script, &exprval, &inc, ei);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = num;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.3.2 */
HRESULT post_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    VARIANT val, num;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
    if(SUCCEEDED(hres)) {
        hres = to_number(ctx->parser->script, &val, ei, &num);
        VariantClear(&val);
    }

    if(SUCCEEDED(hres)) {
        VARIANT dec;
        num_set_val(&dec, num_val(&num)-1.0);
        hres = put_value(ctx->parser->script, &exprval, &dec, ei);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = num;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.4 */
HRESULT pre_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    VARIANT val, num;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
    if(SUCCEEDED(hres)) {
        hres = to_number(ctx->parser->script, &val, ei, &num);
        VariantClear(&val);
    }

    if(SUCCEEDED(hres)) {
        num_set_val(&val, num_val(&num)+1.0);
        hres = put_value(ctx->parser->script, &exprval, &val, ei);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.5 */
HRESULT pre_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    VARIANT val, num;
    exprval_t exprval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
    if(SUCCEEDED(hres)) {
        hres = to_number(ctx->parser->script, &val, ei, &num);
        VariantClear(&val);
    }

    if(SUCCEEDED(hres)) {
        num_set_val(&val, num_val(&num)-1.0);
        hres = put_value(ctx->parser->script, &exprval, &val, ei);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = val;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.9.3 */
static HRESULT equal_values(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
{
    if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
       return equal2_values(lval, rval, ret);

    /* FIXME: NULL disps should be handled in more general way */
    if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
        VARIANT v;
        V_VT(&v) = VT_NULL;
        return equal_values(ctx, &v, rval, ei, ret);
    }

    if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
        VARIANT v;
        V_VT(&v) = VT_NULL;
        return equal_values(ctx, lval, &v, ei, ret);
    }

    if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
       (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
        *ret = TRUE;
        return S_OK;
    }

    if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
        VARIANT v;
        HRESULT hres;

        hres = to_number(ctx->parser->script, lval, ei, &v);
        if(FAILED(hres))
            return hres;

        return equal_values(ctx, &v, rval, ei, ret);
    }

    if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
        VARIANT v;
        HRESULT hres;

        hres = to_number(ctx->parser->script, rval, ei, &v);
        if(FAILED(hres))
            return hres;

        return equal_values(ctx, lval, &v, ei, ret);
    }

    if(V_VT(rval) == VT_BOOL) {
        VARIANT v;

        V_VT(&v) = VT_I4;
        V_I4(&v) = V_BOOL(rval) ? 1 : 0;
        return equal_values(ctx, lval, &v, ei, ret);
    }

    if(V_VT(lval) == VT_BOOL) {
        VARIANT v;

        V_VT(&v) = VT_I4;
        V_I4(&v) = V_BOOL(lval) ? 1 : 0;
        return equal_values(ctx, &v, rval, ei, ret);
    }


    if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
        VARIANT v;
        HRESULT hres;

        hres = to_primitive(ctx->parser->script, rval, ei, &v, NO_HINT);
        if(FAILED(hres))
            return hres;

        hres = equal_values(ctx, lval, &v, ei, ret);

        VariantClear(&v);
        return hres;
    }


    if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
        VARIANT v;
        HRESULT hres;

        hres = to_primitive(ctx->parser->script, lval, ei, &v, NO_HINT);
        if(FAILED(hres))
            return hres;

        hres = equal_values(ctx, &v, rval, ei, ret);

        VariantClear(&v);
        return hres;
    }


    *ret = FALSE;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.9.1 */
HRESULT equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
    if(FAILED(hres))
        return hres;

    hres = equal_values(ctx, &rval, &lval, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.9.4 */
HRESULT equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
    if(FAILED(hres))
        return hres;

    hres = equal2_values(&rval, &lval, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.9.2 */
HRESULT not_equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = equal_values(ctx, &lval, &rval, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, !b);
}

/* ECMA-262 3rd Edition    11.9.5 */
HRESULT not_equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = equal2_values(&lval, &rval, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, !b);
}

/* ECMA-262 3rd Edition    11.8.5 */
static HRESULT less_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
{
    VARIANT l, r, ln, rn;
    HRESULT hres;

    hres = to_primitive(ctx->parser->script, lval, ei, &l, NO_HINT);
    if(FAILED(hres))
        return hres;

    hres = to_primitive(ctx->parser->script, rval, ei, &r, NO_HINT);
    if(FAILED(hres)) {
        VariantClear(&l);
        return hres;
    }

    if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
        *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
        SysFreeString(V_BSTR(&l));
        SysFreeString(V_BSTR(&r));
        return S_OK;
    }

    hres = to_number(ctx->parser->script, &l, ei, &ln);
    VariantClear(&l);
    if(SUCCEEDED(hres))
        hres = to_number(ctx->parser->script, &r, ei, &rn);
    VariantClear(&r);
    if(FAILED(hres))
        return hres;

    if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
        *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
    }else  {
        DOUBLE ld = num_val(&ln);
        DOUBLE rd = num_val(&rn);

        *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
    }

    return S_OK;
}

/* ECMA-262 3rd Edition    11.8.1 */
HRESULT less_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = less_eval(ctx, &lval, &rval, FALSE, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.8.3 */
HRESULT lesseq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = less_eval(ctx, &rval, &lval, TRUE, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.8.2 */
HRESULT greater_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = less_eval(ctx, &rval, &lval, FALSE, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.8.4 */
HRESULT greatereq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    VARIANT rval, lval;
    BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
    if(FAILED(hres))
        return hres;

    hres = less_eval(ctx, &lval, &rval, TRUE, ei, &b);
    VariantClear(&lval);
    VariantClear(&rval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, b);
}

/* ECMA-262 3rd Edition    11.4.8 */
HRESULT binary_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT val;
    INT i;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    hres = to_int32(ctx->parser->script, &val, ei, &i);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    V_VT(&ret->u.var) = VT_I4;
    V_I4(&ret->u.var) = ~i;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.4.9 */
HRESULT logical_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    unary_expression_t *expr = (unary_expression_t*)_expr;
    exprval_t exprval;
    VARIANT_BOOL b;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    return return_bool(ret, !b);
}

/* ECMA-262 3rd Edition    11.7.1 */
static HRESULT lshift_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    DWORD ri;
    INT li;
    HRESULT hres;

    hres = to_int32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_uint32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li << (ri&0x1f);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.7.1 */
HRESULT left_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.7.2 */
static HRESULT rshift_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    DWORD ri;
    INT li;
    HRESULT hres;

    hres = to_int32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_uint32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li >> (ri&0x1f);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.7.2 */
HRESULT right_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.7.3 */
static HRESULT rshift2_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
{
    DWORD li, ri;
    HRESULT hres;

    hres = to_uint32(ctx->parser->script, lval, ei, &li);
    if(FAILED(hres))
        return hres;

    hres = to_uint32(ctx->parser->script, rval, ei, &ri);
    if(FAILED(hres))
        return hres;

    V_VT(retv) = VT_I4;
    V_I4(retv) = li >> (ri&0x1f);
    return S_OK;
}

/* ECMA-262 3rd Edition    11.7.3 */
HRESULT right2_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.1 */
HRESULT assign_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;
    exprval_t exprval, exprvalr;
    VARIANT rval;
    HRESULT hres;

    TRACE("\n");

    hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
    if(FAILED(hres))
        return hres;

    hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
    if(SUCCEEDED(hres)) {
        hres = exprval_to_value(ctx->parser->script, &exprvalr, ei, &rval);
        exprval_release(&exprvalr);
    }

    if(SUCCEEDED(hres)) {
        hres = put_value(ctx->parser->script, &exprval, &rval, ei);
        if(FAILED(hres))
            VariantClear(&rval);
    }

    exprval_release(&exprval);
    if(FAILED(hres))
        return hres;

    ret->type = EXPRVAL_VARIANT;
    ret->u.var = rval;
    return S_OK;
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_lshift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_rshift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_rrshift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_mod_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, mod_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
}

/* ECMA-262 3rd Edition    11.13.2 */
HRESULT assign_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
{
    binary_expression_t *expr = (binary_expression_t*)_expr;

    TRACE("\n");

    return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
}