source: mainline/uspace/app/sbi/src/run_expr.c@ 22fb7ab

/*
 * Copyright (c) 2011 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @file Run expressions. */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "bigint.h"
#include "debug.h"
#include "intmap.h"
#include "list.h"
#include "mytypes.h"
#include "os/os.h"
#include "rdata.h"
#include "run.h"
#include "run_texpr.h"
#include "symbol.h"
#include "stree.h"
#include "strtab.h"
#include "tdata.h"

#include "run_expr.h"

static void run_nameref(run_t *run, stree_nameref_t *nameref,
    rdata_item_t **res);

static void run_literal(run_t *run, stree_literal_t *literal,
    rdata_item_t **res);
static void run_lit_bool(run_t *run, stree_lit_bool_t *lit_bool,
    rdata_item_t **res);
static void run_lit_char(run_t *run, stree_lit_char_t *lit_char,
    rdata_item_t **res);
static void run_lit_int(run_t *run, stree_lit_int_t *lit_int,
    rdata_item_t **res);
static void run_lit_ref(run_t *run, stree_lit_ref_t *lit_ref,
    rdata_item_t **res);
static void run_lit_string(run_t *run, stree_lit_string_t *lit_string,
    rdata_item_t **res);

static void run_self_ref(run_t *run, stree_self_ref_t *self_ref,
    rdata_item_t **res);

static void run_binop(run_t *run, stree_binop_t *binop, rdata_item_t **res);
static void run_binop_bool(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);
static void run_binop_char(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);
static void run_binop_int(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);
static void run_binop_string(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);
static void run_binop_ref(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);
static void run_binop_enum(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res);

static void run_unop(run_t *run, stree_unop_t *unop, rdata_item_t **res);
static void run_unop_bool(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    rdata_item_t **res);
static void run_unop_int(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    rdata_item_t **res);

static void run_new(run_t *run, stree_new_t *new_op, rdata_item_t **res);
static void run_new_array(run_t *run, stree_new_t *new_op,
    tdata_item_t *titem, rdata_item_t **res);
static void run_new_object(run_t *run, stree_new_t *new_op,
    tdata_item_t *titem, rdata_item_t **res);

static void run_object_ctor(run_t *run, rdata_var_t *obj, list_t *arg_vals);

static void run_access(run_t *run, stree_access_t *access, rdata_item_t **res);
static void run_access_item(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res);
static void run_access_ref(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res);
static void run_access_deleg(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res);
static void run_access_object(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res);
static void run_access_object_static(run_t *run, stree_access_t *access,
    rdata_var_t *obj_var, rdata_item_t **res);
static void run_access_object_nonstatic(run_t *run, stree_access_t *access,
    rdata_var_t *obj_var, rdata_item_t **res);
static void run_access_symbol(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res);

static void run_call(run_t *run, stree_call_t *call, rdata_item_t **res);
static void run_call_args(run_t *run, list_t *args, list_t *arg_vals);
static void run_destroy_arg_vals(list_t *arg_vals);

static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res);
static void run_index_array(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res);
static void run_index_object(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res);
static void run_index_string(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res);
static void run_assign(run_t *run, stree_assign_t *assign, rdata_item_t **res);
static void run_as(run_t *run, stree_as_t *as_op, rdata_item_t **res);
static void run_box(run_t *run, stree_box_t *box, rdata_item_t **res);

/** Evaluate expression.
 *
 * Run the expression @a expr and store pointer to the result in *(@a res).
 * If the expression has on value (assignment) then @c NULL is returned.
 * @c NULL is also returned if an error or exception occurs.
 *
 * @param run           Runner object
 * @param expr          Expression to run
 * @param res           Place to store result
 */
void run_expr(run_t *run, stree_expr_t *expr, rdata_item_t **res)
{
#ifdef DEBUG_RUN_TRACE
        printf("Executing expression.\n");
#endif

        switch (expr->ec) {
        case ec_nameref:
                run_nameref(run, expr->u.nameref, res);
                break;
        case ec_literal:
                run_literal(run, expr->u.literal, res);
                break;
        case ec_self_ref:
                run_self_ref(run, expr->u.self_ref, res);
                break;
        case ec_binop:
                run_binop(run, expr->u.binop, res);
                break;
        case ec_unop:
                run_unop(run, expr->u.unop, res);
                break;
        case ec_new:
                run_new(run, expr->u.new_op, res);
                break;
        case ec_access:
                run_access(run, expr->u.access, res);
                break;
        case ec_call:
                run_call(run, expr->u.call, res);
                break;
        case ec_index:
                run_index(run, expr->u.index, res);
                break;
        case ec_assign:
                run_assign(run, expr->u.assign, res);
                break;
        case ec_as:
                run_as(run, expr->u.as_op, res);
                break;
        case ec_box:
                run_box(run, expr->u.box, res);
                break;
        }

#ifdef DEBUG_RUN_TRACE
        printf("Expression result: ");
        rdata_item_print(*res);
        printf(".\n");
#endif
}

/** Evaluate name reference expression.
 *
 * @param run           Runner object
 * @param nameref       Name reference
 * @param res           Place to store result
 */
static void run_nameref(run_t *run, stree_nameref_t *nameref,
    rdata_item_t **res)
{
        stree_symbol_t *sym;
        rdata_item_t *item;
        rdata_address_t *address;
        rdata_addr_var_t *addr_var;
        rdata_addr_prop_t *addr_prop;
        rdata_aprop_named_t *aprop_named;
        rdata_deleg_t *deleg_p;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_deleg_t *deleg_v;
        rdata_symbol_t *symbol_v;

        run_proc_ar_t *proc_ar;
        stree_symbol_t *csi_sym;
        stree_csi_t *csi;
        rdata_object_t *obj;
        rdata_var_t *member_var;

        rdata_var_t *psobj;
        rdata_var_t *sobj;
        rdata_object_t *aobj;

#ifdef DEBUG_RUN_TRACE
        printf("Run nameref.\n");
#endif

        /*
         * Look for a local variable.
         */
        var = run_local_vars_lookup(run, nameref->name->sid);
        if (var != NULL) {
                /* Found a local variable. */
                item = rdata_item_new(ic_address);
                address = rdata_address_new(ac_var);
                addr_var = rdata_addr_var_new();

                item->u.address = address;
                address->u.var_a = addr_var;
                addr_var->vref = var;

                *res = item;
#ifdef DEBUG_RUN_TRACE
                printf("Found local variable.\n");
#endif
                return;
        }

        /*
         * Look for a class-wide or global symbol.
         */

        /* Determine currently active object or CSI. */
        proc_ar = run_get_current_proc_ar(run);

        assert (proc_ar->obj != NULL);
        assert(proc_ar->obj->vc == vc_object);
        obj = proc_ar->obj->u.object_v;
        csi_sym = obj->class_sym;

        if (csi_sym != NULL) {
                csi = symbol_to_csi(csi_sym);
                assert(csi != NULL);
        } else {
                /* This happens in interactive mode. */
                csi = NULL;
        }

        sym = symbol_lookup_in_csi(run->program, csi, nameref->name);

        /* Existence should have been verified in type checking phase. */
        assert(sym != NULL);

        switch (sym->sc) {
        case sc_csi:
#ifdef DEBUG_RUN_TRACE
                printf("Referencing CSI.\n");
#endif
                /* Obtain static object for the referenced CSI. */
                psobj = run->gdata; /* XXX */
                sobj = run_sobject_get(run, sym->u.csi, psobj,
                    nameref->name->sid);

                /* Return reference to the object. */
                run_reference(run, sobj, res);
                break;
        case sc_ctor:
                /* It is not possible to reference a constructor explicitly. */
                assert(b_false);
        case sc_enum:
#ifdef DEBUG_RUN_TRACE
                printf("Referencing enum.\n");
#endif
                item = rdata_item_new(ic_value);
                value = rdata_value_new();
                var = rdata_var_new(vc_symbol);
                symbol_v = rdata_symbol_new();

                item->u.value = value;
                value->var = var;
                var->u.symbol_v = symbol_v;

                symbol_v->sym = sym;
                *res = item;
                break;
        case sc_deleg:
                /* XXX TODO */
                printf("Unimplemented: Delegate name reference.\n");
                abort();
                break;
        case sc_fun:
                /* There should be no global functions. */
                assert(csi != NULL);

                if (symbol_search_csi(run->program, csi, nameref->name)
                    == NULL) {
                        /* Function is not in the current object. */
                        printf("Error: Cannot access non-static member "
                            "function '");
                        symbol_print_fqn(sym);
                        printf("' from nested CSI '");
                        symbol_print_fqn(csi_sym);
                        printf("'.\n");
                        exit(1);
                }

                /* Construct delegate. */
                item = rdata_item_new(ic_value);
                value = rdata_value_new();
                item->u.value = value;

                var = rdata_var_new(vc_deleg);
                deleg_v = rdata_deleg_new();
                value->var = var;
                var->u.deleg_v = deleg_v;

                deleg_v->obj = proc_ar->obj;
                deleg_v->sym = sym;

                *res = item;
                break;
        case sc_var:
        case sc_prop:
#ifdef DEBUG_RUN_TRACE
                if (sym->sc == sc_var)
                        printf("Referencing member variable.\n");
                else
                        printf("Referencing unqualified property.\n");
#endif
                /* There should be no global variables or properties. */
                assert(csi != NULL);

                if (symbol_search_csi(run->program, csi, nameref->name)
                    == NULL && !stree_symbol_is_static(sym)) {
                        /* Symbol is not in the current object. */
                        printf("Error: Cannot access non-static member "
                            "variable '");
                        symbol_print_fqn(sym);
                        printf("' from nested CSI '");
                        symbol_print_fqn(csi_sym);
                        printf("'.\n");
                        exit(1);
                }

                /*
                 * Determine object in which the symbol resides
                 */
                if (stree_symbol_is_static(sym)) {
                        /*
                         * Class object
                         * XXX This is too slow!
                         *
                         * However fixing this is non-trivial. We would
                         * have to have pointer to static object available
                         * for each object (therefore also for each object
                         * type).
                         */
                        sobj = run_sobject_find(run, sym->outer_csi);
                        assert(sobj->vc == vc_object);
                        aobj = sobj->u.object_v;
                } else {
                        /*
                         * Instance object. Currently we don't support
                         * true inner classes, thus we know the symbol is
                         * in the active object (there is no dynamic parent).
                         */
                        sobj = proc_ar->obj;
                        aobj = sobj->u.object_v;;
                }

                if (sym->sc == sc_var) {
                        /* Find member variable in object. */
                        member_var = intmap_get(&aobj->fields,
                            nameref->name->sid);
                        assert(member_var != NULL);

                        /* Return address of the variable. */
                        item = rdata_item_new(ic_address);
                        address = rdata_address_new(ac_var);
                        addr_var = rdata_addr_var_new();

                        item->u.address = address;
                        address->u.var_a = addr_var;
                        addr_var->vref = member_var;

                        *res = item;
                } else {
                        /* Construct named property address. */
                        item = rdata_item_new(ic_address);
                        address = rdata_address_new(ac_prop);
                        addr_prop = rdata_addr_prop_new(apc_named);
                        aprop_named = rdata_aprop_named_new();
                        item->u.address = address;
                        address->u.prop_a = addr_prop;
                        addr_prop->u.named = aprop_named;

                        deleg_p = rdata_deleg_new();
                        deleg_p->obj = sobj;
                        deleg_p->sym = sym;
                        addr_prop->u.named->prop_d = deleg_p;

                        *res = item;
                }
                break;
        }
}

