afw_value_block.c

Go to the documentation of this file.

// See the 'COPYING' file in the project root for licensing information.
/*
 * Interface afw_value Implementation for block
 *
 * Copyright (c) 2010-2023 Clemson University
 *
 */
 
 
#include "afw_internal.h"
 
 
#define impl_afw_value_optional_release NULL
#define impl_afw_value_get_reference NULL
 
 
 
#define impl_afw_value_get_evaluated_meta \
    afw_value_internal_get_evaluated_meta_default
 
#define impl_afw_value_get_evaluated_metas \
    afw_value_internal_get_evaluated_metas_default
 
/* Declares and rti/inf defines for interface afw_value */
#define AFW_IMPLEMENTATION_ID "block"
#define AFW_IMPLEMENTATION_INF_SPECIFIER AFW_DEFINE_CONST_DATA
#define AFW_IMPLEMENTATION_INF_LABEL afw_value_block_inf
#include "afw_value_impl_declares.h"
 
#define IMPL_TEMP_FIX_ASSIGNS(XX) \
    modified_x.p = p; \
    modified_x.xctx = xctx; \
    modified_x.function = &afw_function_definition_ ## XX; \
    modified_x.argv = argv; \
    modified_x.argc = argc; \
 
#define IMPL_TEMP_FIX(XX) \
    afw_function_execute_t modified_x; \
    afw_memory_clear(&modified_x); \
    IMPL_TEMP_FIX_ASSIGNS(XX) \
    x = &modified_x
 
 
 
 
