xmlui 0.4.0

package/dist/scripts/src/components-core/script-runner/process-statement-common.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.innermostLoopScope = innermostLoopScope;
+exports.innermostBlockScope = innermostBlockScope;
+exports.innermostTryScope = innermostTryScope;
+exports.createLoopScope = createLoopScope;
+exports.releaseLoopScope = releaseLoopScope;
+exports.provideLoopBody = provideLoopBody;
+exports.createTryScope = createTryScope;
+exports.provideTryBody = provideTryBody;
+exports.provideCatchBody = provideCatchBody;
+exports.provideFinallyBody = provideFinallyBody;
+exports.provideFinallyErrorBody = provideFinallyErrorBody;
+exports.ensureMainThread = ensureMainThread;
+exports.hoistFunctionDeclarations = hoistFunctionDeclarations;
+const statement_queue_1 = require("./statement-queue");
+const eval_tree_common_1 = require("./eval-tree-common");
+function innermostLoopScope(thread) {
+    if (!thread.loops || thread.loops.length === 0) {
+        throw new Error("Missing loop scope");
+    }
+    return thread.loops[thread.loops.length - 1];
+}
+function innermostBlockScope(thread) {
+    if (!thread.blocks || thread.blocks.length === 0)
+        return undefined;
+    return thread.blocks[thread.blocks.length - 1];
+}
+function innermostTryScope(thread) {
+    if (!thread.tryBlocks || thread.tryBlocks.length === 0) {
+        throw new Error("Missing try scope");
+    }
+    return thread.tryBlocks[thread.tryBlocks.length - 1];
+}
+function createLoopScope(thread, continueOffset = 0) {
+    var _a, _b, _c, _d, _e;
+    (_a = thread.loops) !== null && _a !== void 0 ? _a : (thread.loops = []);
+    const breakDepth = (_c = (_b = thread.blocks) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+    const tryDepth = (_e = (_d = thread.tryBlocks) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+    const loopScope = {
+        breakLabel: -1,
+        continueLabel: -1,
+        breakBlockDepth: breakDepth,
+        continueBlockDepth: breakDepth + continueOffset,
+        tryBlockDepth: tryDepth,
+    };
+    thread.loops.push(loopScope);
+    return loopScope;
+}
+function releaseLoopScope(thread, skipContinuation = true) {
+    var _a;
+    const loopScope = innermostLoopScope(thread);
+    if (skipContinuation) {
+        (_a = thread.loops) === null || _a === void 0 ? void 0 : _a.pop();
+    }
+    if (thread.blocks) {
+        thread.blocks.length = skipContinuation ? loopScope.breakBlockDepth : loopScope.continueBlockDepth;
+    }
+}
+// --- Create a list of body statements according to the specified loop statement and scope
+function provideLoopBody(loopScope, loopStatement, breakLabelValue) {
+    // --- Stay in the loop, add the body and the guard condition
+    const guardStatement = Object.assign(Object.assign({}, loopStatement), { guard: true });
+    const toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([loopStatement.body, guardStatement]);
+    // --- The next queue label is for "break"
+    loopScope.breakLabel = breakLabelValue !== null && breakLabelValue !== void 0 ? breakLabelValue : -1;
+    // --- The guard action's label is for "continue"
+    loopScope.continueLabel = toUnshift[1].label;
+    return toUnshift;
+}
+// --- Create a list of body statements according to the specified try statement scope
+function createTryScope(thread, tryStatement) {
+    var _a;
+    (_a = thread.tryBlocks) !== null && _a !== void 0 ? _a : (thread.tryBlocks = []);
+    const loopScope = {
+        statement: tryStatement,
+        processingPhase: "try",
+        tryLabel: -1,
+    };
+    thread.tryBlocks.push(loopScope);
+    return loopScope;
+}
+// --- Provide a body for the try block
+function provideTryBody(thread, tryScope) {
+    // --- Stay in the error handling block, add the body and the guard condition
+    const guardStatement = Object.assign(Object.assign({}, tryScope.statement), { guard: true });
+    // --- New block scope for try
+    thread.blocks.push({
+        vars: {},
+    });
+    // --- Prepare an empty statement that will only remove the block scope when the entire block is processed
+    const closing = {
+        type: "EmptyS",
+        removeBlockScope: true,
+    }; // --- We need the cast as we do not provide required props
+    const toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...tryScope.statement.tryBlock.statements, closing, guardStatement]);
+    tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+    return toUnshift;
+}
+// --- Provide a body for the catch block
+function provideCatchBody(thread, tryScope) {
+    // --- Stay in the error handling block, add the body and the guard condition
+    const guardStatement = Object.assign(Object.assign({}, tryScope.statement), { guard: true });
+    // --- New block scope for catch
+    thread.blocks.push({
+        vars: {},
+    });
+    // --- Prepare an empty statement that will only remove the block scope when the entire block is processed
+    const closing = {
+        type: "EmptyS",
+        removeBlockScope: true,
+    }; // --- We need the cast as we do not provide required props
+    const toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...tryScope.statement.catchBlock.statements, closing, guardStatement]);
+    tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+    return toUnshift;
+}
+// --- Provide a body for the finally block
+function provideFinallyBody(thread, tryScope) {
+    // --- Stay in the error handling block, add the body and the guard condition
+    const guardStatement = Object.assign(Object.assign({}, tryScope.statement), { guard: true });
+    // --- New block scope for finally
+    thread.blocks.push({
+        vars: {},
+    });
+    // --- Prepare an empty statement that will only remove the block scope when the entire block is processed
+    const closing = {
+        type: "EmptyS",
+        removeBlockScope: true,
+    }; // --- We need the cast as we do not provide required props
+    const finallyBlock = tryScope.statement.finallyBlock;
+    const toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+        ...(finallyBlock ? finallyBlock.statements : []),
+        closing,
+        guardStatement,
+    ]);
+    tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+    return toUnshift;
+}
+// --- Provide a body for the error block in finally
+function provideFinallyErrorBody(tryScope) {
+    // --- Stay in the error handling block, add the body and the guard condition
+    const guardStatement = Object.assign(Object.assign({}, tryScope.statement), { guard: true });
+    const toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([guardStatement]);
+    tryScope.tryLabel = toUnshift[0].label;
+    return toUnshift;
+}
+// --- Ensure that the evaluation context has a main thread
+function ensureMainThread(evalContext) {
+    if (!evalContext.mainThread) {
+        evalContext.mainThread = {
+            childThreads: [],
+            blocks: [
+                {
+                    vars: {},
+                },
+            ],
+            loops: [],
+            breakLabelValue: -1,
+        };
+    }
+    return evalContext.mainThread;
+}
+// --- Hoist function definitions to the innermost block scope
+function hoistFunctionDeclarations(thread, statements) {
+    const block = innermostBlockScope(thread);
+    if (!block) {
+        throw new Error("Missing block scope");
+    }
+    statements
+        .filter((stmt) => stmt.type === "FuncD")
+        .forEach((stmt) => {
+        var _a;
+        const funcDecl = stmt;
+        // --- Turn the function into an arrow expression
+        const arrowExpression = {
+            type: "ArrowE",
+            args: funcDecl.args,
+            statement: funcDecl.statement,
+            closureContext: (0, eval_tree_common_1.obtainClosures)(thread),
+            _ARROW_EXPR_: true,
+        };
+        // --- Remove the functions from the closure list
+        // --- Check name uniqueness
+        const id = funcDecl.name;
+        if (block.vars[id]) {
+            throw new Error(`Variable ${id} is already declared in the current scope.`);
+        }
+        // --- Function is a constant
+        block.vars[id] = arrowExpression;
+        (_a = block.constVars) !== null && _a !== void 0 ? _a : (block.constVars = new Set());
+        block.constVars.add(id);
+    });
+}