/** Evaluate literal.
 *
 * @param run           Runner object
 * @param literal       Literal
 * @param res           Place to store result
 */
static void run_literal(run_t *run, stree_literal_t *literal,
    rdata_item_t **res)
{
#ifdef DEBUG_RUN_TRACE
        printf("Run literal.\n");
#endif
        switch (literal->ltc) {
        case ltc_bool:
                run_lit_bool(run, &literal->u.lit_bool, res);
                break;
        case ltc_char:
                run_lit_char(run, &literal->u.lit_char, res);
                break;
        case ltc_int:
                run_lit_int(run, &literal->u.lit_int, res);
                break;
        case ltc_ref:
                run_lit_ref(run, &literal->u.lit_ref, res);
                break;
        case ltc_string:
                run_lit_string(run, &literal->u.lit_string, res);
                break;
        }
}

/** Evaluate Boolean literal.
 *
 * @param run           Runner object
 * @param lit_bool      Boolean literal
 * @param res           Place to store result
 */
static void run_lit_bool(run_t *run, stree_lit_bool_t *lit_bool,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run Boolean literal.\n");
#endif
        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();

        item->u.value = value;
        value->var = var;
        var->u.bool_v = bool_v;
        bool_v->value = lit_bool->value;

        *res = item;
}

/** Evaluate character literal. */
static void run_lit_char(run_t *run, stree_lit_char_t *lit_char,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_char_t *char_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run character literal.\n");
#endif
        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_char);
        char_v = rdata_char_new();

        item->u.value = value;
        value->var = var;
        var->u.char_v = char_v;
        bigint_clone(&lit_char->value, &char_v->value);

        *res = item;
}

/** Evaluate integer literal.
 *
 * @param run           Runner object
 * @param lit_int       Integer literal
 * @param res           Place to store result
 */
static void run_lit_int(run_t *run, stree_lit_int_t *lit_int,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_int_t *int_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run integer literal.\n");
#endif
        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_int);
        int_v = rdata_int_new();

        item->u.value = value;
        value->var = var;
        var->u.int_v = int_v;
        bigint_clone(&lit_int->value, &int_v->value);

        *res = item;
}

/** Evaluate reference literal (@c nil).
 *
 * @param run           Runner object
 * @param lit_ref       Reference literal
 * @param res           Place to store result
 */
static void run_lit_ref(run_t *run, stree_lit_ref_t *lit_ref,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_ref_t *ref_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run reference literal (nil).\n");
#endif
        (void) run;
        (void) lit_ref;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_ref);
        ref_v = rdata_ref_new();

        item->u.value = value;
        value->var = var;
        var->u.ref_v = ref_v;
        ref_v->vref = NULL;

        *res = item;
}

/** Evaluate string literal.
 *
 * @param run           Runner object
 * @param lit_string    String literal
 * @param res           Place to store result
 */
static void run_lit_string(run_t *run, stree_lit_string_t *lit_string,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_string_t *string_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run integer literal.\n");
#endif
        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_string);
        string_v = rdata_string_new();

        item->u.value = value;
        value->var = var;
        var->u.string_v = string_v;
        string_v->value = lit_string->value;

        *res = item;
}

/** Evaluate @c self reference.
 *
 * @param run           Runner object
 * @param self_ref      Self reference
 * @param res           Place to store result
 */
static void run_self_ref(run_t *run, stree_self_ref_t *self_ref,
    rdata_item_t **res)
{
        run_proc_ar_t *proc_ar;

#ifdef DEBUG_RUN_TRACE
        printf("Run self reference.\n");
#endif
        (void) self_ref;
        proc_ar = run_get_current_proc_ar(run);

        /* Return reference to the currently active object. */
        run_reference(run, proc_ar->obj, res);
}

/** Evaluate binary operation.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param res           Place to store result
 */
