#include <cubescript/cubescript.hh>
#include "cs_vm.hh"
#include "cs_util.hh"

#include <limits>

namespace cscript {

struct cs_cmd_internal {
    static void call(
        cs_state &cs, cs_command *c, cs_value_r args, cs_value &ret
    ) {
        c->p_cb_cftv(cs, args, ret);
    }

    static bool has_cb(cs_ident *id) {
        if (!id->is_command() && !id->is_special()) {
            return false;
        }
        cs_command *cb = static_cast<cs_command *>(id);
        return !!cb->p_cb_cftv;
    }
};

static inline void cs_push_alias(cs_ident *id, cs_ident_stack &st) {
    if (id->is_alias() && (id->get_index() >= MaxArguments)) {
        cs_value nv;
        cs_alias_internal::push_arg(static_cast<cs_alias *>(id), nv, st);
    }
}

static inline void cs_pop_alias(cs_ident *id) {
    if (id->is_alias() && (id->get_index() >= MaxArguments)) {
        cs_alias_internal::pop_arg(static_cast<cs_alias *>(id));
    }
}

cs_stack_state::cs_stack_state(cs_state &cs, cs_stack_state_node *nd, bool gap):
    p_state(cs), p_node(nd), p_gap(gap)
{}
cs_stack_state::cs_stack_state(cs_stack_state &&st):
    p_state(st.p_state), p_node(st.p_node), p_gap(st.p_gap)
{
    st.p_node = nullptr;
    st.p_gap = false;
}

cs_stack_state::~cs_stack_state() {
    size_t len = 0;
    for (cs_stack_state_node const *nd = p_node; nd; nd = nd->next) {
        ++len;
    }
    p_state.p_state->destroy_array(p_node, len);
}

cs_stack_state &cs_stack_state::operator=(cs_stack_state &&st) {
    p_node = st.p_node;
    p_gap = st.p_gap;
    st.p_node = nullptr;
    st.p_gap = false;
    return *this;
}

cs_stack_state_node const *cs_stack_state::get() const {
    return p_node;
}

bool cs_stack_state::gap() const {
    return p_gap;
}

cs_stack_state cs_error::save_stack(cs_state &cs) {
    cs_ivar *dalias = static_cast<cs_ivar *>(cs.p_state->identmap[DbgaliasIdx]);
    if (!dalias->get_value()) {
        return cs_stack_state(cs, nullptr, !!cs.p_callstack);
    }
    int total = 0, depth = 0;
    for (cs_identLink *l = cs.p_callstack; l; l = l->next) {
        total++;
    }
    if (!total) {
        return cs_stack_state(cs, nullptr, false);
    }
    cs_stack_state_node *st = cs.p_state->create_array<cs_stack_state_node>(
        std::min(total, dalias->get_value())
    );
    cs_stack_state_node *ret = st, *nd = st;
    ++st;
    for (cs_identLink *l = cs.p_callstack; l; l = l->next) {
        ++depth;
        if (depth < dalias->get_value()) {
            nd->id = l->id;
            nd->index = total - depth + 1;
            if (!l->next) {
                nd->next = nullptr;
            } else {
                nd->next = st;
            }
            nd = st++;
        } else if (!l->next) {
            nd->id = l->id;
            nd->index = 1;
            nd->next = nullptr;
        }
    }
    return cs_stack_state(cs, ret, total > dalias->get_value());
}

ostd::string_range cs_error::save_msg(
    cs_state &cs, ostd::string_range msg
) {
    if (msg.size() > sizeof(cs.p_errbuf)) {
        msg = msg.slice(0, sizeof(cs.p_errbuf));
    }
    cs_gen_state *gs = cs.p_pstate;
    if (gs) {
        /* we can attach line number */
        std::size_t sz = 0;
        try {
            ostd::char_range r(cs.p_errbuf, cs.p_errbuf + sizeof(cs.p_errbuf));
            if (!gs->src_name.empty()) {
                sz = ostd::format(
                    ostd::counting_sink(r), "%s:%d: %s", gs->src_name,
                    gs->current_line, msg
                ).get_written();
            } else {
                sz = ostd::format(
                    ostd::counting_sink(r), "%d: %s", gs->current_line, msg
                ).get_written();
            }
        } catch (...) {
            memcpy(cs.p_errbuf, msg.data(), msg.size());
            sz = msg.size();
        }
        return ostd::string_range(cs.p_errbuf, cs.p_errbuf + sz);
    }
    memcpy(cs.p_errbuf, msg.data(), msg.size());
    return ostd::string_range(cs.p_errbuf, cs.p_errbuf + msg.size());
}

static void bcode_ref(uint32_t *code) {
    if (!code) {
        return;
    }
    if ((*code & CsCodeOpMask) == CsCodeStart) {
        bcode_incr(code);
        return;
    }
    switch (code[-1]&CsCodeOpMask) {
        case CsCodeStart:
            bcode_incr(&code[-1]);
            break;
        case CsCodeOffset:
            code -= std::ptrdiff_t(code[-1] >> 8);
            bcode_incr(code);
            break;
    }
}

static void bcode_unref(uint32_t *code) {
    if (!code) {
        return;
    }
    if ((*code & CsCodeOpMask) == CsCodeStart) {
        bcode_decr(code);
        return;
    }
    switch (code[-1]&CsCodeOpMask) {
        case CsCodeStart:
            bcode_decr(&code[-1]);
            break;
        case CsCodeOffset:
            code -= std::ptrdiff_t(code[-1] >> 8);
            bcode_decr(code);
            break;
    }
}

cs_bcode_ref::cs_bcode_ref(cs_bcode *v): p_code(v) {
    bcode_ref(reinterpret_cast<uint32_t *>(p_code));
}
cs_bcode_ref::cs_bcode_ref(cs_bcode_ref const &v): p_code(v.p_code) {
    bcode_ref(reinterpret_cast<uint32_t *>(p_code));
}

cs_bcode_ref::~cs_bcode_ref() {
    bcode_unref(reinterpret_cast<uint32_t *>(p_code));
}

cs_bcode_ref &cs_bcode_ref::operator=(cs_bcode_ref const &v) {
    bcode_unref(reinterpret_cast<uint32_t *>(p_code));
    p_code = v.p_code;
    bcode_ref(reinterpret_cast<uint32_t *>(p_code));
    return *this;
}

cs_bcode_ref &cs_bcode_ref::operator=(cs_bcode_ref &&v) {
    bcode_unref(reinterpret_cast<uint32_t *>(p_code));
    p_code = v.p_code;
    v.p_code = nullptr;
    return *this;
}

static inline uint32_t *forcecode(cs_state &cs, cs_value &v) {
    uint32_t *code = reinterpret_cast<uint32_t *>(v.get_code());
    if (!code) {
        cs_gen_state gs(cs);
        gs.code.reserve(64);
        gs.gen_main(v.get_str());
        gs.done();
        uint32_t *cbuf = new uint32_t[gs.code.size()];
        memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(uint32_t));
        v.set_code(reinterpret_cast<cs_bcode *>(cbuf + 1));
        code = reinterpret_cast<uint32_t *>(v.get_code());
    }
    return code;
}