static void
impl_assign(
    const afw_value_t *target,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
static void
impl_assign_value(
    const afw_value_t *target,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx);
 
 
 
static void
impl_set_variable(
    const afw_utf8_t *name,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    afw_xctx_t *xctx)
{
    switch (assignment_type) {
 
    case afw_compile_assignment_type_assign_only:
        afw_xctx_set_defined_variable(name, value, xctx);
        break;
 
    case afw_compile_assignment_type_const:
        afw_xctx_define_variable(name, value, xctx);
        break;
 
    case afw_compile_assignment_type_loc:
        afw_xctx_define_variable(name, value, xctx);
        break;
 
    case afw_compile_assignment_type_define_loc_if_needed:
        afw_xctx_set_local_variable(name, value, xctx);
        break;
 
    default:
        AFW_THROW_ERROR_Z(general, "Internal error", xctx);
    }
 
}
 
 
 
static void
impl_list_destructure(
    const afw_compile_assignment_target_t *at,
    const afw_compile_list_destructure_t *ld,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_compile_assignment_element_t *ae;
    const afw_iterator_t *iterator;
    const afw_value_t *v;
    const afw_list_t *rest;
    afw_boolean_t eol;
 
    if (!afw_value_is_list(value)) {
        AFW_THROW_ERROR_Z(general,
            "List destructure can only be performed on a list", xctx);
    }
 
    for (eol = false,
        iterator = NULL,
        ae = ld->assignment_element,
        v = NULL;
        ae;
        ae = ae->next)
    {
        if (!eol) {
            v = afw_list_get_next_value(
                ((const afw_value_list_t *)value)->internal,
                &iterator, p, xctx);
            if (!v) {
                eol = true;
            }
        }
        if (!ae->assignment_target) {
            continue;
        }
        if (eol) {
            v = ae->default_value;
        }
        if (v) {
            impl_assign_value(ae->assignment_target, v, assignment_type,
                p, xctx);
        }
        else {
            //FIXME ???
        }
    }
 
    if (!eol && ld->rest) {
        for (rest = NULL;;) {
            v = afw_list_get_next_value(
                ((const afw_value_list_t *)value)->internal,
                &iterator, p, xctx);
            if (!v) {
                break;
            }
            if (!rest) {
                rest = afw_list_create_generic(p, xctx);
            }
            afw_list_add_value(rest, v, xctx);
        }
        if (rest) {
            v = afw_value_create_list(rest, p, xctx);
            impl_assign_value(ld->rest, v, assignment_type, p, xctx);
        }
    }
}
 
 
 
static void
impl_object_destructure(
    const afw_compile_assignment_target_t *at,
    const afw_compile_object_destructure_t *od,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_compile_assignment_property_t *ap;
    const afw_object_t *object;
    const afw_iterator_t *iterator;
    const afw_utf8_t *property_name;
    const afw_value_t *v;
    const afw_object_t *rest;
 
    object = afw_value_as_object(value, xctx);
 
    /* Process assignment properties. */
    for (ap = od->assignment_property; ap; ap = ap->next)
    {
        if (ap->is_rename) {
            v = afw_object_get_property(object, ap->property_name, xctx);
            if (!v) {
                v = ap->assignment_element->default_value;
            }
            if (v) {
                impl_assign_value(ap->assignment_element->assignment_target, v,
                    assignment_type, p, xctx);
            }
            else {
                //FIXME ???
            }
        }
        else {
            v = afw_object_get_property(object,
                ap->variable_reference->symbol->name, xctx);
            if (!v) {
                v = ap->default_value;
            }
            if (v) {
                impl_assign_value((const afw_value_t *)ap->variable_reference,
                    v, assignment_type, p, xctx);
            }
            else {
                //FIXME ???
            }
 
        }
    }
 
    /* Add other properties to rest. */
    if (od->rest) {
        rest = afw_object_create_managed(p, xctx);
        for (iterator = NULL;;) {
            v = afw_object_get_next_property(object, &iterator, &property_name,
                xctx);
            if (!v) {
                break;
            }
 
            for (ap = od->assignment_property; ap; ap = ap->next)
            {
                if (
                    (ap->is_rename && afw_utf8_equal(
                        ap->property_name, property_name))
                    ||
                    (!ap->is_rename && afw_utf8_equal(
                        ap->variable_reference->symbol->name, property_name))
                )
                {
                    break;
                }
            }
            if (!ap) {
                afw_object_set_property(rest, property_name, v, xctx);
            }
        }
        v = afw_value_create_object(rest, p, xctx);
        impl_assign_value(od->rest, v, assignment_type, p, xctx);
    }
}
 
 
 
static void
impl_assignment_target(
    const afw_value_assignment_target_t *target,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_compile_assignment_target_t *at =
        target->assignment_target;
 
    switch (at->target_type) {
    case afw_compile_assignment_target_type_list_destructure:
        impl_list_destructure(at, at->list_destructure, value,
            assignment_type, p, xctx);
        break;
 
    case afw_compile_assignment_target_type_object_destructure:
        impl_object_destructure(at, at->object_destructure, value,
            assignment_type, p, xctx);
        break;
 
    case afw_compile_assignment_target_type_variable_reference:
        impl_set_variable(at->variable_reference->symbol->name,
            value, assignment_type, xctx);
        break;
 
    case afw_compile_assignment_target_type_max_type:
    default:
        AFW_THROW_ERROR_FZ(code, xctx, "Invalid case %d", at->target_type);
    }
}
 
 
 
static void
impl_assign(
    const afw_value_t *target,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_assignment_target_t *at;
 
    if (assignment_type == afw_compile_assignment_type_use_assignment_targets)
    {
        if (afw_value_is_assignment_target(target)) {
            at = (const afw_value_assignment_target_t *)target;
            assignment_type = at->assignment_target->assignment_type;
        }
        else {
            AFW_THROW_ERROR_Z(general, "Internal error", xctx);
        }
    }
 
    impl_assign_value(target, value, assignment_type, p, xctx);
}
 
 
 
static void
impl_assign_value(
    const afw_value_t *target,
    const afw_value_t *value,
    afw_compile_internal_assignment_type_t assignment_type,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_assignment_target_t *at;
 
    if (afw_value_is_assignment_target(target)) {
        at = (const afw_value_assignment_target_t *)target;
        impl_assignment_target(at, value, assignment_type, p, xctx);
    }
 
    /* String containing variable name */
    else if (afw_value_is_string(target)) {
        impl_set_variable(
            &((afw_value_string_t *)target)->internal,
            value, assignment_type, xctx);
    }
 
    /* Variable Reference */
    else if (afw_value_is_variable_reference(target)) {
        const afw_value_variable_reference_t *t =
            (afw_value_variable_reference_t *)target;
        impl_set_variable(t->symbol->name, value,
            assignment_type, xctx);
    }
 
    /* Reference by key */
    else if (afw_value_is_reference_by_key(target)) {
        const afw_value_reference_by_key_t *t =
            (afw_value_reference_by_key_t *)target;
        const afw_object_t *object;
        const afw_list_t *list;
        const afw_value_t *key;
        const afw_value_t *aggregate_value;
        const afw_utf8_t *name;
 
        aggregate_value = afw_value_evaluate(t->aggregate_value, p, xctx);
        key = afw_value_evaluate(t->key, p, xctx);
 
        if (afw_value_is_object(aggregate_value)) {
            object = ((const afw_value_object_t *)aggregate_value)->internal;
            if (afw_object_is_immutable(object, xctx)) {
                AFW_THROW_ERROR_Z(general, "Target object is immutable", xctx);
            }
            name = afw_value_is_string(key)
                ? &((const afw_value_string_t *)key)->internal
                : afw_value_as_utf8(key, p, xctx);
            afw_object_set_property(object, name, value, xctx);
        }
 
        else if (afw_value_is_list(aggregate_value)) {
            list = ((const afw_value_list_t *)aggregate_value)->internal;
 
            if (afw_list_is_immutable(list, xctx)) {
                AFW_THROW_ERROR_Z(general, "Target list is immutable", xctx);
            }
 
            if (!afw_value_is_integer(key)) {
                AFW_THROW_ERROR_Z(general, "List index must be integer", xctx);
            }
 
            afw_list_set_value_by_index(list,
                (afw_size_t)((const afw_value_integer_t *)key)->internal,
                value, xctx);
        }
 
        else {
            AFW_THROW_ERROR_Z(general, "Invalid assignment target", xctx);
        }
 
    }
 
    /* Invalid assignment target. */
    else {
        AFW_THROW_ERROR_Z(general, "Invalid assignment target", xctx);
    }
 
}
 
 
 
/* Use by for statement assignments. Result of evaluate is ignored. */
static const afw_value_t *
impl_evaluate_one_or_more_values(
    afw_function_execute_t *x,
    afw_size_t parameter_number,
    const afw_value_t *values,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_t *result;
    const afw_value_t *value;
    const afw_iterator_t *iterator;
    afw_value_block_statement_type_t type;
 
    result = NULL;
    if (afw_value_is_list(values)) {
        iterator = NULL;
        for (;;) {
            value = afw_list_get_next_value(
                ((const afw_value_list_t *)values)->internal,
                &iterator, p, xctx);
            if (!value) {
                break;
            }
            result = afw_value_block_evaluate_statement(x, &type,
                false, false, value, p, xctx);
        }
    }
 
    else {
        result = afw_value_block_evaluate_statement(x, &type,
            false, false, values, p, xctx);
    }
 
    return result;
}
 
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_block(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    const afw_value_block_t *self,
    afw_boolean_t is_loop,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_t *result;
    const afw_compile_value_contextual_t *saved_contextual;
    afw_size_t i;
    int local_top;
 
    /* Push value on evaluation stack. */
    afw_xctx_evaluation_stack_push_value(
        (const afw_value_t *)self, xctx);
    saved_contextual = xctx->error->contextual;
    xctx->error->contextual = self->contextual;
    result = afw_value_null;
 
    local_top = afw_xctx_begin_stack_frame(xctx);
    AFW_TRY{
        for (i = 0; i < self->argc; i++) {
            result = afw_value_block_evaluate_statement(x, type,
                true, is_loop, self->argv[i], p, xctx);
            if (*type != afw_value_block_statement_type_sequential)
            {
                break;
            }
        }
    }
    AFW_FINALLY{
        afw_xctx_end_stack_frame(local_top, xctx);
    }
    AFW_ENDTRY;
 
    /* Pop value from evaluation stack and return result. */
    afw_xctx_evaluation_stack_pop_value(xctx);
    xctx->error->contextual = saved_contextual;
 
    return result;
}
 
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_for(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_size_t argc,
    const afw_value_t * const * argv,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    IMPL_TEMP_FIX(for);
    const afw_value_boolean_t *condition;
    const afw_value_t *result;
    const afw_value_t *increment;
    const afw_value_t *body;
    int local_top;
 
    local_top = afw_xctx_begin_stack_frame(xctx);
    AFW_TRY{
 
        AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(4);
 
        if (AFW_FUNCTION_PARAMETER_IS_PRESENT(1)) {
            impl_evaluate_one_or_more_values(x, 1, argv[1], p, xctx);
        }
 
        increment = NULL;
        if (AFW_FUNCTION_PARAMETER_IS_PRESENT(3)) {
            increment = argv[3];
        }
 
        body = NULL;
        if (AFW_FUNCTION_PARAMETER_IS_PRESENT(4)) {
            body = argv[4];
        }
 
        for (result= afw_value_null;;) {
 
            if (AFW_FUNCTION_PARAMETER_IS_PRESENT(2)) {
                AFW_FUNCTION_EVALUATE_REQUIRED_CONDITION_PARAMETER(condition,
                    2);
                if (!condition->internal) {
                    break;
                }
            }
 
            if (body) {
                result = afw_value_block_evaluate_statement(x, type,
                    true, true, body, p, xctx);
                if (*type == afw_value_block_statement_type_break ||
                    *type == afw_value_block_statement_type_return)
                {
                    break;
                }
            }
 
            if (increment) {
                impl_evaluate_one_or_more_values(x, 3, increment, p, xctx);
            }
        }
    }
    AFW_FINALLY{
        /* We don't want continue/break outside of this loop */
        if (*type == afw_value_block_statement_type_continue || 
            *type == afw_value_block_statement_type_break) 
        {
            *type = afw_value_block_statement_type_sequential;
        }
        afw_xctx_end_stack_frame(local_top, xctx);
    }
    AFW_ENDTRY;
 
    return result;
}
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_foreach(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_size_t argc,
    const afw_value_t *const *argv,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    IMPL_TEMP_FIX(foreach);
    const afw_value_t *result;
    const afw_value_list_t *list;
    const afw_iterator_t *iterator;
    const afw_value_t *value;
    afw_compile_internal_assignment_type_t assignment_type;
    int local_top;
 
    local_top = afw_xctx_begin_stack_frame(xctx);
    AFW_TRY{
 
        AFW_FUNCTION_ASSERT_PARAMETER_COUNT_IS(3);
        AFW_FUNCTION_EVALUATE_REQUIRED_DATA_TYPE_PARAMETER(list, 2, list);
 
        assignment_type = afw_compile_assignment_type_use_assignment_targets;
        for (iterator = NULL;;) {
            value = afw_list_get_next_value(list->internal, &iterator,
                p, xctx);
            if (!value) {
                break;
            }
            impl_assign(argv[1], value, assignment_type, p, xctx);
            assignment_type = afw_compile_assignment_type_assign_only;
            result = afw_value_block_evaluate_statement(x, type,
                true, true, argv[3], p, xctx);
            if (*type == afw_value_block_statement_type_break ||
                *type == afw_value_block_statement_type_return)
            {
                break;
            }
        }
    }
    AFW_FINALLY{
        /* We don't want continue/break outside of this loop */
        if (*type == afw_value_block_statement_type_continue || 
            *type == afw_value_block_statement_type_break) 
        {
            *type = afw_value_block_statement_type_sequential;
        }
        afw_xctx_end_stack_frame(local_top, xctx);
    }
    AFW_ENDTRY;
 
    return result;
}
 
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_do_while(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_size_t argc,
    const afw_value_t *const *argv,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    IMPL_TEMP_FIX(do_while);
    const afw_value_t *result;
    const afw_value_boolean_t *condition;
 
    AFW_FUNCTION_ASSERT_PARAMETER_COUNT_IS(2);
    for (result = afw_value_null;;) {
        result = afw_value_block_evaluate_statement(x, type,
            true, true, argv[2], p, xctx);
        if (*type == afw_value_block_statement_type_break ||
            *type == afw_value_block_statement_type_return)
        {
            break;
        }
        AFW_FUNCTION_EVALUATE_REQUIRED_CONDITION_PARAMETER(condition, 1);
        if (!condition->internal) {
            break;
        }
    }
 
    /* We don't want continue/break outside of this loop */
    if (*type == afw_value_block_statement_type_continue || 
        *type == afw_value_block_statement_type_break) 
    {
        *type = afw_value_block_statement_type_sequential;
    }
 
    return result;
}
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_if(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_size_t argc,
    const afw_value_t * const * argv,
    afw_boolean_t is_loop,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    IMPL_TEMP_FIX(if);
    const afw_value_t *result;
    const afw_value_boolean_t *condition;
 
    AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MIN(2);
    AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(3);
 
    AFW_FUNCTION_EVALUATE_REQUIRED_CONDITION_PARAMETER(condition, 1);
    result = afw_value_null;
    if (condition->internal) {
        result = afw_value_block_evaluate_statement(x, type,
            true, is_loop, argv[2], p, xctx);
    }
    else if (x->argc == 3) {
        result = afw_value_block_evaluate_statement(x, type,
            true, is_loop, argv[3], p, xctx);
    }
 
    return result;
}
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_while(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_size_t argc,
    const afw_value_t * const * argv,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    IMPL_TEMP_FIX(while);
    const afw_value_t *result;
    const afw_value_boolean_t *condition;
 
    AFW_FUNCTION_ASSERT_PARAMETER_COUNT_IS(2);
 
    for (result = afw_value_null;;) {
        AFW_FUNCTION_EVALUATE_REQUIRED_CONDITION_PARAMETER(condition, 1);
        if (!condition->internal) {
            break;
        }
        result = afw_value_block_evaluate_statement(x, type,
            true, true, argv[2], p, xctx);
        if (*type == afw_value_block_statement_type_break ||
            *type == afw_value_block_statement_type_return)
        {
            break;
        }
    }
 
    /* We don't want continue/break outside of this loop */
    if (*type == afw_value_block_statement_type_continue || 
        *type == afw_value_block_statement_type_break) 
    {
        *type = afw_value_block_statement_type_sequential;
    }
 
    return result;
}
 
 
AFW_DEFINE_INTERNAL(const afw_value_t *)
afw_value_block_evaluate_statement(
    afw_function_execute_t *x,
    afw_value_block_statement_type_t *type,
    afw_boolean_t allow_return,
    afw_boolean_t is_loop,
    const afw_value_t *statement,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_t *result;
    const afw_value_call_t *call;
    const afw_compile_value_contextual_t *saved_contextual;
    const afw_value_function_definition_t *function;
 
    afw_function_execute_t modified_x;
    afw_memory_copy(&modified_x, x);
    modified_x.p = p;
    modified_x.xctx = xctx;
    modified_x.function = NULL;
    x = &modified_x;
 
 
    result = afw_value_null;
    *type = afw_value_block_statement_type_sequential;
 
    /* If statement is block, handle special. */
    if (afw_value_is_block(statement)) {
        result = afw_value_block_evaluate_block(x, type,
            (const afw_value_block_t *)statement, is_loop, p, xctx);
    }
 
    /* If statement is special call, handle special. */
    else if (afw_value_is_any_call(statement) &&
        afw_value_is_function_definition(
        ((const afw_value_call_t *)statement)->function_value))
    {
        call = (const afw_value_call_t *)statement;
        function = (const afw_value_function_definition_t *)
            (call->function_value);
        switch (function->scriptSupportNumber) {
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_ASSIGN:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
            modified_x.argc = call->args.argc;
            modified_x.argv = call->args.argv;
            modified_x.function = &afw_function_definition_assign;
 
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_IS(2);
            AFW_FUNCTION_EVALUATE_PARAMETER(statement, 2);
 
            impl_assign(modified_x.argv[1], statement,
                afw_compile_assignment_type_assign_only,
                p, xctx);
            result = statement;
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_BREAK:
            if (!is_loop) {
                AFW_THROW_ERROR_Z(general, "Misplaced break()", xctx);
            }
            modified_x.argc = call->args.argc;
            modified_x.argv = call->args.argv;
            modified_x.function = &afw_function_definition_break;
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(1);
            *type = afw_value_block_statement_type_break;
            if (AFW_FUNCTION_PARAMETER_IS_PRESENT(1)) {
                result = afw_function_evaluate_required_parameter(
                        &modified_x, 1, NULL);
            }
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_CONST:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
            modified_x.argc = call->args.argc;
            modified_x.argv = call->args.argv;
            modified_x.function = &afw_function_definition_const;
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MIN(2);
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(3);
            AFW_FUNCTION_EVALUATE_PARAMETER(statement, 2);
 
            impl_assign(modified_x.argv[1], statement,
                afw_compile_assignment_type_const,
                p, xctx);
            result = statement;
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_CONTINUE:
            if (!is_loop) {
                AFW_THROW_ERROR_Z(general, "Misplaced continue()", xctx);
            }
            modified_x.argc = call->args.argc;
            modified_x.function = &afw_function_definition_continue;
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_IS(0);
 
            *type = afw_value_block_statement_type_continue;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_DO_WHILE:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
 
            result = afw_value_block_evaluate_do_while(x, type,
                call->args.argc, call->args.argv,
                p, xctx);
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_FOR:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
 
            result = afw_value_block_evaluate_for(x, type,
                call->args.argc, call->args.argv,
                p, xctx);
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_FOREACH:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
 
            result = afw_value_block_evaluate_foreach(x, type,
                call->args.argc, call->args.argv,
                p, xctx);
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_IF:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
 
            result = afw_value_block_evaluate_if(x, type,
                call->args.argc, call->args.argv, is_loop,
                p, xctx);
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_LOC:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
            modified_x.argc = call->args.argc;
            modified_x.argv = call->args.argv;
            modified_x.function = &afw_function_definition_loc;
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MIN(1);
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(3);
 
            statement = NULL;
            if (AFW_FUNCTION_PARAMETER_IS_PRESENT(2)) {
                AFW_FUNCTION_EVALUATE_PARAMETER(statement, 2);
            }
 
            impl_assign(modified_x.argv[1], statement,
                afw_compile_assignment_type_loc,
                p, xctx);
            result = statement;
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_RETURN:
            *type = afw_value_block_statement_type_return;
            modified_x.argc = call->args.argc;
            modified_x.argv = call->args.argv;
            modified_x.function = &afw_function_definition_return;
            if (!allow_return) {
                AFW_THROW_ERROR_Z(general, "Misplaced return()", xctx);
            }
            AFW_FUNCTION_ASSERT_PARAMETER_COUNT_MAX(1);
            if (AFW_FUNCTION_PARAMETER_IS_PRESENT(1)) {
                /* NULL (undefined) is okay here. */
                result = afw_function_evaluate_parameter(&modified_x, 1,
                        NULL);
            }
            break;
 
        case AFW_VALUE_SCRIPT_SUPPORT_NUMBER_WHILE:
            afw_xctx_evaluation_stack_push_value(statement, xctx);
            saved_contextual = xctx->error->contextual;
            xctx->error->contextual = call->args.contextual;
 
            result = afw_value_block_evaluate_while(x, type,
                call->args.argc, call->args.argv,
                p, xctx);
 
            afw_xctx_evaluation_stack_pop_value(xctx);
            xctx->error->contextual = saved_contextual;
            break;
 
        default:
            result = afw_value_evaluate(statement, p, xctx);
        }
    }
 
    /* If statement is not special call, just evaluate. */
    else {
        result = afw_value_evaluate(statement, p, xctx);
    }
 
    return result;
}
 
 
 
AFW_DEFINE(const afw_value_block_t *)
afw_value_block_allocated_and_link(
    const afw_compile_value_contextual_t *contextual,
    afw_value_compiled_value_t *compiled_value,
    afw_size_t *block_count,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    afw_value_block_t *block;
 
    /* Error if top block has already ended. */
    if (compiled_value->top_block &&
        !compiled_value->current_block)
    {
        /*
         * This is probably caused by parent being passed with top_block
         * but already backed out of current_block.
         */
        AFW_THROW_ERROR_Z(general, "Block block underflow", xctx);
 
    }
    else {
        block = afw_pool_calloc_type(p, afw_value_block_t, xctx);
        block->inf = &afw_value_block_inf;
        block->contextual = contextual;
    }
    if (!compiled_value->top_block) {
        compiled_value->top_block = block;
    }
    else {
        block->parent_block = compiled_value->current_block;
        block->depth = block->parent_block->depth + 1;
        (*block_count)++;
        block->number = *block_count;
        if (!block->parent_block->first_child_block) {
            block->parent_block->first_child_block = block;
        }
        else {
            block->parent_block->final_child_block->next_sibling_block = block;
        }
        block->parent_block->final_child_block = block;
    }
    compiled_value->current_block = block;
 
    return (const afw_value_block_t*)block;
}
 
 
 
AFW_DEFINE(const afw_value_t *)
afw_value_block_finalize(
    const afw_value_block_t *block,
    afw_size_t argc,
    const afw_value_t * const *argv,
    afw_xctx_t *xctx)
{
    afw_value_block_t *self = (afw_value_block_t *)block;
 
    self->argc = argc;
    self->argv = argv;
 
    return (const afw_value_t *)self;
}
 
 
 
/*
 * Implementation of method optional_evaluate for interface afw_value.
 */
const afw_value_t *
impl_afw_value_optional_evaluate(
    const afw_value_t * instance,
    const afw_pool_t * p,
    afw_xctx_t *xctx)
{
    const afw_value_t *result;
    afw_value_block_statement_type_t type;
    afw_function_execute_t x;
 
    x.p = p;
    x.xctx = xctx;
 
    /* Evaluate block. */
    result = afw_value_block_evaluate_block(&x, &type, 
        (const afw_value_block_t *)instance, false, p, xctx);
 
    return result;
}
 
/*
 * Implementation of method get_data_type for interface afw_value.
 */
const afw_data_type_t *
impl_afw_value_get_data_type(
    const afw_value_t * instance,
    afw_xctx_t *xctx)
{
    return NULL;
}
 
/*
 * Implementation of method get_evaluated_data_type for interface afw_value.
 */
const afw_data_type_t *
impl_afw_value_get_evaluated_data_type(
    const afw_value_t * instance,
    afw_xctx_t *xctx)
{
    return NULL;
}
 
/*
 * Implementation of method get_evaluated_data_type_parameter for interface
 * afw_value.
 */
const afw_utf8_t *
impl_afw_value_get_evaluated_data_type_parameter(
    const afw_value_t * instance,
    afw_xctx_t *xctx)
{
    return NULL;
}
 
 
/*
 * Implementation of method decompile for interface afw_value.
 */
void
impl_afw_value_produce_compiler_listing(
    const afw_value_t *instance,
    const afw_writer_t *writer,
    afw_xctx_t *xctx)
{
    const afw_value_block_t *self =
        (const afw_value_block_t *)instance;
    afw_size_t i;
 
    afw_value_compiler_listing_begin_value(writer, instance,
        self->contextual, xctx);
 
    afw_writer_write_z(writer, " number=", xctx);
    afw_writer_write_size(writer, self->number, xctx);
 
    afw_writer_write_z(writer, ": [", xctx);
    afw_writer_write_eol(writer, xctx);
    afw_writer_increment_indent(writer, xctx);
 
    AFW_VALUE_COMPILER_LISTING_IF_NOT_LIMIT_EXCEEDED
    for (i = 0; i < self->argc; i++) {
        afw_value_produce_compiler_listing(self->argv[i], writer, xctx);
    }
 
    afw_writer_decrement_indent(writer, xctx);
    afw_writer_write_z(writer, "]", xctx);
 
    afw_writer_write_eol(writer, xctx);
}
 
 
 
/*
 * Implementation of method decompile for interface afw_value.
 */
void
impl_afw_value_decompile(
    const afw_value_t * instance,
    const afw_writer_t * writer,
    afw_xctx_t *xctx)
{
    /*
 
    if (self->qualifier.len > 0) {
        afw_writer_write_utf8(writer, &self->qualifier, xctx);
        afw_writer_write_z(writer, "::", xctx);
    }
    afw_writer_write_utf8(writer, &self->name, xctx);
    afw_value_decompile_call_args(writer, 0, &self->args, xctx);
 
     */
}
 
 
/*
 * Implementation of method get_info for interface afw_value.
 */
void
impl_afw_value_get_info(
    const afw_value_t *instance,
    afw_value_info_t *info,
    const afw_pool_t *p,
    afw_xctx_t *xctx)
{
    const afw_value_block_t *self =
        (const afw_value_block_t *)instance;
 
    afw_memory_clear(info);
    info->value_inf_id = &instance->inf->rti.implementation_id;
    info->contextual = self->contextual;
}