static void run_binop(run_t *run, stree_binop_t *binop, rdata_item_t **res)
{
        rdata_item_t *rarg1_i, *rarg2_i;
        rdata_item_t *rarg1_vi, *rarg2_vi;
        rdata_value_t *v1, *v2;

        rarg1_i = NULL;
        rarg2_i = NULL;
        rarg1_vi = NULL;
        rarg2_vi = NULL;

#ifdef DEBUG_RUN_TRACE
        printf("Run binary operation.\n");
#endif
        run_expr(run, binop->arg1, &rarg1_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

#ifdef DEBUG_RUN_TRACE
        printf("Check binop argument result.\n");
#endif
        run_cvt_value_item(run, rarg1_i, &rarg1_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        run_expr(run, binop->arg2, &rarg2_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

#ifdef DEBUG_RUN_TRACE
        printf("Check binop argument result.\n");
#endif
        run_cvt_value_item(run, rarg2_i, &rarg2_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        v1 = rarg1_vi->u.value;
        v2 = rarg2_vi->u.value;

        if (v1->var->vc != v2->var->vc) {
                printf("Unimplemented: Binary operation arguments have "
                    "different type.\n");
                exit(1);
        }

        switch (v1->var->vc) {
        case vc_bool:
                run_binop_bool(run, binop, v1, v2, res);
                break;
        case vc_char:
                run_binop_char(run, binop, v1, v2, res);
                break;
        case vc_int:
                run_binop_int(run, binop, v1, v2, res);
                break;
        case vc_string:
                run_binop_string(run, binop, v1, v2, res);
                break;
        case vc_ref:
                run_binop_ref(run, binop, v1, v2, res);
                break;
        case vc_enum:
                run_binop_enum(run, binop, v1, v2, res);
                break;
        case vc_deleg:
        case vc_array:
        case vc_object:
        case vc_resource:
        case vc_symbol:
                assert(b_false);
        }

cleanup:
        if (rarg1_i != NULL)
                rdata_item_destroy(rarg1_i);
        if (rarg2_i != NULL)
                rdata_item_destroy(rarg2_i);
        if (rarg1_vi != NULL)
                rdata_item_destroy(rarg1_vi);
        if (rarg2_vi != NULL)
                rdata_item_destroy(rarg2_vi);
}

/** Evaluate binary operation on bool arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
 */
static void run_binop_bool(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

        bool_t b1, b2;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();

        item->u.value = value;
        value->var = var;
        var->u.bool_v = bool_v;

        b1 = v1->var->u.bool_v->value;
        b2 = v2->var->u.bool_v->value;

        switch (binop->bc) {
        case bo_plus:
        case bo_minus:
        case bo_mult:
                assert(b_false);

        case bo_equal:
                bool_v->value = (b1 == b2);
                break;
        case bo_notequal:
                bool_v->value = (b1 != b2);
                break;
        case bo_lt:
                bool_v->value = (b1 == b_false) && (b2 == b_true);
                break;
        case bo_gt:
                bool_v->value = (b1 == b_true) && (b2 == b_false);
                break;
        case bo_lt_equal:
                bool_v->value = (b1 == b_false) || (b2 == b_true);
                break;
        case bo_gt_equal:
                bool_v->value = (b1 == b_true) || (b2 == b_false);
                break;

        case bo_and:
                bool_v->value = (b1 == b_true) && (b2 == b_true);
                break;
        case bo_or:
                bool_v->value = (b1 == b_true) || (b2 == b_true);
                break;
        }

        *res = item;
}

/** Evaluate binary operation on char arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
*/
static void run_binop_char(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

        bigint_t *c1, *c2;
        bigint_t diff;
        bool_t zf, nf;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();

        item->u.value = value;

        c1 = &v1->var->u.char_v->value;
        c2 = &v2->var->u.char_v->value;

        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();
        var->u.bool_v = bool_v;
        value->var = var;

        bigint_sub(c1, c2, &diff);
        zf = bigint_is_zero(&diff);
        nf = bigint_is_negative(&diff);

        switch (binop->bc) {
        case bo_plus:
        case bo_minus:
        case bo_mult:
                assert(b_false);

        case bo_equal:
                bool_v->value = zf;
                break;
        case bo_notequal:
                bool_v->value = !zf;
                break;
        case bo_lt:
                bool_v->value = (!zf && nf);
                break;
        case bo_gt:
                bool_v->value = (!zf && !nf);
                break;
        case bo_lt_equal:
                bool_v->value = (zf || nf);
                break;
        case bo_gt_equal:
                bool_v->value = !nf;
                break;

        case bo_and:
        case bo_or:
                assert(b_false);
        }

        *res = item;
}

/** Evaluate binary operation on int arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
*/
static void run_binop_int(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_int_t *int_v;
        rdata_bool_t *bool_v;

        bigint_t *i1, *i2;
        bigint_t diff;
        bool_t done;
        bool_t zf, nf;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();

        item->u.value = value;

        i1 = &v1->var->u.int_v->value;
        i2 = &v2->var->u.int_v->value;

        done = b_true;

        switch (binop->bc) {
        case bo_plus:
                int_v = rdata_int_new();
                bigint_add(i1, i2, &int_v->value);
                break;
        case bo_minus:
                int_v = rdata_int_new();
                bigint_sub(i1, i2, &int_v->value);
                break;
        case bo_mult:
                int_v = rdata_int_new();
                bigint_mul(i1, i2, &int_v->value);
                break;
        default:
                done = b_false;
                break;
        }

        if (done) {
                var = rdata_var_new(vc_int);
                var->u.int_v = int_v;
                value->var = var;
                *res = item;
                return;
        }

        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();
        var->u.bool_v = bool_v;
        value->var = var;

        /* Relational operation. */

        bigint_sub(i1, i2, &diff);
        zf = bigint_is_zero(&diff);
        nf = bigint_is_negative(&diff);

        switch (binop->bc) {
        case bo_plus:
        case bo_minus:
        case bo_mult:
                assert(b_false);

        case bo_equal:
                bool_v->value = zf;
                break;
        case bo_notequal:
                bool_v->value = !zf;
                break;
        case bo_lt:
                bool_v->value = (!zf && nf);
                break;
        case bo_gt:
                bool_v->value = (!zf && !nf);
                break;
        case bo_lt_equal:
                bool_v->value = (zf || nf);
                break;
        case bo_gt_equal:
                bool_v->value = !nf;
                break;
        case bo_and:
        case bo_or:
                assert(b_false);
        }

        *res = item;
}

/** Evaluate binary operation on string arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
 */
static void run_binop_string(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_string_t *string_v;
        rdata_bool_t *bool_v;
        bool_t done;
        bool_t zf;

        const char *s1, *s2;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();

        item->u.value = value;

        s1 = v1->var->u.string_v->value;
        s2 = v2->var->u.string_v->value;

        done = b_true;

        switch (binop->bc) {
        case bo_plus:
                /* Concatenate strings. */
                string_v = rdata_string_new();
                string_v->value = os_str_acat(s1, s2);
                break;
        default:
                done = b_false;
                break;
        }

        if (done) {
                var = rdata_var_new(vc_string);
                var->u.string_v = string_v;
                value->var = var;
                *res = item;
                return;
        }

        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();
        var->u.bool_v = bool_v;
        value->var = var;

        /* Relational operation. */

        zf = os_str_cmp(s1, s2) == 0;

        switch (binop->bc) {
        case bo_equal:
                bool_v->value = zf;
                break;
        case bo_notequal:
                bool_v->value = !zf;
                break;
        default:
                printf("Error: Invalid binary operation on string "
                    "arguments (%d).\n", binop->bc);
                assert(b_false);
        }

        *res = item;
}

/** Evaluate binary operation on ref arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
 */
static void run_binop_ref(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

        rdata_var_t *ref1, *ref2;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();

        item->u.value = value;
        value->var = var;
        var->u.bool_v = bool_v;

        ref1 = v1->var->u.ref_v->vref;
        ref2 = v2->var->u.ref_v->vref;

        switch (binop->bc) {
        case bo_equal:
                bool_v->value = (ref1 == ref2);
                break;
        case bo_notequal:
                bool_v->value = (ref1 != ref2);
                break;
        default:
                printf("Error: Invalid binary operation on reference "
                    "arguments (%d).\n", binop->bc);
                assert(b_false);
        }

        *res = item;
}

/** Evaluate binary operation on enum arguments.
 *
 * @param run           Runner object
 * @param binop         Binary operation
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result
 */
static void run_binop_enum(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    rdata_value_t *v2, rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

        stree_embr_t *e1, *e2;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();

        item->u.value = value;
        value->var = var;
        var->u.bool_v = bool_v;

        e1 = v1->var->u.enum_v->value;
        e2 = v2->var->u.enum_v->value;

        switch (binop->bc) {
        case bo_equal:
                bool_v->value = (e1 == e2);
                break;
        case bo_notequal:
                bool_v->value = (e1 != e2);
                break;
        default:
                /* Should have been caught by static typing. */
                assert(b_false);
        }

        *res = item;
}

/** Evaluate unary operation.
 *
 * @param run           Runner object
 * @param unop          Unary operation
 * @param res           Place to store result
 */
static void run_unop(run_t *run, stree_unop_t *unop, rdata_item_t **res)
{
        rdata_item_t *rarg_i;
        rdata_item_t *rarg_vi;
        rdata_value_t *val;

#ifdef DEBUG_RUN_TRACE
        printf("Run unary operation.\n");
#endif
        rarg_i = NULL;
        rarg_vi = NULL;

        run_expr(run, unop->arg, &rarg_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

#ifdef DEBUG_RUN_TRACE
        printf("Check unop argument result.\n");
#endif
        run_cvt_value_item(run, rarg_i, &rarg_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        val = rarg_vi->u.value;

        switch (val->var->vc) {
        case vc_bool:
                run_unop_bool(run, unop, val, res);
                break;
        case vc_int:
                run_unop_int(run, unop, val, res);
                break;
        default:
                printf("Unimplemented: Unrary operation argument of "
                    "type %d.\n", val->var->vc);
                run_raise_error(run);
                *res = run_recovery_item(run);
                break;
        }
cleanup:
        if (rarg_i != NULL)
                rdata_item_destroy(rarg_i);
        if (rarg_vi != NULL)
                rdata_item_destroy(rarg_vi);
}

/** Evaluate unary operation on bool argument.
 *
 * @param run           Runner object
 * @param unop          Unary operation
 * @param val           Value of argument
 * @param res           Place to store result
 */
static void run_unop_bool(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_bool_t *bool_v;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_bool);
        bool_v = rdata_bool_new();

        item->u.value = value;
        value->var = var;
        var->u.bool_v = bool_v;

        switch (unop->uc) {
        case uo_plus:
        case uo_minus:
                assert(b_false);

        case uo_not:
                bool_v->value = !val->var->u.bool_v->value;
                break;
        }

        *res = item;
}

/** Evaluate unary operation on int argument.
 *
 * @param run           Runner object
 * @param unop          Unary operation
 * @param val           Value of argument
 * @param res           Place to store result
 */
static void run_unop_int(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    rdata_item_t **res)
{
        rdata_item_t *item;
        rdata_value_t *value;
        rdata_var_t *var;
        rdata_int_t *int_v;

        (void) run;

        item = rdata_item_new(ic_value);
        value = rdata_value_new();
        var = rdata_var_new(vc_int);
        int_v = rdata_int_new();

        item->u.value = value;
        value->var = var;
        var->u.int_v = int_v;

        switch (unop->uc) {
        case uo_plus:
                bigint_clone(&val->var->u.int_v->value, &int_v->value);
                break;
        case uo_minus:
                bigint_reverse_sign(&val->var->u.int_v->value,
                    &int_v->value);
                break;
        case uo_not:
                assert(b_false);
        }

        *res = item;
}

/** Run equality comparison of two values
 *
 * This should be equivalent to equality ('==') binary operation.
 * XXX Duplicating code of run_binop_xxx().
 *
 * @param run           Runner object
 * @param v1            Value of first argument
 * @param v2            Value of second argument
 * @param res           Place to store result (plain boolean value)
 */
void run_equal(run_t *run, rdata_value_t *v1, rdata_value_t *v2, bool_t *res)
{
        bool_t b1, b2;
        bigint_t *c1, *c2;
        bigint_t *i1, *i2;
        bigint_t diff;
        const char *s1, *s2;
        rdata_var_t *ref1, *ref2;
        stree_embr_t *e1, *e2;

        (void) run;
        assert(v1->var->vc == v2->var->vc);

        switch (v1->var->vc) {
        case vc_bool:
                b1 = v1->var->u.bool_v->value;
                b2 = v2->var->u.bool_v->value;

                *res = (b1 == b2);
                break;
        case vc_char:
                c1 = &v1->var->u.char_v->value;
                c2 = &v2->var->u.char_v->value;

                bigint_sub(c1, c2, &diff);
                *res = bigint_is_zero(&diff);
                break;
        case vc_int:
                i1 = &v1->var->u.int_v->value;
                i2 = &v2->var->u.int_v->value;

                bigint_sub(i1, i2, &diff);
                *res = bigint_is_zero(&diff);
                break;
        case vc_string:
                s1 = v1->var->u.string_v->value;
                s2 = v2->var->u.string_v->value;

                *res = os_str_cmp(s1, s2) == 0;
                break;
        case vc_ref:
                ref1 = v1->var->u.ref_v->vref;
                ref2 = v2->var->u.ref_v->vref;

                *res = (ref1 == ref2);
                break;
        case vc_enum:
                e1 = v1->var->u.enum_v->value;
                e2 = v2->var->u.enum_v->value;

                *res = (e1 == e2);
                break;

        case vc_deleg:
        case vc_array:
        case vc_object:
        case vc_resource:
        case vc_symbol:
                assert(b_false);
        }
}


/** Evaluate @c new operation.
 *
 * Evaluates operation per the @c new operator that creates a new
 * instance of some type.
 *
 * @param run           Runner object
 * @param unop          Unary operation
 * @param res           Place to store result
 */
static void run_new(run_t *run, stree_new_t *new_op, rdata_item_t **res)
{
        tdata_item_t *titem;

#ifdef DEBUG_RUN_TRACE
        printf("Run 'new' operation.\n");
#endif
        /* Evaluate type expression */
        run_texpr(run->program, run_get_current_csi(run), new_op->texpr,
            &titem);

        switch (titem->tic) {
        case tic_tarray:
                run_new_array(run, new_op, titem, res);
                break;
        case tic_tobject:
                run_new_object(run, new_op, titem, res);
                break;
        default:
                printf("Error: Invalid argument to operator 'new', "
                    "expected object.\n");
                exit(1);
        }
}

/** Create new array.
 *
 * @param run           Runner object
 * @param new_op        New operation
 * @param titem         Type of new var node (tic_tarray)
 * @param res           Place to store result
 */
static void run_new_array(run_t *run, stree_new_t *new_op,
    tdata_item_t *titem, rdata_item_t **res)
{
        tdata_array_t *tarray;
        rdata_array_t *array;
        rdata_var_t *array_var;
        rdata_var_t *elem_var;

        rdata_item_t *rexpr, *rexpr_vi;
        rdata_var_t *rexpr_var;

        stree_expr_t *expr;

        list_node_t *node;
        int length;
        int i;
        int rc;
        int iextent;

#ifdef DEBUG_RUN_TRACE
        printf("Create new array.\n");
#endif
        (void) run;
        (void) new_op;

        assert(titem->tic == tic_tarray);
        tarray = titem->u.tarray;

        /* Create the array. */
        assert(titem->u.tarray->rank > 0);
        array = rdata_array_new(titem->u.tarray->rank);

        /* Compute extents. */
        node = list_first(&tarray->extents);
        if (node == NULL) {
                printf("Error: Extents must be specified when constructing "
                    "an array with 'new'.\n");
                exit(1);
        }

        i = 0; length = 1;
        while (node != NULL) {
                expr = list_node_data(node, stree_expr_t *);

                /* Evaluate extent argument. */
                run_expr(run, expr, &rexpr);
                if (run_is_bo(run)) {
                        *res = run_recovery_item(run);
                        return;
                }

                run_cvt_value_item(run, rexpr, &rexpr_vi);
                if (run_is_bo(run)) {
                        *res = run_recovery_item(run);
                        return;
                }

                assert(rexpr_vi->ic == ic_value);
                rexpr_var = rexpr_vi->u.value->var;

                if (rexpr_var->vc != vc_int) {
                        printf("Error: Array extent must be an integer.\n");
                        exit(1);
                }

#ifdef DEBUG_RUN_TRACE
                printf("Array extent: ");
                bigint_print(&rexpr_var->u.int_v->value);
                printf(".\n");
#endif
                rc = bigint_get_value_int(&rexpr_var->u.int_v->value,
                    &iextent);
                if (rc != EOK) {
                        printf("Memory allocation failed (big int used).\n");
                        exit(1);
                }

                array->extent[i] = iextent;
                length = length * array->extent[i];

                node = list_next(&tarray->extents, node);
                i += 1;
        }

        array->element = calloc(length, sizeof(rdata_var_t *));
        if (array->element == NULL) {
                printf("Memory allocation failed.\n");
                exit(1);
        }

        /* Create member variables */
        for (i = 0; i < length; ++i) {
                /* Create and initialize element. */
                run_var_new(run, tarray->base_ti, &elem_var);

                array->element[i] = elem_var;
        }

        /* Create array variable. */
        array_var = rdata_var_new(vc_array);
        array_var->u.array_v = array;

        /* Create reference to the new array. */
        run_reference(run, array_var, res);
}

/** Create new object.
 *
 * @param run           Runner object
 * @param new_op        New operation
 * @param titem         Type of new var node (tic_tobject)
 * @param res           Place to store result
 */
static void run_new_object(run_t *run, stree_new_t *new_op,
    tdata_item_t *titem, rdata_item_t **res)
{
        stree_csi_t *csi;
        rdata_item_t *obj_i;
        list_t arg_vals;

#ifdef DEBUG_RUN_TRACE
        printf("Create new object.\n");
#endif
        /* Lookup object CSI. */
        assert(titem->tic == tic_tobject);
        csi = titem->u.tobject->csi;

        /* Evaluate constructor arguments. */
        run_call_args(run, &new_op->ctor_args, &arg_vals);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        /* Create CSI instance. */
        run_new_csi_inst_ref(run, csi, sn_nonstatic, res);

        /* Run the constructor. */
        run_dereference(run, *res, NULL, &obj_i);
        assert(obj_i->ic == ic_address);
        assert(obj_i->u.address->ac == ac_var);
        run_object_ctor(run, obj_i->u.address->u.var_a->vref, &arg_vals);
        rdata_item_destroy(obj_i);

        /* Destroy argument values */
        run_destroy_arg_vals(&arg_vals);
}

/** Evaluate member acccess.
 *
 * Evaluate operation per the member access ('.') operator.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param res           Place to store result
 */
static void run_access(run_t *run, stree_access_t *access, rdata_item_t **res)
{
        rdata_item_t *rarg;

#ifdef DEBUG_RUN_TRACE
        printf("Run access operation.\n");
#endif
        rarg = NULL;

        run_expr(run, access->arg, &rarg);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        if (rarg == NULL) {
                printf("Error: Sub-expression has no value.\n");
                exit(1);
        }

        run_access_item(run, access, rarg, res);
cleanup:
        if (rarg != NULL)
                rdata_item_destroy(rarg);
}

/** Evaluate member acccess (with base already evaluated).
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_item(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res)
{
        var_class_t vc;

#ifdef DEBUG_RUN_TRACE
        printf("Run access operation on pre-evaluated base.\n");
#endif
        vc = run_item_get_vc(run, arg);

        switch (vc) {
        case vc_ref:
                run_access_ref(run, access, arg, res);
                break;
        case vc_deleg:
                run_access_deleg(run, access, arg, res);
                break;
        case vc_object:
                run_access_object(run, access, arg, res);
                break;
        case vc_symbol:
                run_access_symbol(run, access, arg, res);
                break;

        case vc_bool:
        case vc_char:
        case vc_enum:
        case vc_int:
        case vc_string:
        case vc_array:
        case vc_resource:
                printf("Unimplemented: Using access operator ('.') "
                    "with unsupported data type (value/%d).\n", vc);
                exit(1);
        }
}

/** Evaluate reference acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_ref(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res)
{
        rdata_item_t *darg;

        /* Implicitly dereference. */
        run_dereference(run, arg, access->arg->cspan, &darg);

        if (run->thread_ar->bo_mode != bm_none) {
                *res = run_recovery_item(run);
                return;
        }

        /* Try again. */
        run_access_item(run, access, darg, res);

        /* Destroy temporary */
        rdata_item_destroy(darg);
}

/** Evaluate delegate member acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_deleg(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res)
{
        (void) run;
        (void) access;
        (void) arg;
        (void) res;

        printf("Error: Using '.' with delegate.\n");
        exit(1);
}

/** Evaluate object member acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_object(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res)
{
        rdata_var_t *obj_var;
        rdata_object_t *object;

#ifdef DEBUG_RUN_TRACE
        printf("Run object access operation.\n");
#endif
        assert(arg->ic == ic_address);
        assert(arg->u.address->ac == ac_var);

        obj_var = arg->u.address->u.var_a->vref;
        assert(obj_var->vc == vc_object);

        object = obj_var->u.object_v;

        if (object->static_obj == sn_static)
                run_access_object_static(run, access, obj_var, res);
        else
                run_access_object_nonstatic(run, access, obj_var, res);
}

/** Evaluate static object member acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_object_static(run_t *run, stree_access_t *access,
    rdata_var_t *obj_var, rdata_item_t **res)
{
        rdata_object_t *object;
        stree_symbol_t *member;
        stree_csi_t *member_csi;

        rdata_deleg_t *deleg_v;
        rdata_item_t *ritem;
        rdata_value_t *rvalue;
        rdata_var_t *rvar;
        rdata_address_t *address;
        rdata_addr_var_t *addr_var;
        rdata_addr_prop_t *addr_prop;
        rdata_aprop_named_t *aprop_named;
        rdata_deleg_t *deleg_p;
        rdata_var_t *mvar;

#ifdef DEBUG_RUN_TRACE
        printf("Run static object access operation.\n");
#endif
        assert(obj_var->vc == vc_object);
        object = obj_var->u.object_v;

        assert(object->static_obj == sn_static);

        member = symbol_search_csi(run->program, object->class_sym->u.csi,
            access->member_name);

        /* Member existence should be ensured by static type checking. */
        assert(member != NULL);

#ifdef DEBUG_RUN_TRACE
        printf("Found member '%s'.\n",
            strtab_get_str(access->member_name->sid));
#endif

        switch (member->sc) {
        case sc_csi:
                /* Get child static object. */
                member_csi = symbol_to_csi(member);
                assert(member_csi != NULL);

                mvar = run_sobject_get(run, member_csi, obj_var,
                    access->member_name->sid);

                ritem = rdata_item_new(ic_address);
                address = rdata_address_new(ac_var);
                ritem->u.address = address;

                addr_var = rdata_addr_var_new();
                address->u.var_a = addr_var;
                addr_var->vref = mvar;

                *res = ritem;
                break;
        case sc_ctor:
                /* It is not possible to reference a constructor explicitly. */
                assert(b_false);
        case sc_deleg:
                printf("Error: Accessing object member which is a delegate.\n");
                exit(1);
        case sc_enum:
                printf("Error: Accessing object member which is an enum.\n");
                exit(1);
        case sc_fun:
                /* Construct anonymous delegate. */
                ritem = rdata_item_new(ic_value);
                rvalue = rdata_value_new();
                ritem->u.value = rvalue;

                rvar = rdata_var_new(vc_deleg);
                rvalue->var = rvar;

                deleg_v = rdata_deleg_new();
                rvar->u.deleg_v = deleg_v;

                deleg_v->obj = obj_var;
                deleg_v->sym = member;
                *res = ritem;
                break;
        case sc_var:
                /* Get static object member variable. */
                mvar = intmap_get(&object->fields, access->member_name->sid);

                ritem = rdata_item_new(ic_address);
                address = rdata_address_new(ac_var);
                ritem->u.address = address;

                addr_var = rdata_addr_var_new();
                address->u.var_a = addr_var;
                addr_var->vref = mvar;

                *res = ritem;
                break;
        case sc_prop:
                /* Construct named property address. */
                ritem = rdata_item_new(ic_address);
                address = rdata_address_new(ac_prop);
                addr_prop = rdata_addr_prop_new(apc_named);
                aprop_named = rdata_aprop_named_new();
                ritem->u.address = address;
                address->u.prop_a = addr_prop;
                addr_prop->u.named = aprop_named;

                deleg_p = rdata_deleg_new();
                deleg_p->obj = obj_var;
                deleg_p->sym = member;
                addr_prop->u.named->prop_d = deleg_p;

                *res = ritem;
                break;
        }
}

/** Evaluate object member acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_object_nonstatic(run_t *run, stree_access_t *access,
    rdata_var_t *obj_var, rdata_item_t **res)
{
        rdata_object_t *object;
        stree_symbol_t *member;
        rdata_item_t *ritem;
        rdata_address_t *address;
        rdata_addr_var_t *addr_var;
        rdata_addr_prop_t *addr_prop;
        rdata_aprop_named_t *aprop_named;
        rdata_deleg_t *deleg_p;

        rdata_value_t *value;
        rdata_deleg_t *deleg_v;
        rdata_var_t *var;

#ifdef DEBUG_RUN_TRACE
        printf("Run nonstatic object access operation.\n");
#endif
        assert(obj_var->vc == vc_object);
        object = obj_var->u.object_v;

        assert(object->static_obj == sn_nonstatic);

        member = symbol_search_csi(run->program, object->class_sym->u.csi,
            access->member_name);

        if (member == NULL) {
                printf("Error: Object of class '");
                symbol_print_fqn(object->class_sym);
                printf("' has no member named '%s'.\n",
                    strtab_get_str(access->member_name->sid));
                exit(1);
        }

#ifdef DEBUG_RUN_TRACE
        printf("Found member '%s'.\n",
            strtab_get_str(access->member_name->sid));
#endif

        /* Make compiler happy. */
        ritem = NULL;

        switch (member->sc) {
        case sc_csi:
                printf("Error: Accessing object member which is nested CSI.\n");
                exit(1);
        case sc_ctor:
                /* It is not possible to reference a constructor explicitly. */
                assert(b_false);
        case sc_deleg:
                printf("Error: Accessing object member which is a delegate.\n");
                exit(1);
        case sc_enum:
                printf("Error: Accessing object member which is an enum.\n");
                exit(1);
        case sc_fun:
                /* Construct anonymous delegate. */
                ritem = rdata_item_new(ic_value);
                value = rdata_value_new();
                ritem->u.value = value;

                var = rdata_var_new(vc_deleg);
                value->var = var;
                deleg_v = rdata_deleg_new();
                var->u.deleg_v = deleg_v;

                deleg_v->obj = obj_var;
                deleg_v->sym = member;
                break;
        case sc_var:
                /* Construct variable address item. */
                ritem = rdata_item_new(ic_address);
                address = rdata_address_new(ac_var);
                addr_var = rdata_addr_var_new();
                ritem->u.address = address;
                address->u.var_a = addr_var;

                addr_var->vref = intmap_get(&object->fields,
                    access->member_name->sid);
                assert(addr_var->vref != NULL);
                break;
        case sc_prop:
                /* Construct named property address. */
                ritem = rdata_item_new(ic_address);
                address = rdata_address_new(ac_prop);
                addr_prop = rdata_addr_prop_new(apc_named);
                aprop_named = rdata_aprop_named_new();
                ritem->u.address = address;
                address->u.prop_a = addr_prop;
                addr_prop->u.named = aprop_named;

                deleg_p = rdata_deleg_new();
                deleg_p->obj = obj_var;
                deleg_p->sym = member;
                addr_prop->u.named->prop_d = deleg_p;
                break;
        }

        *res = ritem;
}

/** Evaluate symbol member acccess.
 *
 * @param run           Runner object
 * @param access        Access operation
 * @param arg           Evaluated base expression
 * @param res           Place to store result
 */
static void run_access_symbol(run_t *run, stree_access_t *access,
    rdata_item_t *arg, rdata_item_t **res)
{
        rdata_item_t *arg_vi;
        rdata_value_t *arg_val;
        rdata_symbol_t *symbol_v;
        stree_embr_t *embr;

        rdata_item_t *ritem;
        rdata_value_t *rvalue;
        rdata_var_t *rvar;
        rdata_enum_t *enum_v;

#ifdef DEBUG_RUN_TRACE
        printf("Run symbol access operation.\n");
#endif
        run_cvt_value_item(run, arg, &arg_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        arg_val = arg_vi->u.value;
        assert(arg_val->var->vc == vc_symbol);

        symbol_v = arg_val->var->u.symbol_v;

        /* XXX Port CSI symbol reference to using vc_symbol */
        assert(symbol_v->sym->sc == sc_enum);

        embr = stree_enum_find_mbr(symbol_v->sym->u.enum_d,
            access->member_name);

        rdata_item_destroy(arg_vi);

        /* Member existence should be ensured by static type checking. */
        assert(embr != NULL);

#ifdef DEBUG_RUN_TRACE
        printf("Found enum member '%s'.\n",
            strtab_get_str(access->member_name->sid));
#endif
        ritem = rdata_item_new(ic_value);
        rvalue = rdata_value_new();
        rvar = rdata_var_new(vc_enum);
        enum_v = rdata_enum_new();

        ritem->u.value = rvalue;
        rvalue->var = rvar;
        rvar->u.enum_v = enum_v;
        enum_v->value = embr;

        *res = ritem;
}

/** Call a function.
 *
 * Call a function and return the result in @a res.
 *
 * @param run           Runner object
 * @param call          Call operation
 * @param res           Place to store result
 */
static void run_call(run_t *run, stree_call_t *call, rdata_item_t **res)
{
        rdata_item_t *rdeleg, *rdeleg_vi;
        rdata_deleg_t *deleg_v;
        list_t arg_vals;

        stree_fun_t *fun;
        run_proc_ar_t *proc_ar;

#ifdef DEBUG_RUN_TRACE
        printf("Run call operation.\n");
#endif
        rdeleg = NULL;
        rdeleg_vi = NULL;

        run_expr(run, call->fun, &rdeleg);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        run_cvt_value_item(run, rdeleg, &rdeleg_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        assert(rdeleg_vi->ic == ic_value);

        if (rdeleg_vi->u.value->var->vc != vc_deleg) {
                printf("Unimplemented: Call expression of this type (");
                rdata_item_print(rdeleg_vi);
                printf(").\n");
                exit(1);
        }

        deleg_v = rdeleg_vi->u.value->var->u.deleg_v;

        if (deleg_v->sym->sc != sc_fun) {
                printf("Error: Called symbol is not a function.\n");
                exit(1);
        }

#ifdef DEBUG_RUN_TRACE
        printf("Call function '");
        symbol_print_fqn(deleg_v->sym);
        printf("'\n");
#endif
        /* Evaluate function arguments. */
        run_call_args(run, &call->args, &arg_vals);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        fun = symbol_to_fun(deleg_v->sym);
        assert(fun != NULL);

        /* Create procedure activation record. */
        run_proc_ar_create(run, deleg_v->obj, fun->proc, &proc_ar);

        /* Fill in argument values. */
        run_proc_ar_set_args(run, proc_ar, &arg_vals);

        /* Destroy arg_vals, they are no longer needed. */
        run_destroy_arg_vals(&arg_vals);

        /* Run the function. */
        run_proc(run, proc_ar, res);

        if (!run_is_bo(run) && fun->sig->rtype != NULL && *res == NULL) {
                printf("Error: Function '");
                symbol_print_fqn(deleg_v->sym);
                printf("' did not return a value.\n");
                exit(1);
        }

        /* Destroy procedure activation record. */
        run_proc_ar_destroy(run, proc_ar);

cleanup:
        if (rdeleg != NULL)
                rdata_item_destroy(rdeleg);
        if (rdeleg_vi != NULL)
                rdata_item_destroy(rdeleg_vi);

#ifdef DEBUG_RUN_TRACE
        printf("Returned from function call.\n");
#endif
}

/** Evaluate call arguments.
 *
 * Evaluate arguments to function or constructor.
 *
 * @param run           Runner object
 * @param args          Real arguments (list of stree_expr_t)
 * @param arg_vals      Address of uninitialized list to store argument values
 *                      (list of rdata_item_t).
 */
static void run_call_args(run_t *run, list_t *args, list_t *arg_vals)
{
        list_node_t *arg_n;
        stree_expr_t *arg;
        rdata_item_t *rarg_i, *rarg_vi;

        /* Evaluate function arguments. */
        list_init(arg_vals);
        arg_n = list_first(args);

        while (arg_n != NULL) {
                arg = list_node_data(arg_n, stree_expr_t *);
                run_expr(run, arg, &rarg_i);
                if (run_is_bo(run))
                        goto error;

                run_cvt_value_item(run, rarg_i, &rarg_vi);
                rdata_item_destroy(rarg_i);
                if (run_is_bo(run))
                        goto error;

                list_append(arg_vals, rarg_vi);
                arg_n = list_next(args, arg_n);
        }
        return;

error:
        /*
         * An exception or error occured while evaluating one of the
         * arguments. Destroy already obtained argument values and
         * dismantle the list.
         */
        run_destroy_arg_vals(arg_vals);
}

/** Destroy list of evaluated arguments.
 *
 * Provided a list of evaluated arguments, destroy them, removing them
 * from the list and fini the list itself.
 *
 * @param arg_vals      List of evaluated arguments (value items,
 *                      rdata_item_t).
 */
static void run_destroy_arg_vals(list_t *arg_vals)
{
        list_node_t *val_n;
        rdata_item_t *val_i;

        /*
         * An exception or error occured while evaluating one of the
         * arguments. Destroy already obtained argument values and
         * dismantle the list.
         */
        while (!list_is_empty(arg_vals)) {
                val_n = list_first(arg_vals);
                val_i = list_node_data(val_n, rdata_item_t *);

                rdata_item_destroy(val_i);
                list_remove(arg_vals, val_n);
        }
        list_fini(arg_vals);
}

/** Run index operation.
 *
 * Evaluate operation per the indexing ('[', ']') operator.
 *
 * @param run           Runner object
 * @param index         Index operation
 * @param res           Place to store result
 */
static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res)
{
        rdata_item_t *rbase;
        rdata_item_t *base_i;
        list_node_t *node;
        stree_expr_t *arg;
        rdata_item_t *rarg_i, *rarg_vi;
        var_class_t vc;
        list_t arg_vals;
        list_node_t *val_n;
        rdata_item_t *val_i;

#ifdef DEBUG_RUN_TRACE
        printf("Run index operation.\n");
#endif
        run_expr(run, index->base, &rbase);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        vc = run_item_get_vc(run, rbase);

        /* Implicitly dereference. */
        if (vc == vc_ref) {
                run_dereference(run, rbase, index->base->cspan, &base_i);
                rdata_item_destroy(rbase);
                if (run_is_bo(run)) {
                        *res = run_recovery_item(run);
                        return;
                }
        } else {
                base_i = rbase;
        }

        vc = run_item_get_vc(run, base_i);

        /* Evaluate arguments (indices). */
        node = list_first(&index->args);
        list_init(&arg_vals);

        while (node != NULL) {
                arg = list_node_data(node, stree_expr_t *);
                run_expr(run, arg, &rarg_i);
                if (run_is_bo(run)) {
                        *res = run_recovery_item(run);
                        goto cleanup;
                }

                run_cvt_value_item(run, rarg_i, &rarg_vi);
                rdata_item_destroy(rarg_i);
                if (run_is_bo(run)) {
                        *res = run_recovery_item(run);
                        goto cleanup;
                }

                list_append(&arg_vals, rarg_vi);

                node = list_next(&index->args, node);
        }

        switch (vc) {
        case vc_array:
                run_index_array(run, index, base_i, &arg_vals, res);
                break;
        case vc_object:
                run_index_object(run, index, base_i, &arg_vals, res);
                break;
        case vc_string:
                run_index_string(run, index, base_i, &arg_vals, res);
                break;
        default:
                printf("Error: Indexing object of bad type (%d).\n", vc);
                exit(1);
        }

        /* Destroy the indexing base temporary */
        rdata_item_destroy(base_i);
cleanup:
        /*
         * An exception or error occured while evaluating one of the
         * arguments. Destroy already obtained argument values and
         * dismantle the list.
         */
        while (!list_is_empty(&arg_vals)) {
                val_n = list_first(&arg_vals);
                val_i = list_node_data(val_n, rdata_item_t *);

                rdata_item_destroy(val_i);
                list_remove(&arg_vals, val_n);
        }

        list_fini(&arg_vals);
}

/** Run index operation on array.
 *
 * @param run           Runner object
 * @param index         Index operation
 * @param base          Evaluated base expression
 * @param args          Evaluated indices (list of rdata_item_t)
 * @param res           Place to store result
 */
static void run_index_array(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res)
{
        list_node_t *node;
        rdata_array_t *array;
        rdata_item_t *arg;

        int i;
        int elem_index;
        int arg_val;
        int rc;

        rdata_item_t *ritem;
        rdata_address_t *address;
        rdata_addr_var_t *addr_var;

#ifdef DEBUG_RUN_TRACE
        printf("Run array index operation.\n");
#endif
        (void) run;

        assert(base->ic == ic_address);
        assert(base->u.address->ac == ac_var);
        assert(base->u.address->u.var_a->vref->vc == vc_array);
        array = base->u.address->u.var_a->vref->u.array_v;

        /*
         * Linear index of the desired element. Elements are stored in
         * lexicographic order with the last index changing the fastest.
         */
        elem_index = 0;

        node = list_first(args);
        i = 0;

        while (node != NULL) {
                if (i >= array->rank) {
                        printf("Error: Too many indices for array of rank %d",
                            array->rank);
                        exit(1);
                }

                arg = list_node_data(node, rdata_item_t *);
                assert(arg->ic == ic_value);

                if (arg->u.value->var->vc != vc_int) {
                        printf("Error: Array index is not an integer.\n");
                        exit(1);
                }

                rc = bigint_get_value_int(
                    &arg->u.value->var->u.int_v->value,
                    &arg_val);

                if (rc != EOK || arg_val < 0 || arg_val >= array->extent[i]) {
#ifdef DEBUG_RUN_TRACE
                        printf("Error: Array index (value: %d) is out of range.\n",
                            arg_val);
#endif
                        /* Raise Error.OutOfBounds */
                        run_raise_exc(run,
                            run->program->builtin->error_outofbounds,
                            index->expr->cspan);
                        /* XXX It should be cspan of the argument. */
                        *res = run_recovery_item(run);
                        return;
                }

                elem_index = elem_index * array->extent[i] + arg_val;

                node = list_next(args, node);
                i += 1;
        }

        if (i < array->rank) {
                printf("Error: Too few indices for array of rank %d",
                    array->rank);
                exit(1);
        }

        /* Construct variable address item. */
        ritem = rdata_item_new(ic_address);
        address = rdata_address_new(ac_var);
        addr_var = rdata_addr_var_new();
        ritem->u.address = address;
        address->u.var_a = addr_var;

        addr_var->vref = array->element[elem_index];

        *res = ritem;
}

/** Index an object (via its indexer).
 *
 * @param run           Runner object
 * @param index         Index operation
 * @param base          Evaluated base expression
 * @param args          Evaluated indices (list of rdata_item_t)
 * @param res           Place to store result
 */
static void run_index_object(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res)
{
        rdata_item_t *ritem;
        rdata_address_t *address;
        rdata_addr_prop_t *addr_prop;
        rdata_aprop_indexed_t *aprop_indexed;
        rdata_var_t *obj_var;
        stree_csi_t *obj_csi;
        rdata_deleg_t *object_d;
        stree_symbol_t *indexer_sym;
        stree_ident_t *indexer_ident;

        list_node_t *node;
        rdata_item_t *arg, *arg_copy;

#ifdef DEBUG_RUN_TRACE
        printf("Run object index operation.\n");
#endif
        (void) index;

        /* Construct property address item. */
        ritem = rdata_item_new(ic_address);
        address = rdata_address_new(ac_prop);
        addr_prop = rdata_addr_prop_new(apc_indexed);
        aprop_indexed = rdata_aprop_indexed_new();
        ritem->u.address = address;
        address->u.prop_a = addr_prop;
        addr_prop->u.indexed = aprop_indexed;

        if (base->ic != ic_address || base->u.address->ac != ac_var) {
                /* XXX Several other cases can occur. */
                printf("Unimplemented: Indexing object varclass via something "
                    "which is not a simple variable reference.\n");
                exit(1);
        }

        /* Find indexer symbol. */
        obj_var = base->u.address->u.var_a->vref;
        assert(obj_var->vc == vc_object);
        indexer_ident = stree_ident_new();
        indexer_ident->sid = strtab_get_sid(INDEXER_IDENT);
        obj_csi = symbol_to_csi(obj_var->u.object_v->class_sym);
        assert(obj_csi != NULL);
        indexer_sym = symbol_search_csi(run->program, obj_csi, indexer_ident);

        if (indexer_sym == NULL) {
                printf("Error: Accessing object which does not have an "
                    "indexer.\n");
                exit(1);
        }

        /* Construct delegate. */
        object_d = rdata_deleg_new();
        object_d->obj = obj_var;
        object_d->sym = indexer_sym;
        aprop_indexed->object_d = object_d;

        /* Copy list of argument values. */
        list_init(&aprop_indexed->args);

        node = list_first(args);
        while (node != NULL) {
                arg = list_node_data(node, rdata_item_t *);

                /*
                 * Clone argument so that original can
                 * be freed.
                 */
                assert(arg->ic == ic_value);
                arg_copy = rdata_item_new(ic_value);
                rdata_value_copy(arg->u.value, &arg_copy->u.value);

                list_append(&aprop_indexed->args, arg_copy);
                node = list_next(args, node);
        }

        *res = ritem;
}

/** Run index operation on string.
 *
 * @param run           Runner object
 * @param index         Index operation
 * @param base          Evaluated base expression
 * @param args          Evaluated indices (list of rdata_item_t)
 * @param res           Place to store result
 */
static void run_index_string(run_t *run, stree_index_t *index,
    rdata_item_t *base, list_t *args, rdata_item_t **res)
{
        list_node_t *node;
        rdata_string_t *string;
        rdata_item_t *base_vi;
        rdata_item_t *arg;

        int i;
        int elem_index;
        int arg_val;
        int rc1, rc2;

        rdata_value_t *value;
        rdata_var_t *cvar;
        rdata_item_t *ritem;
        int cval;

#ifdef DEBUG_RUN_TRACE
        printf("Run string index operation.\n");
#endif
        (void) run;

        run_cvt_value_item(run, base, &base_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        assert(base_vi->u.value->var->vc == vc_string);
        string = base_vi->u.value->var->u.string_v;

        /*
         * Linear index of the desired element. Elements are stored in
         * lexicographic order with the last index changing the fastest.
         */
        node = list_first(args);
        elem_index = 0;

        i = 0;
        while (node != NULL) {
                if (i >= 1) {
                        printf("Error: Too many indices string.\n");
                        exit(1);
                }

                arg = list_node_data(node, rdata_item_t *);
                assert(arg->ic == ic_value);

                if (arg->u.value->var->vc != vc_int) {
                        printf("Error: String index is not an integer.\n");
                        exit(1);
                }

                rc1 = bigint_get_value_int(
                    &arg->u.value->var->u.int_v->value,
                    &arg_val);

                elem_index = arg_val;

                node = list_next(args, node);
                i += 1;
        }

        if (i < 1) {
                printf("Error: Too few indices for string.\n");
                exit(1);
        }

        if (rc1 == EOK)
                rc2 = os_str_get_char(string->value, elem_index, &cval);
        else
                rc2 = EOK;

        if (rc1 != EOK || rc2 != EOK) {
#ifdef DEBUG_RUN_TRACE
                printf("Error: String index (value: %d) is out of range.\n",
                    arg_val);
#endif
                /* Raise Error.OutOfBounds */
                run_raise_exc(run, run->program->builtin->error_outofbounds,
                    index->expr->cspan);
                *res = run_recovery_item(run);
                goto cleanup;
        }

        /* Construct character value. */
        ritem = rdata_item_new(ic_value);
        value = rdata_value_new();
        ritem->u.value = value;

        cvar = rdata_var_new(vc_char);
        cvar->u.char_v = rdata_char_new();
        bigint_init(&cvar->u.char_v->value, cval);
        value->var = cvar;

        *res = ritem;
cleanup:
        rdata_item_destroy(base_vi);
}

/** Run assignment.
 *
 * Executes an assignment. @c NULL is always stored to @a res because
 * an assignment does not have a value.
 *
 * @param run           Runner object
 * @param assign        Assignment expression
 * @param res           Place to store result
*/
static void run_assign(run_t *run, stree_assign_t *assign, rdata_item_t **res)
{
        rdata_item_t *rdest_i, *rsrc_i;
        rdata_item_t *rsrc_vi;

#ifdef DEBUG_RUN_TRACE
        printf("Run assign operation.\n");
#endif
        rdest_i = NULL;
        rsrc_i = NULL;
        rsrc_vi = NULL;

        run_expr(run, assign->dest, &rdest_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        run_expr(run, assign->src, &rsrc_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        run_cvt_value_item(run, rsrc_i, &rsrc_vi);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                goto cleanup;
        }

        assert(rsrc_vi->ic == ic_value);

        if (rdest_i->ic != ic_address) {
                printf("Error: Address expression required on left side of "
                    "assignment operator.\n");
                exit(1);
        }

        run_address_write(run, rdest_i->u.address, rsrc_vi->u.value);

        *res = NULL;
cleanup:
        if (rdest_i != NULL)
                rdata_item_destroy(rdest_i);
        if (rsrc_i != NULL)
                rdata_item_destroy(rsrc_i);
        if (rsrc_vi != NULL)
                rdata_item_destroy(rsrc_vi);
}

/** Execute @c as conversion.
 *
 * @param run           Runner object
 * @param as_op         @c as conversion expression
 * @param res           Place to store result
 */
static void run_as(run_t *run, stree_as_t *as_op, rdata_item_t **res)
{
        rdata_item_t *rarg_i;
        rdata_item_t *rarg_vi;
        rdata_item_t *rarg_di;
        rdata_var_t *arg_vref;
        tdata_item_t *dtype;
        run_proc_ar_t *proc_ar;

        stree_symbol_t *obj_csi_sym;
        stree_csi_t *obj_csi;

#ifdef DEBUG_RUN_TRACE
        printf("Run @c as conversion operation.\n");
#endif
        run_expr(run, as_op->arg, &rarg_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        /*
         * This should always be a reference if the argument is indeed
         * a class instance.
         */
        assert(run_item_get_vc(run, rarg_i) == vc_ref);
        run_cvt_value_item(run, rarg_i, &rarg_vi);
        rdata_item_destroy(rarg_i);

        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        assert(rarg_vi->ic == ic_value);

        if (rarg_vi->u.value->var->u.ref_v->vref == NULL) {
                /* Nil reference is always okay. */
                *res = rarg_vi;
                return;
        }

        run_dereference(run, rarg_vi, NULL, &rarg_di);

        /* Now we should have a variable address. */
        assert(rarg_di->ic == ic_address);
        assert(rarg_di->u.address->ac == ac_var);

        arg_vref = rarg_di->u.address->u.var_a->vref;

        proc_ar = run_get_current_proc_ar(run);
        /* XXX Memoize to avoid recomputing. */
        run_texpr(run->program, proc_ar->proc->outer_symbol->outer_csi,
            as_op->dtype, &dtype);

        assert(arg_vref->vc == vc_object);
        obj_csi_sym = arg_vref->u.object_v->class_sym;
        obj_csi = symbol_to_csi(obj_csi_sym);
        assert(obj_csi != NULL);

        if (tdata_is_csi_derived_from_ti(obj_csi, dtype) != b_true) {
                printf("Error: Run-time type conversion error. Object is "
                    "of type '");
                symbol_print_fqn(obj_csi_sym);
                printf("' which is not derived from '");
                tdata_item_print(dtype);
                printf("'.\n");
                exit(1);
        }

        /* The dereferenced item is not used anymore. */
        rdata_item_destroy(rarg_di);

        *res = rarg_vi;
}

/** Execute boxing operation.
 *
 * XXX We can scrap this special operation once we have constructors.
 *
 * @param run           Runner object
 * @param box           Boxing operation
 * @param res           Place to store result
 */
static void run_box(run_t *run, stree_box_t *box, rdata_item_t **res)
{
        rdata_item_t *rarg_i;
        rdata_item_t *rarg_vi;

        stree_symbol_t *csi_sym;
        stree_csi_t *csi;
        builtin_t *bi;
        rdata_var_t *var;
        rdata_object_t *object;

        sid_t mbr_name_sid;
        rdata_var_t *mbr_var;

#ifdef DEBUG_RUN_TRACE
        printf("Run boxing operation.\n");
#endif
        run_expr(run, box->arg, &rarg_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        run_cvt_value_item(run, rarg_i, &rarg_vi);
        rdata_item_destroy(rarg_i);
        if (run_is_bo(run)) {
                *res = run_recovery_item(run);
                return;
        }

        assert(rarg_vi->ic == ic_value);

        bi = run->program->builtin;

        /* Just to keep the compiler happy. */
        csi_sym = NULL;

        switch (rarg_vi->u.value->var->vc) {
        case vc_bool: csi_sym = bi->boxed_bool; break;
        case vc_char: csi_sym = bi->boxed_char; break;
        case vc_int: csi_sym = bi->boxed_int; break;
        case vc_string: csi_sym = bi->boxed_string; break;

        case vc_ref:
        case vc_deleg:
        case vc_enum:
        case vc_array:
        case vc_object:
        case vc_resource:
        case vc_symbol:
                assert(b_false);
        }

        csi = symbol_to_csi(csi_sym);
        assert(csi != NULL);

        /* Construct object of the relevant boxed type. */
        run_new_csi_inst_ref(run, csi, sn_nonstatic, res);

        /* Set the 'Value' field */

        assert((*res)->ic == ic_value);
        assert((*res)->u.value->var->vc == vc_ref);
        var = (*res)->u.value->var->u.ref_v->vref;
        assert(var->vc == vc_object);
        object = var->u.object_v;

        mbr_name_sid = strtab_get_sid("Value");
        mbr_var = intmap_get(&object->fields, mbr_name_sid);
        assert(mbr_var != NULL);

        rdata_var_write(mbr_var, rarg_vi->u.value);
        rdata_item_destroy(rarg_vi);
}

/** Create new CSI instance and return reference to it.
 *
 * Create a new object, instance of @a csi.
 * XXX This does not work with generics as @a csi cannot specify a generic
 * type.
 *
 * Initialize the fields with default values of their types, but do not
 * run any constructor.
 *
 * If @a sn is @c sn_nonstatic a regular object is created, containing all
 * non-static member variables. If @a sn is @c sn_static a static object
 * is created, containing all static member variables.
 *
 * @param run           Runner object
 * @param csi           CSI to create instance of
 * @param sn            @c sn_static to create a static (class) object,
 *                      @c sn_nonstatic to create a regular object
 * @param res           Place to store result
 */
void run_new_csi_inst_ref(run_t *run, stree_csi_t *csi, statns_t sn,
    rdata_item_t **res)
{
        rdata_var_t *obj_var;

        /* Create object. */
        run_new_csi_inst(run, csi, sn, &obj_var);

        /* Create reference to the new object. */
        run_reference(run, obj_var, res);
}

/** Create new CSI instance.
 *
 * Create a new object, instance of @a csi.
 * XXX This does not work with generics as @a csi cannot specify a generic
 * type.
 *
 * Initialize the fields with default values of their types, but do not
 * run any constructor.
 *
 * If @a sn is @c sn_nonstatic a regular object is created, containing all
 * non-static member variables. If @a sn is @c sn_static a static object
 * is created, containing all static member variables.
 *
 * @param run           Runner object
 * @param csi           CSI to create instance of
 * @param sn            @c sn_static to create a static (class) object,
 *                      @c sn_nonstatic to create a regular object
 * @param res           Place to store result
 */
void run_new_csi_inst(run_t *run, stree_csi_t *csi, statns_t sn,
    rdata_var_t **res)
{
        rdata_object_t *obj;
        rdata_var_t *obj_var;

        stree_symbol_t *csi_sym;
        stree_csimbr_t *csimbr;
        stree_var_t *var;
        statns_t var_sn;

        rdata_var_t *mbr_var;
        list_node_t *node;
        tdata_item_t *field_ti;

        csi_sym = csi_to_symbol(csi);

#ifdef DEBUG_RUN_TRACE
        printf("Create new instance of CSI '");
        symbol_print_fqn(csi_sym);
        printf("'.\n");
#endif

        /* Create the object. */
        obj = rdata_object_new();
        obj->class_sym = csi_sym;
        obj->static_obj = sn;
        intmap_init(&obj->fields);

        obj_var = rdata_var_new(vc_object);
        obj_var->u.object_v = obj;

        /* For this CSI and all base CSIs */
        while (csi != NULL) {

                /* For all members */
                node = list_first(&csi->members);
                while (node != NULL) {
                        csimbr = list_node_data(node, stree_csimbr_t *);

                        /* Is it a member variable? */
                        if (csimbr->cc == csimbr_var) {
                                var = csimbr->u.var;

                                /* Is it static/nonstatic? */
                                var_sn = stree_symbol_has_attr(
                                    var_to_symbol(var), sac_static);
                                if (var_sn == sn) {
                                        /* Compute field type. XXX Memoize. */
                                        run_texpr(run->program, csi, var->type,
                                            &field_ti);

                                        /* Create and initialize field. */
                                        run_var_new(run, field_ti, &mbr_var);

                                        /* Add to field map. */
                                        intmap_set(&obj->fields, var->name->sid,
                                            mbr_var);
                                }
                        }

                        node = list_next(&csi->members, node);
                }

                /* Continue with base CSI */
                csi = csi->base_csi;
        }

        *res = obj_var;
}

/** Run constructor on an object.
 *
 * @param run           Runner object
 * @param obj           Object to run constructor on
 * @param arg_vals      Argument values (list of rdata_item_t)
 */
static void run_object_ctor(run_t *run, rdata_var_t *obj, list_t *arg_vals)
{
        stree_ident_t *ctor_ident;
        stree_symbol_t *csi_sym;
        stree_csi_t *csi;
        stree_symbol_t *ctor_sym;
        stree_ctor_t *ctor;
        run_proc_ar_t *proc_ar;
        rdata_item_t *res;

        csi_sym = obj->u.object_v->class_sym;
        csi = symbol_to_csi(csi_sym);
        assert(csi != NULL);

#ifdef DEBUG_RUN_TRACE
        printf("Run object constructor from CSI '");
        symbol_print_fqn(csi_sym);
        printf("'.\n");
#endif
        ctor_ident = stree_ident_new();
        ctor_ident->sid = strtab_get_sid(CTOR_IDENT);

        /* Find constructor. */
        ctor_sym = symbol_search_csi_no_base(run->program, csi, ctor_ident);
        if (ctor_sym == NULL) {
#ifdef DEBUG_RUN_TRACE
                printf("No constructor found.\n");
#endif
                return;
        }

        ctor = symbol_to_ctor(ctor_sym);
        assert(ctor != NULL);

        /* Create procedure activation record. */
        run_proc_ar_create(run, obj, ctor->proc, &proc_ar);

        /* Fill in argument values. */
        run_proc_ar_set_args(run, proc_ar, arg_vals);

        /* Run the procedure. */
        run_proc(run, proc_ar, &res);

        /* Constructor does not return a value. */
        assert(res == NULL);

        /* Destroy procedure activation record. */
        run_proc_ar_destroy(run, proc_ar);

#ifdef DEBUG_RUN_TRACE
        printf("Returned from constructor..\n");
#endif
}

/** Return boolean value of an item.
 *
 * Try to interpret @a item as a boolean value. If it is not a boolean
 * value, generate an error.
 *
 * @param run           Runner object
 * @param item          Input item
 * @return              Resulting boolean value
 */
bool_t run_item_boolean_value(run_t *run, rdata_item_t *item)
{
        rdata_item_t *vitem;
        rdata_var_t *var;
        bool_t res;

        (void) run;
        run_cvt_value_item(run, item, &vitem);
        if (run_is_bo(run))
                return b_true;

        assert(vitem->ic == ic_value);
        var = vitem->u.value->var;

        assert(var->vc == vc_bool);
        res = var->u.bool_v->value;

        /* Free value item */
        rdata_item_destroy(vitem);
        return res;
}