static inline void forcecond(cs_state &cs, cs_value &v) {
    switch (v.get_type()) {
        case cs_value_type::String:
        case cs_value_type::Macro:
        case cs_value_type::Cstring:
            if (!v.get_strr().empty()) {
                forcecode(cs, v);
            } else {
                v.set_int(0);
            }
            break;
        default:
            break;
    }
}

static uint32_t emptyblock[CsValAny][2] = {
    { CsCodeStart + 0x100, CsCodeExit | CsRetNull },
    { CsCodeStart + 0x100, CsCodeExit | CsRetInt },
    { CsCodeStart + 0x100, CsCodeExit | CsRetFloat },
    { CsCodeStart + 0x100, CsCodeExit | CsRetString }
};

static inline void force_arg(cs_value &v, int type) {
    switch (type) {
        case CsRetString:
            if (v.get_type() != cs_value_type::String) {
                v.force_str();
            }
            break;
        case CsRetInt:
            if (v.get_type() != cs_value_type::Int) {
                v.force_int();
            }
            break;
        case CsRetFloat:
            if (v.get_type() != cs_value_type::Float) {
                v.force_float();
            }
            break;
    }
}

static uint32_t *skipcode(uint32_t *code) {
    int depth = 0;
    for (;;) {
        uint32_t op = *code++;
        switch (op & 0xFF) {
            case CsCodeMacro:
            case CsCodeVal | CsRetString: {
                uint32_t len = op >> 8;
                code += len / sizeof(uint32_t) + 1;
                continue;
            }
            case CsCodeBlock:
            case CsCodeJump:
            case CsCodeJumpB | CsCodeFlagTrue:
            case CsCodeJumpB | CsCodeFlagFalse:
            case CsCodeJumpResult | CsCodeFlagTrue:
            case CsCodeJumpResult | CsCodeFlagFalse: {
                uint32_t len = op >> 8;
                code += len;
                continue;
            }
            case CsCodeEnter:
            case CsCodeEnterResult:
                ++depth;
                continue;
            case CsCodeExit | CsRetNull:
            case CsCodeExit | CsRetString:
            case CsCodeExit | CsRetInt:
            case CsCodeExit | CsRetFloat:
                if (depth <= 0) {
                    return code;
                }
                --depth;
                continue;
        }
    }
}

cs_bcode *cs_copy_code(cs_bcode *c) {
    uint32_t *bcode = reinterpret_cast<uint32_t *>(c);
    uint32_t *end = skipcode(bcode);
    uint32_t *dst = new uint32_t[end - bcode + 1];
    *dst++ = CsCodeStart;
    memcpy(dst, bcode, (end - bcode) * sizeof(uint32_t));
    return reinterpret_cast<cs_bcode *>(dst);
}

static inline void callcommand(
    cs_state &cs, cs_command *id, cs_value *args, cs_value &res, int numargs,
    bool lookup = false
) {
    int i = -1, fakeargs = 0;
    bool rep = false;
    for (auto fmt = id->get_args(); !fmt.empty(); ++fmt) {
        switch (*fmt) {
            case 'i':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_int(0);
                    fakeargs++;
                } else {
                    args[i].force_int();
                }
                break;
            case 'b':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_int(std::numeric_limits<cs_int>::min());
                    fakeargs++;
                } else {
                    args[i].force_int();
                }
                break;
            case 'f':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_float(0.0f);
                    fakeargs++;
                } else {
                    args[i].force_float();
                }
                break;
            case 'F':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_float(args[i - 1].get_float());
                    fakeargs++;
                } else {
                    args[i].force_float();
                }
                break;
            case 'S':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_str("");
                    fakeargs++;
                } else {
                    args[i].force_str();
                }
                break;
            case 's':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_cstr("");
                    fakeargs++;
                } else {
                    args[i].force_str();
                }
                break;
            case 'T':
            case 't':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_null();
                    fakeargs++;
                }
                break;
            case 'E':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_null();
                    fakeargs++;
                } else {
                    forcecond(cs, args[i]);
                }
                break;
            case 'e':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_code(
                        reinterpret_cast<cs_bcode *>(emptyblock[CsValNull] + 1)
                    );
                    fakeargs++;
                } else {
                    forcecode(cs, args[i]);
                }
                break;
            case 'r':
                if (++i >= numargs) {
                    if (rep) {
                        break;
                    }
                    args[i].set_ident(cs.p_state->identmap[DummyIdx]);
                    fakeargs++;
                } else {
                    cs.force_ident(args[i]);
                }
                break;
            case '$':
                i += 1;
                args[i].set_ident(id);
                break;
            case 'N':
                i += 1;
                args[i].set_int(cs_int(lookup ? -1 : i - fakeargs));
                break;
            case 'C': {
                i = std::max(i + 1, numargs);
                auto buf = ostd::appender<cs_string>();
                cscript::util::tvals_concat(buf, ostd::iter(args, args + i), " ");
                cs_value tv;
                tv.set_str(std::move(buf.get()));
                cs_cmd_internal::call(cs, id, cs_value_r(&tv, &tv + 1), res);
                return;
            }
            case 'V':
                i = std::max(i + 1, numargs);
                cs_cmd_internal::call(cs, id, ostd::iter(args, args + i), res);
                return;
            case '1':
            case '2':
            case '3':
            case '4':
                if (i + 1 < numargs) {
                    fmt = ostd::string_range{
                        &fmt[-int(*fmt) + '0' - 1], &fmt[fmt.size()]
                    };
                    rep = true;
                }
                break;
        }
    }
    ++i;
    cs_cmd_internal::call(cs, id, cs_value_r(args, args + i), res);
}

static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result);

static inline void cs_call_alias(
    cs_state &cs, cs_alias *a, cs_value *args, cs_value &result,
    int callargs, int &nargs, int offset, int skip, uint32_t op
) {
    cs_ivar *anargs = static_cast<cs_ivar *>(cs.p_state->identmap[NumargsIdx]);
    cs_ident_stack argstack[MaxArguments];
    for(int i = 0; i < callargs; i++) {
        cs_alias_internal::push_arg(
            static_cast<cs_alias *>(cs.p_state->identmap[i]),
            args[offset + i], argstack[i], false
        );
    }
    int oldargs = anargs->get_value();
    anargs->set_value(callargs);
    int oldflags = cs.identflags;
    cs.identflags |= a->get_flags()&CS_IDF_OVERRIDDEN;
    cs_identLink aliaslink = {
        a, cs.p_callstack, (1<<callargs)-1, argstack
    };
    cs.p_callstack = &aliaslink;
    uint32_t *codep = reinterpret_cast<uint32_t *>(
        cs_alias_internal::compile_code(a, cs)
    );
    bcode_incr(codep);
    cs_do_and_cleanup([&]() {
        runcode(cs, codep+1, result);
    }, [&]() {
        bcode_decr(codep);
        cs.p_callstack = aliaslink.next;
        cs.identflags = oldflags;
        for (int i = 0; i < callargs; i++) {
            cs_alias_internal::pop_arg(
                static_cast<cs_alias *>(cs.p_state->identmap[i])
            );
        }
        int argmask = aliaslink.usedargs & int(~0U << callargs);
        for (; argmask; ++callargs) {
            if (argmask & (1 << callargs)) {
                cs_alias_internal::pop_arg(static_cast<cs_alias *>(
                    cs.p_state->identmap[callargs])
                );
                argmask &= ~(1 << callargs);
            }
        }
        force_arg(result, op & CsCodeRetMask);
        anargs->set_value(oldargs);
        nargs = offset - skip;
    });
}

