@the-little-books/little/lib/env/env-next.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.next = void 0;
const Pattern = __importStar(require("../pattern"));
function put_back_entry(env, entry) {
    const { nodes, index } = entry;
    // NOTE Handle proper tail call.
    // - put back entry unless at the tail of its nodes.
    if (index + 1 < nodes.length) {
        env.return_stack.push({ ...entry, index: index + 1 });
    }
    return env;
}
async function next(env) {
    const entry = env.return_stack.pop();
    if (entry === undefined) {
        throw new Error("The return_stack is empty.");
    }
    const { nodes, index } = entry;
    const node = nodes[index];
    if (node.kind === "Node.Element") {
        if (node.tag === "jump") {
            return await next_jump(env, entry, node);
        }
        else if (node.tag === "call") {
            return await next_call(env, entry, node);
        }
        else if (node.tag === "match") {
            return await next_match(env, entry, node);
        }
        else {
            put_back_entry(env, entry);
            return node;
        }
    }
    else {
        put_back_entry(env, entry);
        return node;
    }
}
exports.next = next;
function find_label_index(nodes, label) {
    return nodes.findIndex((node) => node.kind === "Node.Element" && node.attributes.label === label);
}
async function next_jump(env, entry, node) {
    const module = node.attributes.module || entry.module;
    const nodes = await env.loader(env.book, module);
    const index = node.attributes.label
        ? find_label_index(nodes, node.attributes.label)
        : 0;
    env.return_stack.push({ module, nodes, index });
    return await next(env);
}
async function next_call(env, entry, node) {
    put_back_entry(env, entry);
    return await next_jump(env, entry, node);
}
async function next_match(env, entry, node) {
    const top_node = env.node_stack.pop();
    // NOTE better log.
    // console.log("top_node:", top_node)
    if (top_node === undefined) {
        throw new Error("Empty env.node_stack.");
    }
    for (const case_node of node.contents) {
        if (case_node.kind === "Node.Element") {
            if (case_node.tag === "case") {
                const pattern = Pattern.from_node(case_node.contents[0]);
                const result = Pattern.match(pattern, top_node);
                if (result !== null) {
                    // TODO use `result` to subst pattern variables in body.
                    const body = case_node.contents.slice(1);
                    put_back_entry(env, entry);
                    env.return_stack.push({ ...entry, nodes: body, index: 0 });
                    return await next(env);
                }
            }
            else if (case_node.tag === "default") {
                const body = case_node.contents;
                put_back_entry(env, entry);
                env.return_stack.push({ ...entry, nodes: body, index: 0 });
                return await next(env);
            }
        }
    }
    throw new Error("Mismatch.");
}
//# sourceMappingURL=env-next.js.map