static constexpr int MaxRunDepth = 255;
static thread_local int rundepth = 0;

struct RunDepthRef {
    RunDepthRef() = delete;
    RunDepthRef(cs_state &cs) {
        if (rundepth >= MaxRunDepth) {
            throw cs_error(cs, "exceeded recursion limit");
        }
        ++rundepth;
    }
    RunDepthRef(RunDepthRef const &) = delete;
    RunDepthRef(RunDepthRef &&) = delete;
    ~RunDepthRef() { --rundepth; }
};

static inline cs_alias *cs_get_lookup_id(cs_state &cs, uint32_t op) {
    cs_ident *id = cs.p_state->identmap[op >> 8];
    if (id->get_flags() & CS_IDF_UNKNOWN) {
        throw cs_error(cs, "unknown alias lookup: %s", id->get_name());
    }
    return static_cast<cs_alias *>(id);
}

static inline cs_alias *cs_get_lookuparg_id(cs_state &cs, uint32_t op) {
    cs_ident *id = cs.p_state->identmap[op >> 8];
    if (!cs_is_arg_used(cs, id)) {
        return nullptr;
    }
    return static_cast<cs_alias *>(id);
}

static inline int cs_get_lookupu_type(
    cs_state &cs, cs_value &arg, cs_ident *&id, uint32_t op
) {
    if (
        arg.get_type() != cs_value_type::String &&
        arg.get_type() != cs_value_type::Macro &&
        arg.get_type() != cs_value_type::Cstring
    ) {
        return -2; /* default case */
    }
    id = cs.get_ident(arg.get_strr());
    if (id) {
        switch(id->get_type()) {
            case cs_ident_type::Alias:
                if (id->get_flags() & CS_IDF_UNKNOWN) {
                    break;
                }
                if ((id->get_index() < MaxArguments) && !cs_is_arg_used(cs, id)) {
                    return CsIdUnknown;
                }
                return CsIdAlias;
            case cs_ident_type::Svar:
                return CsIdSvar;
            case cs_ident_type::Ivar:
                return CsIdIvar;
            case cs_ident_type::Fvar:
                return CsIdFvar;
            case cs_ident_type::Command: {
                arg.set_null();
                cs_value buf[MaxArguments];
                callcommand(cs, static_cast<cs_command *>(id), buf, arg, 0, true);
                force_arg(arg, op & CsCodeRetMask);
                return -2; /* ignore */
            }
            default:
                return CsIdUnknown;
        }
    }
    throw cs_error(cs, "unknown alias lookup: %s", arg.get_strr());
}

static uint32_t *runcode(cs_state &cs, uint32_t *code, cs_value &result) {
    result.set_null();
    RunDepthRef level{cs}; /* incr and decr on scope exit */
    int numargs = 0;
    cs_value args[MaxArguments + MaxResults];
    auto &chook = cs.get_call_hook();
    if (chook) {
        chook(cs);
    }
    for (;;) {
        uint32_t op = *code++;
        switch (op & 0xFF) {
            case CsCodeStart:
            case CsCodeOffset:
                continue;

            case CsCodeNull | CsRetNull:
                result.set_null();
                continue;
            case CsCodeNull | CsRetString:
                result.set_str("");
                continue;
            case CsCodeNull | CsRetInt:
                result.set_int(0);
                continue;
            case CsCodeNull | CsRetFloat:
                result.set_float(0.0f);
                continue;

            case CsCodeFalse | CsRetString:
                result.set_str("0");
                continue;
            case CsCodeFalse | CsRetNull:
            case CsCodeFalse | CsRetInt:
                result.set_int(0);
                continue;
            case CsCodeFalse | CsRetFloat:
                result.set_float(0.0f);
                continue;

            case CsCodeTrue | CsRetString:
                result.set_str("1");
                continue;
            case CsCodeTrue | CsRetNull:
            case CsCodeTrue | CsRetInt:
                result.set_int(1);
                continue;
            case CsCodeTrue | CsRetFloat:
                result.set_float(1.0f);
                continue;

            case CsCodeNot | CsRetString:
                --numargs;
                result.set_str(args[numargs].get_bool() ? "0" : "1");
                continue;
            case CsCodeNot | CsRetNull:
            case CsCodeNot | CsRetInt:
                --numargs;
                result.set_int(!args[numargs].get_bool());
                continue;
            case CsCodeNot | CsRetFloat:
                --numargs;
                result.set_float(cs_float(!args[numargs].get_bool()));
                continue;

            case CsCodePop:
                numargs -= 1;
                continue;
            case CsCodeEnter:
                code = runcode(cs, code, args[numargs++]);
                continue;
            case CsCodeEnterResult:
                code = runcode(cs, code, result);
                continue;
            case CsCodeExit | CsRetString:
            case CsCodeExit | CsRetInt:
            case CsCodeExit | CsRetFloat:
                force_arg(result, op & CsCodeRetMask);
            /* fallthrough */
            case CsCodeExit | CsRetNull:
                return code;
            case CsCodeResultArg | CsRetString:
            case CsCodeResultArg | CsRetInt:
            case CsCodeResultArg | CsRetFloat:
                force_arg(result, op & CsCodeRetMask);
            /* fallthrough */
            case CsCodeResultArg | CsRetNull:
                args[numargs++] = std::move(result);
                continue;
            case CsCodePrint:
                cs.print_var(static_cast<cs_var *>(cs.p_state->identmap[op >> 8]));
                continue;

            case CsCodeLocal: {
                int numlocals = op >> 8, offset = numargs - numlocals;
                cs_ident_stack locals[MaxArguments];
                for (int i = 0; i < numlocals; ++i) {
                    cs_push_alias(args[offset + i].get_ident(), locals[i]);
                }
                cs_do_and_cleanup([&]() {
                    code = runcode(cs, code, result);
                }, [&]() {
                    for (int i = offset; i < numargs; i++) {
                        cs_pop_alias(args[i].get_ident());
                    }
                });
                return code;
            }

            case CsCodeDoArgs | CsRetNull:
            case CsCodeDoArgs | CsRetString:
            case CsCodeDoArgs | CsRetInt:
            case CsCodeDoArgs | CsRetFloat:
                cs_do_args(cs, [&]() {
                    cs.run(args[--numargs].get_code(), result);
                    force_arg(result, op & CsCodeRetMask);
                });
                continue;
            /* fallthrough */
            case CsCodeDo | CsRetNull:
            case CsCodeDo | CsRetString:
            case CsCodeDo | CsRetInt:
            case CsCodeDo | CsRetFloat:
                cs.run(args[--numargs].get_code(), result);
                force_arg(result, op & CsCodeRetMask);
                continue;

            case CsCodeJump: {
                uint32_t len = op >> 8;
                code += len;
                continue;
            }
            case CsCodeJumpB | CsCodeFlagTrue: {
                uint32_t len = op >> 8;
                if (args[--numargs].get_bool()) {
                    code += len;
                }
                continue;
            }
            case CsCodeJumpB | CsCodeFlagFalse: {
                uint32_t len = op >> 8;
                if (!args[--numargs].get_bool()) {
                    code += len;
                }
                continue;
            }
            case CsCodeJumpResult | CsCodeFlagTrue: {
                uint32_t len = op >> 8;
                --numargs;
                if (args[numargs].get_type() == cs_value_type::Code) {
                    cs.run(args[numargs].get_code(), result);
                } else {
                    result = std::move(args[numargs]);
                }
                if (result.get_bool()) {
                    code += len;
                }
                continue;
            }
            case CsCodeJumpResult | CsCodeFlagFalse: {
                uint32_t len = op >> 8;
                --numargs;
                if (args[numargs].get_type() == cs_value_type::Code) {
                    cs.run(args[numargs].get_code(), result);
                } else {
                    result = std::move(args[numargs]);
                }
                if (!result.get_bool()) {
                    code += len;
                }
                continue;
            }
            case CsCodeBreak | CsCodeFlagFalse:
                if (cs.is_in_loop()) {
                    throw CsBreakException();
                } else {
                    throw cs_error(cs, "no loop to break");
                }
                break;
            case CsCodeBreak | CsCodeFlagTrue:
                if (cs.is_in_loop()) {
                    throw CsContinueException();
                } else {
                    throw cs_error(cs, "no loop to continue");
                }
                break;

            case CsCodeMacro: {
                uint32_t len = op >> 8;
                args[numargs++].set_macro(ostd::string_range(
                    reinterpret_cast<char const *>(code),
                    reinterpret_cast<char const *>(code) + len
                ));
                code += len / sizeof(uint32_t) + 1;
                continue;
            }

            case CsCodeVal | CsRetString: {
                uint32_t len = op >> 8;
                args[numargs++].set_str(cs_string{
                    reinterpret_cast<char const *>(code),
                    reinterpret_cast<char const *>(code) + len
                });
                code += len / sizeof(uint32_t) + 1;
                continue;
            }
            case CsCodeValInt | CsRetString: {
                char s[4] = {
                    char((op >> 8) & 0xFF),
                    char((op >> 16) & 0xFF),
                    char((op >> 24) & 0xFF), '\0'
                };
                /* gotta cast or r.size() == potentially 3 */
                args[numargs++].set_str(static_cast<char const *>(s));
                continue;
            }
            case CsCodeVal | CsRetNull:
            case CsCodeValInt | CsRetNull:
                args[numargs++].set_null();
                continue;
            case CsCodeVal | CsRetInt:
                args[numargs++].set_int(
                    *reinterpret_cast<cs_int const *>(code)
                );
                code += CsTypeStorageSize<cs_int>;
                continue;
            case CsCodeValInt | CsRetInt:
                args[numargs++].set_int(cs_int(op) >> 8);
                continue;
            case CsCodeVal | CsRetFloat:
                args[numargs++].set_float(
                    *reinterpret_cast<cs_float const *>(code)
                );
                code += CsTypeStorageSize<cs_float>;
                continue;
            case CsCodeValInt | CsRetFloat:
                args[numargs++].set_float(cs_float(cs_int(op) >> 8));
                continue;

            case CsCodeDup | CsRetNull:
                args[numargs - 1].get_val(args[numargs]);
                numargs++;
                continue;
            case CsCodeDup | CsRetInt:
                args[numargs].set_int(args[numargs - 1].get_int());
                numargs++;
                continue;
            case CsCodeDup | CsRetFloat:
                args[numargs].set_float(args[numargs - 1].get_float());
                numargs++;
                continue;
            case CsCodeDup | CsRetString:
                args[numargs].set_str(args[numargs - 1].get_str());
                numargs++;
                continue;

            case CsCodeForce | CsRetString:
                args[numargs - 1].force_str();
                continue;
            case CsCodeForce | CsRetInt:
                args[numargs - 1].force_int();
                continue;
            case CsCodeForce | CsRetFloat:
                args[numargs - 1].force_float();
                continue;

            case CsCodeResult | CsRetNull:
                result = std::move(args[--numargs]);
                continue;
            case CsCodeResult | CsRetString:
            case CsCodeResult | CsRetInt:
            case CsCodeResult | CsRetFloat:
                result = std::move(args[--numargs]);
                force_arg(result, op & CsCodeRetMask);
                continue;

            case CsCodeEmpty | CsRetNull:
                args[numargs++].set_code(
                    reinterpret_cast<cs_bcode *>(emptyblock[CsValNull] + 1)
                );
                break;
            case CsCodeEmpty | CsRetString:
                args[numargs++].set_code(
                    reinterpret_cast<cs_bcode *>(emptyblock[CsValString] + 1)
                );
                break;
            case CsCodeEmpty | CsRetInt:
                args[numargs++].set_code(
                    reinterpret_cast<cs_bcode *>(emptyblock[CsValInt] + 1)
                );
                break;
            case CsCodeEmpty | CsRetFloat:
                args[numargs++].set_code(
                    reinterpret_cast<cs_bcode *>(emptyblock[CsValFloat] + 1)
                );
                break;
            case CsCodeBlock: {
                uint32_t len = op >> 8;
                args[numargs++].set_code(
                    reinterpret_cast<cs_bcode *>(code + 1)
                );
                code += len;
                continue;
            }
            case CsCodeCompile: {
                cs_value &arg = args[numargs - 1];
                cs_gen_state gs(cs);
                switch (arg.get_type()) {
                    case cs_value_type::Int:
                        gs.code.reserve(8);
                        gs.code.push_back(CsCodeStart);
                        gs.gen_int(arg.get_int());
                        gs.code.push_back(CsCodeResult);
                        gs.code.push_back(CsCodeExit);
                        break;
                    case cs_value_type::Float:
                        gs.code.reserve(8);
                        gs.code.push_back(CsCodeStart);
                        gs.gen_float(arg.get_float());
                        gs.code.push_back(CsCodeResult);
                        gs.code.push_back(CsCodeExit);
                        break;
                    case cs_value_type::String:
                    case cs_value_type::Macro:
                    case cs_value_type::Cstring:
                        gs.code.reserve(64);
                        gs.gen_main(arg.get_strr());
                        break;
                    default:
                        gs.code.reserve(8);
                        gs.code.push_back(CsCodeStart);
                        gs.gen_null();
                        gs.code.push_back(CsCodeResult);
                        gs.code.push_back(CsCodeExit);
                        break;
                }
                gs.done();
                uint32_t *cbuf = new uint32_t[gs.code.size()];
                memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(uint32_t));
                arg.set_code(
                    reinterpret_cast<cs_bcode *>(cbuf + 1)
                );
                continue;
            }
            case CsCodeCond: {
                cs_value &arg = args[numargs - 1];
                switch (arg.get_type()) {
                    case cs_value_type::String:
                    case cs_value_type::Macro:
                    case cs_value_type::Cstring: {
                        ostd::string_range s = arg.get_strr();
                        if (!s.empty()) {
                            cs_gen_state gs(cs);
                            gs.code.reserve(64);
                            gs.gen_main(s);
                            gs.done();
                            uint32_t *cbuf = new uint32_t[gs.code.size()];
                            memcpy(
                                cbuf, gs.code.data(),
                                gs.code.size() * sizeof(uint32_t)
                            );
                            arg.set_code(reinterpret_cast<cs_bcode *>(cbuf + 1));
                        } else {
                            arg.force_null();
                        }
                        break;
                    }
                    default:
                        break;
                }
                continue;
            }

            case CsCodeIdent:
                args[numargs++].set_ident(cs.p_state->identmap[op >> 8]);
                continue;
            case CsCodeIdentArg: {
                cs_alias *a = static_cast<cs_alias *>(
                    cs.p_state->identmap[op >> 8]
                );
                if (!cs_is_arg_used(cs, a)) {
                    cs_value nv;
                    cs_alias_internal::push_arg(
                        a, nv, cs.p_callstack->argstack[a->get_index()], false
                    );
                    cs.p_callstack->usedargs |= 1 << a->get_index();
                }
                args[numargs++].set_ident(a);
                continue;
            }
            case CsCodeIdentU: {
                cs_value &arg = args[numargs - 1];
                cs_ident *id = cs.p_state->identmap[DummyIdx];
                if (
                    arg.get_type() == cs_value_type::String ||
                    arg.get_type() == cs_value_type::Macro ||
                    arg.get_type() == cs_value_type::Cstring
                ) {
                    id = cs.new_ident(arg.get_strr());
                }
                if ((id->get_index() < MaxArguments) && !cs_is_arg_used(cs, id)) {
                    cs_value nv;
                    cs_alias_internal::push_arg(
                        static_cast<cs_alias *>(id), nv,
                        cs.p_callstack->argstack[id->get_index()], false
                    );
                    cs.p_callstack->usedargs |= 1 << id->get_index();
                }
                arg.set_ident(id);
                continue;
            }

            case CsCodeLookupU | CsRetString: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        arg.set_str(
                            static_cast<cs_alias *>(id)->get_value().get_str()
                        );
                        continue;
                    case CsIdSvar:
                        arg.set_str(cs_string{
                            static_cast<cs_svar *>(id)->get_value()
                        });
                        continue;
                    case CsIdIvar:
                        arg.set_str(
                            intstr(static_cast<cs_ivar *>(id)->get_value())
                        );
                        continue;
                    case CsIdFvar:
                        arg.set_str(
                            floatstr(static_cast<cs_fvar *>(id)->get_value())
                        );
                        continue;
                    case CsIdUnknown:
                        arg.set_str("");
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookup | CsRetString:
                args[numargs++].set_str(
                    cs_get_lookup_id(cs, op)->get_value().get_str()
                );
                continue;
            case CsCodeLookupArg | CsRetString: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_str("");
                } else {
                    args[numargs++].set_str(a->get_value().get_str());
                }
                continue;
            }
            case CsCodeLookupU | CsRetInt: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        arg.set_int(
                            static_cast<cs_alias *>(id)->get_value().get_int()
                        );
                        continue;
                    case CsIdSvar:
                        arg.set_int(cs_parse_int(
                            static_cast<cs_svar *>(id)->get_value()
                        ));
                        continue;
                    case CsIdIvar:
                        arg.set_int(static_cast<cs_ivar *>(id)->get_value());
                        continue;
                    case CsIdFvar:
                        arg.set_int(
                            cs_int(static_cast<cs_fvar *>(id)->get_value())
                        );
                        continue;
                    case CsIdUnknown:
                        arg.set_int(0);
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookup | CsRetInt:
                args[numargs++].set_int(
                    cs_get_lookup_id(cs, op)->get_value().get_int()
                );
                continue;
            case CsCodeLookupArg | CsRetInt: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_int(0);
                } else {
                    args[numargs++].set_int(a->get_value().get_int());
                }
                continue;
            }
            case CsCodeLookupU | CsRetFloat: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        arg.set_float(
                            static_cast<cs_alias *>(id)->get_value().get_float()
                        );
                        continue;
                    case CsIdSvar:
                        arg.set_float(cs_parse_float(
                            static_cast<cs_svar *>(id)->get_value()
                        ));
                        continue;
                    case CsIdIvar:
                        arg.set_float(cs_float(
                            static_cast<cs_ivar *>(id)->get_value()
                        ));
                        continue;
                    case CsIdFvar:
                        arg.set_float(
                            static_cast<cs_fvar *>(id)->get_value()
                        );
                        continue;
                    case CsIdUnknown:
                        arg.set_float(cs_float(0));
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookup | CsRetFloat:
                args[numargs++].set_float(
                    cs_get_lookup_id(cs, op)->get_value().get_float()
                );
                continue;
            case CsCodeLookupArg | CsRetFloat: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_float(cs_float(0));
                } else {
                    args[numargs++].set_float(a->get_value().get_float());
                }
                continue;
            }
            case CsCodeLookupU | CsRetNull: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        static_cast<cs_alias *>(id)->get_value().get_val(arg);
                        continue;
                    case CsIdSvar:
                        arg.set_str(cs_string{
                            static_cast<cs_svar *>(id)->get_value()
                        });
                        continue;
                    case CsIdIvar:
                        arg.set_int(static_cast<cs_ivar *>(id)->get_value());
                        continue;
                    case CsIdFvar:
                        arg.set_float(
                            static_cast<cs_fvar *>(id)->get_value()
                        );
                        continue;
                    case CsIdUnknown:
                        arg.set_null();
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookup | CsRetNull:
                cs_get_lookup_id(cs, op)->get_value().get_val(args[numargs++]);
                continue;
            case CsCodeLookupArg | CsRetNull: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_null();
                } else {
                    a->get_value().get_val(args[numargs++]);
                }
                continue;
            }

            case CsCodeLookupMu | CsRetString: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        static_cast<cs_alias *>(id)->get_cstr(arg);
                        continue;
                    case CsIdSvar:
                        arg.set_cstr(static_cast<cs_svar *>(id)->get_value());
                        continue;
                    case CsIdIvar:
                        arg.set_str(
                            intstr(static_cast<cs_ivar *>(id)->get_value())
                        );
                        continue;
                    case CsIdFvar:
                        arg.set_str(
                            floatstr(static_cast<cs_fvar *>(id)->get_value())
                        );
                        continue;
                    case CsIdUnknown:
                        arg.set_cstr("");
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookupM | CsRetString:
                cs_get_lookup_id(cs, op)->get_cstr(args[numargs++]);
                continue;
            case CsCodeLookupMarg | CsRetString: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_cstr("");
                } else {
                    a->get_cstr(args[numargs++]);
                }
                continue;
            }
            case CsCodeLookupMu | CsRetNull: {
                cs_ident *id = nullptr;
                cs_value &arg = args[numargs - 1];
                switch (cs_get_lookupu_type(cs, arg, id, op)) {
                    case CsIdAlias:
                        static_cast<cs_alias *>(id)->get_cval(arg);
                        continue;
                    case CsIdSvar:
                        arg.set_cstr(static_cast<cs_svar *>(id)->get_value());
                        continue;
                    case CsIdIvar:
                        arg.set_int(static_cast<cs_ivar *>(id)->get_value());
                        continue;
                    case CsIdFvar:
                        arg.set_float(static_cast<cs_fvar *>(id)->get_value());
                        continue;
                    case CsIdUnknown:
                        arg.set_null();
                        continue;
                    default:
                        continue;
                }
            }
            case CsCodeLookupM | CsRetNull:
                cs_get_lookup_id(cs, op)->get_cval(args[numargs++]);
                continue;
            case CsCodeLookupMarg | CsRetNull: {
                cs_alias *a = cs_get_lookuparg_id(cs, op);
                if (!a) {
                    args[numargs++].set_null();
                } else {
                    a->get_cval(args[numargs++]);
                }
                continue;
            }

            case CsCodeSvar | CsRetString:
            case CsCodeSvar | CsRetNull:
                args[numargs++].set_str(cs_string{static_cast<cs_svar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()});
                continue;
            case CsCodeSvar | CsRetInt:
                args[numargs++].set_int(cs_parse_int(static_cast<cs_svar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()));
                continue;
            case CsCodeSvar | CsRetFloat:
                args[numargs++].set_float(cs_parse_float(static_cast<cs_svar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()));
                continue;
            case CsCodeSvarM:
                args[numargs++].set_cstr(static_cast<cs_svar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value());
                continue;
            case CsCodeSvar1:
                cs.set_var_str_checked(
                    static_cast<cs_svar *>(cs.p_state->identmap[op >> 8]),
                    args[--numargs].get_strr()
                );
                continue;

            case CsCodeIvar | CsRetInt:
            case CsCodeIvar | CsRetNull:
                args[numargs++].set_int(static_cast<cs_ivar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value());
                continue;
            case CsCodeIvar | CsRetString:
                args[numargs++].set_str(intstr(static_cast<cs_ivar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()));
                continue;
            case CsCodeIvar | CsRetFloat:
                args[numargs++].set_float(cs_float(static_cast<cs_ivar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()));
                continue;
            case CsCodeIvar1:
                cs.set_var_int_checked(
                    static_cast<cs_ivar *>(cs.p_state->identmap[op >> 8]),
                    args[--numargs].get_int()
                );
                continue;
            case CsCodeIvar2:
                numargs -= 2;
                cs.set_var_int_checked(
                    static_cast<cs_ivar *>(cs.p_state->identmap[op >> 8]),
                    (args[numargs].get_int() << 16)
                        | (args[numargs + 1].get_int() << 8)
                );
                continue;
            case CsCodeIvar3:
                numargs -= 3;
                cs.set_var_int_checked(
                    static_cast<cs_ivar *>(cs.p_state->identmap[op >> 8]),
                    (args[numargs].get_int() << 16)
                        | (args[numargs + 1].get_int() << 8)
                        | (args[numargs + 2].get_int()));
                continue;

            case CsCodeFvar | CsRetFloat:
            case CsCodeFvar | CsRetNull:
                args[numargs++].set_float(static_cast<cs_fvar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value());
                continue;
            case CsCodeFvar | CsRetString:
                args[numargs++].set_str(floatstr(
                    static_cast<cs_fvar *>(
                        cs.p_state->identmap[op >> 8]
                    )->get_value()
                ));
                continue;
            case CsCodeFvar | CsRetInt:
                args[numargs++].set_int(int(static_cast<cs_fvar *>(
                    cs.p_state->identmap[op >> 8]
                )->get_value()));
                continue;
            case CsCodeFvar1:
                cs.set_var_float_checked(
                    static_cast<cs_fvar *>(cs.p_state->identmap[op >> 8]),
                    args[--numargs].get_float()
                );
                continue;

            case CsCodeCom | CsRetNull:
            case CsCodeCom | CsRetString:
            case CsCodeCom | CsRetFloat:
            case CsCodeCom | CsRetInt: {
                cs_command *id = static_cast<cs_command *>(
                    cs.p_state->identmap[op >> 8]
                );
                int offset = numargs - id->get_num_args();
                result.force_null();
                cs_cmd_internal::call(cs, id, cs_value_r(
                    args + offset, args + offset + id->get_num_args()
                ), result);
                force_arg(result, op & CsCodeRetMask);
                numargs = offset;
                continue;
            }

            case CsCodeComV | CsRetNull:
            case CsCodeComV | CsRetString:
            case CsCodeComV | CsRetFloat:
            case CsCodeComV | CsRetInt: {
                cs_command *id = static_cast<cs_command *>(
                    cs.p_state->identmap[op >> 13]
                );
                int callargs = (op >> 8) & 0x1F, offset = numargs - callargs;
                result.force_null();
                cs_cmd_internal::call(cs, id, ostd::iter(
                    &args[offset], &args[offset + callargs]
                ), result);
                force_arg(result, op & CsCodeRetMask);
                numargs = offset;
                continue;
            }
            case CsCodeComC | CsRetNull:
            case CsCodeComC | CsRetString:
            case CsCodeComC | CsRetFloat:
            case CsCodeComC | CsRetInt: {
                cs_command *id = static_cast<cs_command *>(
                    cs.p_state->identmap[op >> 13]
                );
                int callargs = (op >> 8) & 0x1F, offset = numargs - callargs;
                result.force_null();
                {
                    auto buf = ostd::appender<cs_string>();
                    cscript::util::tvals_concat(buf, ostd::iter(
                        &args[offset], &args[offset + callargs]
                    ), " ");
                    cs_value tv;
                    tv.set_str(std::move(buf.get()));
                    cs_cmd_internal::call(cs, id, cs_value_r(&tv, &tv + 1), result);
                }
                force_arg(result, op & CsCodeRetMask);
                numargs = offset;
                continue;
            }

            case CsCodeConc | CsRetNull:
            case CsCodeConc | CsRetString:
            case CsCodeConc | CsRetFloat:
            case CsCodeConc | CsRetInt:
            case CsCodeConcW | CsRetNull:
            case CsCodeConcW | CsRetString:
            case CsCodeConcW | CsRetFloat:
            case CsCodeConcW | CsRetInt: {
                int numconc = op >> 8;
                auto buf = ostd::appender<cs_string>();
                cscript::util::tvals_concat(
                    buf, ostd::iter(&args[numargs - numconc], &args[numargs]),
                    ((op & CsCodeOpMask) == CsCodeConc) ? " " : ""
                );
                numargs = numargs - numconc;
                args[numargs].set_str(std::move(buf.get()));
                force_arg(args[numargs], op & CsCodeRetMask);
                numargs++;
                continue;
            }

            case CsCodeConcM | CsRetNull:
            case CsCodeConcM | CsRetString:
            case CsCodeConcM | CsRetFloat:
            case CsCodeConcM | CsRetInt: {
                int numconc = op >> 8;
                auto buf = ostd::appender<cs_string>();
                cscript::util::tvals_concat(
                    buf, ostd::iter(&args[numargs - numconc], &args[numargs])
                );
                numargs = numargs - numconc;
                result.set_str(std::move(buf.get()));
                force_arg(result, op & CsCodeRetMask);
                continue;
            }

            case CsCodeAlias:
                cs_alias_internal::set_alias(
                    static_cast<cs_alias *>(cs.p_state->identmap[op >> 8]),
                    cs, args[--numargs]
                );
                continue;
            case CsCodeAliasArg:
                cs_alias_internal::set_arg(
                    static_cast<cs_alias *>(cs.p_state->identmap[op >> 8]),
                    cs, args[--numargs]
                );
                continue;
            case CsCodeAliasU:
                numargs -= 2;
                cs.set_alias(
                    args[numargs].get_str(), std::move(args[numargs + 1])
                );
                continue;

            case CsCodeCall | CsRetNull:
            case CsCodeCall | CsRetString:
            case CsCodeCall | CsRetFloat:
            case CsCodeCall | CsRetInt: {
                result.force_null();
                cs_ident *id = cs.p_state->identmap[op >> 13];
                int callargs = (op >> 8) & 0x1F, offset = numargs - callargs;
                if (id->get_flags() & CS_IDF_UNKNOWN) {
                    force_arg(result, op & CsCodeRetMask);
                    throw cs_error(
                        cs, "unknown command: %s", id->get_name()
                    );
                }
                cs_call_alias(
                    cs, static_cast<cs_alias *>(id), args, result, callargs,
                    numargs, offset, 0, op
                );
                continue;
            }
            case CsCodeCallArg | CsRetNull:
            case CsCodeCallArg | CsRetString:
            case CsCodeCallArg | CsRetFloat:
            case CsCodeCallArg | CsRetInt: {
                result.force_null();
                cs_ident *id = cs.p_state->identmap[op >> 13];
                int callargs = (op >> 8) & 0x1F, offset = numargs - callargs;
                if (!cs_is_arg_used(cs, id)) {
                    numargs = offset;
                    force_arg(result, op & CsCodeRetMask);
                    continue;
                }
                cs_call_alias(
                    cs, static_cast<cs_alias *>(id), args, result, callargs,
                    numargs, offset, 0, op
                );
                continue;
            }

            case CsCodeCallU | CsRetNull:
            case CsCodeCallU | CsRetString:
            case CsCodeCallU | CsRetFloat:
            case CsCodeCallU | CsRetInt: {
                int callargs = op >> 8, offset = numargs - callargs;
                cs_value &idarg = args[offset - 1];
                if (
                    idarg.get_type() != cs_value_type::String &&
                    idarg.get_type() != cs_value_type::Macro &&
                    idarg.get_type() != cs_value_type::Cstring
                ) {
litval:
                    result = std::move(idarg);
                    force_arg(result, op & CsCodeRetMask);
                    numargs = offset - 1;
                    continue;
                }
                cs_ident *id = cs.get_ident(idarg.get_strr());
                if (!id) {
noid:
                    if (cs_check_num(idarg.get_strr())) {
                        goto litval;
                    }
                    result.force_null();
                    force_arg(result, op & CsCodeRetMask);
                    throw cs_error(
                        cs, "unknown command: %s", idarg.get_strr()
                    );
                }
                result.force_null();
                switch (id->get_type_raw()) {
                    default:
                        if (!cs_cmd_internal::has_cb(id)) {
                            numargs = offset - 1;
                            force_arg(result, op & CsCodeRetMask);
                            continue;
                        }
                    /* fallthrough */
                    case CsIdCommand:
                        callcommand(
                            cs, static_cast<cs_command *>(id), &args[offset],
                            result, callargs
                        );
                        force_arg(result, op & CsCodeRetMask);
                        numargs = offset - 1;
                        continue;
                    case CsIdLocal: {
                        cs_ident_stack locals[MaxArguments];
                        for (size_t j = 0; j < size_t(callargs); ++j) {
                            cs_push_alias(cs.force_ident(
                                args[offset + j]
                            ), locals[j]);
                        }
                        cs_do_and_cleanup([&]() {
                            code = runcode(cs, code, result);
                        }, [&]() {
                            for (size_t j = 0; j < size_t(callargs); ++j) {
                                cs_pop_alias(args[offset + j].get_ident());
                            }
                        });
                        return code;
                    }
                    case CsIdIvar:
                        if (callargs <= 0) {
                            cs.print_var(static_cast<cs_var *>(id));
                        } else {
                            cs.set_var_int_checked(
                                static_cast<cs_ivar *>(id),
                                ostd::iter(&args[offset], &args[offset + callargs])
                            );
                        }
                        numargs = offset - 1;
                        force_arg(result, op & CsCodeRetMask);
                        continue;
                    case CsIdFvar:
                        if (callargs <= 0) {
                            cs.print_var(static_cast<cs_var *>(id));
                        } else {
                            cs.set_var_float_checked(
                                static_cast<cs_fvar *>(id),
                                args[offset].force_float()
                            );
                        }
                        numargs = offset - 1;
                        force_arg(result, op & CsCodeRetMask);
                        continue;
                    case CsIdSvar:
                        if (callargs <= 0) {
                            cs.print_var(static_cast<cs_var *>(id));
                        } else {
                            cs.set_var_str_checked(
                                static_cast<cs_svar *>(id),
                                args[offset].force_str()
                            );
                        }
                        numargs = offset - 1;
                        force_arg(result, op & CsCodeRetMask);
                        continue;
                    case CsIdAlias: {
                        cs_alias *a = static_cast<cs_alias *>(id);
                        if (
                            (a->get_index() < MaxArguments) &&
                            !cs_is_arg_used(cs, a)
                        ) {
                            numargs = offset - 1;
                            force_arg(result, op & CsCodeRetMask);
                            continue;
                        }
                        if (a->get_value().get_type() == cs_value_type::Null) {
                            goto noid;
                        }
                        cs_call_alias(
                            cs, a, args, result, callargs, numargs,
                            offset, 1, op
                        );
                        continue;
                    }
                }
            }
        }
    }
    return code;
}

void cs_state::run(cs_bcode *code, cs_value &ret) {
    runcode(*this, reinterpret_cast<uint32_t *>(code), ret);
}

static void cs_run(
    cs_state &cs, ostd::string_range file, ostd::string_range code,
    cs_value &ret
) {
    cs_gen_state gs(cs);
    gs.src_name = file;
    gs.code.reserve(64);
    gs.gen_main(code, CsValAny);
    gs.done();
    uint32_t *cbuf = new uint32_t[gs.code.size()];
    memcpy(cbuf, gs.code.data(), gs.code.size() * sizeof(uint32_t));
    runcode(cs, cbuf + 1, ret);
    if (int(cbuf[0]) < 0x100) {
        delete[] cbuf;
    }
}

void cs_state::run(ostd::string_range code, cs_value &ret) {
    cs_run(*this, ostd::string_range(), code, ret);
}

void cs_state::run(cs_ident *id, cs_value_r args, cs_value &ret) {
    int nargs = int(args.size());
    ret.set_null();
    RunDepthRef level{*this}; /* incr and decr on scope exit */
    if (id) {
        switch (id->get_type()) {
            default:
                if (!cs_cmd_internal::has_cb(id)) {
                    break;
                }
            /* fallthrough */
            case cs_ident_type::Command:
                if (nargs < static_cast<cs_command *>(id)->get_num_args()) {
                    cs_value buf[MaxArguments];
                    memcpy(buf, &args[0], args.size() * sizeof(cs_value));
                    callcommand(
                        *this, static_cast<cs_command *>(id), buf, ret,
                        nargs, false
                    );
                } else {
                    callcommand(
                        *this, static_cast<cs_command *>(id), &args[0],
                        ret, nargs, false
                    );
                }
                nargs = 0;
                break;
            case cs_ident_type::Ivar:
                if (args.empty()) {
                    print_var(static_cast<cs_var *>(id));
                } else {
                    set_var_int_checked(static_cast<cs_ivar *>(id), args);
                }
                break;
            case cs_ident_type::Fvar:
                if (args.empty()) {
                    print_var(static_cast<cs_var *>(id));
                } else {
                    set_var_float_checked(
                        static_cast<cs_fvar *>(id), args[0].force_float()
                    );
                }
                break;
            case cs_ident_type::Svar:
                if (args.empty()) {
                    print_var(static_cast<cs_var *>(id));
                } else {
                    set_var_str_checked(
                        static_cast<cs_svar *>(id), args[0].force_str()
                    );
                }
                break;
            case cs_ident_type::Alias: {
                cs_alias *a = static_cast<cs_alias *>(id);
                if (
                    (a->get_index() < MaxArguments) && !cs_is_arg_used(*this, a)
                ) {
                    break;
                }
                if (a->get_value().get_type() == cs_value_type::Null) {
                    break;
                }
                cs_call_alias(
                    *this, a, &args[0], ret, nargs, nargs, 0, 0, CsRetNull
                );
                break;
            }
        }
    }
}

cs_string cs_state::run_str(cs_bcode *code) {
    cs_value ret;
    run(code, ret);
    return ret.get_str();
}

cs_string cs_state::run_str(ostd::string_range code) {
    cs_value ret;
    run(code, ret);
    return ret.get_str();
}

cs_string cs_state::run_str(cs_ident *id, cs_value_r args) {
    cs_value ret;
    run(id, args, ret);
    return ret.get_str();
}

cs_int cs_state::run_int(cs_bcode *code) {
    cs_value ret;
    run(code, ret);
    return ret.get_int();
}

cs_int cs_state::run_int(ostd::string_range code) {
    cs_value ret;
    run(code, ret);
    return ret.get_int();
}

cs_int cs_state::run_int(cs_ident *id, cs_value_r args) {
    cs_value ret;
    run(id, args, ret);
    return ret.get_int();
}

cs_float cs_state::run_float(cs_bcode *code) {
    cs_value ret;
    run(code, ret);
    return ret.get_float();
}

cs_float cs_state::run_float(ostd::string_range code) {
    cs_value ret;
    run(code, ret);
    return ret.get_float();
}

cs_float cs_state::run_float(cs_ident *id, cs_value_r args) {
    cs_value ret;
    run(id, args, ret);
    return ret.get_float();
}

bool cs_state::run_bool(cs_bcode *code) {
    cs_value ret;
    run(code, ret);
    return ret.get_bool();
}

bool cs_state::run_bool(ostd::string_range code) {
    cs_value ret;
    run(code, ret);
    return ret.get_bool();
}

bool cs_state::run_bool(cs_ident *id, cs_value_r args) {
    cs_value ret;
    run(id, args, ret);
    return ret.get_bool();
}

void cs_state::run(cs_bcode *code) {
    cs_value ret;
    run(code, ret);
}

void cs_state::run(ostd::string_range code) {
    cs_value ret;
    run(code, ret);
}

void cs_state::run(cs_ident *id, cs_value_r args) {
    cs_value ret;
    run(id, args, ret);
}

CsLoopState cs_state::run_loop(cs_bcode *code, cs_value &ret) {
    ++p_inloop;
    try {
        run(code, ret);
    } catch (CsBreakException) {
        --p_inloop;
        return CsLoopState::Break;
    } catch (CsContinueException) {
        --p_inloop;
        return CsLoopState::Continue;
    } catch (...) {
        --p_inloop;
        throw;
    }
    return CsLoopState::Normal;
}

CsLoopState cs_state::run_loop(cs_bcode *code) {
    cs_value ret;
    return run_loop(code, ret);
}

static bool cs_run_file(
    cs_state &cs, ostd::string_range fname, cs_value &ret
) {
    std::unique_ptr<char[]> buf;
    size_t len;

    ostd::file_stream f(fname, ostd::stream_mode::READ);
    if (!f.is_open()) {
        return false;
    }

    len = f.size();
    buf = std::make_unique<char[]>(len + 1);
    if (!buf) {
        return false;
    }
    try {
        f.get(buf.get(), len);
    } catch (...) {
        return false;
    }
    buf[len] = '\0';

    cs_run(cs, fname, ostd::string_range(buf.get(), buf.get() + len), ret);
    return true;
}

std::optional<cs_string> cs_state::run_file_str(ostd::string_range fname) {
    cs_value ret;
    if (!cs_run_file(*this, fname, ret)) {
        return std::nullopt;
    }
    return ret.get_str();
}

std::optional<cs_int> cs_state::run_file_int(ostd::string_range fname) {
    cs_value ret;
    if (!cs_run_file(*this, fname, ret)) {
        return std::nullopt;
    }
    return ret.get_int();
}

std::optional<cs_float> cs_state::run_file_float(ostd::string_range fname) {
    cs_value ret;
    if (!cs_run_file(*this, fname, ret)) {
        return std::nullopt;
    }
    return ret.get_float();
}

std::optional<bool> cs_state::run_file_bool(ostd::string_range fname) {
    cs_value ret;
    if (!cs_run_file(*this, fname, ret)) {
        return std::nullopt;
    }
    return ret.get_bool();
}

bool cs_state::run_file(ostd::string_range fname, cs_value &ret) {
    return cs_run_file(*this, fname, ret);
}

bool cs_state::run_file(ostd::string_range fname) {
    cs_value ret;
    if (!cs_run_file(*this, fname, ret)) {
        return false;
    }
    return true;
}

} /* namespace cscript */