@dseict/psc-interpreter 0.0.2 → 1.0.1

package/dist/visitor.js

@@ -0,0 +1,765 @@
+import PSCParser from "./_antlr/PSCParser";
+import PSCParserVisitor from "./_antlr/PSCParserVisitor";
+import { PSCAccessNonExistingVariableError, PSCArrayAccessNotArrayError, PSCConditionNotBooleanError, PSCForRangeNotIntegerError, PSCForVariableReuseError, PSCImpossibleError, PSCInvalidArrayIndexError, PSCOperationValueTypeMismatchError, PSCUnmatchedArgumentsError, } from "./error";
+import { PSCEventBus, } from "./events";
+export class PSCInterpretVisitor extends PSCParserVisitor {
+    #options;
+    // Stack of variable scopes
+    #variableStack = [{}];
+    // Current return value, undefined means currently not in returning state
+    #currentReturn = undefined;
+    // Event bus
+    #eventBus = new PSCEventBus();
+    constructor(options) {
+        super();
+        this.#options = options;
+    }
+    // Returns a function that can be called to unregister the event handler
+    on(eventType, handler) {
+        return this.#eventBus.on(eventType, handler);
+    }
+    #stringSmartCast(value) {
+        if (typeof value === "string") {
+            // Try to cast to boolean
+            if (value.toLowerCase() === "true") {
+                return true;
+            }
+            if (value.toLowerCase() === "false") {
+                return false;
+            }
+            if (value.toLowerCase() === "null") {
+                return null;
+            }
+            // Handle ridiculous edge cases for JS built-in casting v_v
+            if (value.trim() === "" || !/^-?\d*(\.\d+)?$/.test(value)) {
+                return value; // Return as is
+            }
+            // Try to cast to number
+            const numValue = Number(value);
+            if (!isNaN(numValue)) {
+                return numValue;
+            }
+        }
+        return value; // Return as is if no casting is possible
+    }
+    #assignVariable(_ctx, name, value) {
+        // Found if the variable is declared, and reassign it in the correct scope
+        for (const stack of this.#variableStack.slice().reverse()) {
+            if (stack[name] !== undefined) {
+                stack[name] = value;
+                return;
+            }
+        }
+        // If variable not found declared, assign it to the current scope
+        this.#variableStack[this.#variableStack.length - 1][name] = value;
+    }
+    #readVariable(ctx, name) {
+        for (const stack of this.#variableStack.slice().reverse()) {
+            if (stack[name] !== undefined) {
+                return stack[name];
+            }
+        }
+        throw new PSCAccessNonExistingVariableError(ctx, name);
+    }
+    #deleteVariable(ctx, name) {
+        for (const stack of this.#variableStack.slice().reverse()) {
+            if (stack[name] !== undefined) {
+                delete stack[name];
+                return;
+            }
+        }
+        throw new PSCImpossibleError(ctx, `Cannot delete variable '${name}' because it does not exist.`);
+    }
+    #variableExists(name) {
+        for (const stack of this.#variableStack.slice().reverse()) {
+            if (stack[name] !== undefined) {
+                return true;
+            }
+        }
+        return false;
+    }
+    #newVariableStack(_ctx) {
+        this.#variableStack.push({});
+    }
+    #popVariableStack(ctx) {
+        if (this.#variableStack.length === 1) {
+            throw new PSCImpossibleError(ctx, "Cannot pop the global variable stack.");
+        }
+        this.#variableStack.pop();
+    }
+    #initiateReturn(value) {
+        this.#currentReturn = value;
+    }
+    #isReturning() {
+        return this.#currentReturn !== undefined;
+    }
+    #terminateReturn() {
+        const ret = this.#currentReturn;
+        this.#currentReturn = undefined;
+        return ret;
+    }
+    #asString(ctx, value) {
+        if (Array.isArray(value)) {
+            return `[${value.map((v) => this.#asString(ctx, v)).join(",")}]`;
+        }
+        else if (typeof value === "boolean") {
+            return value ? "true" : "false";
+        }
+        else if (typeof value === "number") {
+            return value.toString();
+        }
+        else if (typeof value === "string") {
+            return `"` + value + `"`; // Wrap string in quotes
+        }
+        else if (value === undefined) {
+            return "";
+        }
+        else if (value === null) {
+            return "null";
+        }
+        else if (value instanceof Function) {
+            return "[Function]";
+        }
+        throw new PSCImpossibleError(ctx, `Cannot convert value of type ${typeof value} to string.`);
+    }
+    #normalizeArrayIndexOrThrow(ctx, index) {
+        if (typeof index !== "number" ||
+            !Number.isInteger(index - this.#options.arrayStartIndex) ||
+            index - this.#options.arrayStartIndex < 0) {
+            throw new PSCInvalidArrayIndexError(ctx, this.#asString(ctx, index));
+        }
+        return index - this.#options.arrayStartIndex;
+    }
+    visitProgram = async (ctx) => {
+        for (const subprogramCtx of ctx.subprogram_list()) {
+            await this.visitSubprogram(subprogramCtx);
+        }
+        await this.visitStmts(ctx.stmts());
+    };
+    // Expression and literals
+    visitExpr = async (ctx) => {
+        const eventParams = {
+            startLine: ctx.start.line,
+            startCol: ctx.start.column,
+            endLine: ctx.stop?.line,
+            endCol: ctx.stop !== undefined
+                ? ctx.stop.column + ctx.stop.stop - ctx.stop.start
+                : undefined,
+        };
+        this.#eventBus.emit("pre_eval_expr", eventParams);
+        const result = await this.visitOrExpr(ctx.orExpr());
+        this.#eventBus.emit("post_eval_expr", { ...eventParams, result });
+        return result;
+    };
+    visitOrExpr = async (ctx) => {
+        let result = this.#stringSmartCast(await this.visitAndExpr(ctx.andExpr(0)));
+        for (let i = 1; i < ctx.andExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitAndExpr(ctx.andExpr(i)));
+            const resultBool = typeof result == "boolean";
+            const rightBool = typeof right == "boolean";
+            if (!resultBool || !rightBool) {
+                throw new PSCOperationValueTypeMismatchError(ctx, "OR", "boolean", this.#asString(ctx, !resultBool ? result : right));
+            }
+            result = result || right;
+        }
+        return result;
+    };
+    visitAndExpr = async (ctx) => {
+        let result = this.#stringSmartCast(await this.visitCompExpr(ctx.compExpr(0)));
+        for (let i = 1; i < ctx.compExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitCompExpr(ctx.compExpr(i)));
+            const resultBool = typeof result == "boolean";
+            const rightBool = typeof right == "boolean";
+            if (!resultBool || !rightBool) {
+                throw new PSCOperationValueTypeMismatchError(ctx, "AND", "boolean", this.#asString(ctx, !resultBool ? result : right));
+            }
+            result = result && right;
+        }
+        return result;
+    };
+    visitCompExpr = async (ctx) => {
+        let result = this.#stringSmartCast(await this.visitAddExpr(ctx.addExpr(0)));
+        for (let i = 1; i < ctx.addExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitAddExpr(ctx.addExpr(i)));
+            const operator = ctx.compOp(i - 1).getText();
+            switch (operator) {
+                case "=":
+                    result = result === right;
+                    break;
+                case "<>":
+                    result = result !== right;
+                    break;
+                case ">":
+                    if ((typeof result == "string" && typeof right == "string") ||
+                        (typeof result == "number" && typeof right == "number")) {
+                        result = result > right;
+                    }
+                    else {
+                        throw new PSCOperationValueTypeMismatchError(ctx, ">", "string or number", `${result} > ${right}`);
+                    }
+                    break;
+                case "<":
+                    if ((typeof result == "string" && typeof right == "string") ||
+                        (typeof result == "number" && typeof right == "number")) {
+                        result = result < right;
+                    }
+                    else {
+                        throw new PSCOperationValueTypeMismatchError(ctx, "<", "string or number", `${result} < ${right}`);
+                    }
+                    break;
+                case ">=":
+                    if ((typeof result == "string" && typeof right == "string") ||
+                        (typeof result == "number" && typeof right == "number")) {
+                        result = result >= right;
+                    }
+                    else {
+                        throw new PSCOperationValueTypeMismatchError(ctx, ">=", "string or number", `${result} >= ${right}`);
+                    }
+                    break;
+                case "<=":
+                    if ((typeof result == "string" && typeof right == "string") ||
+                        (typeof result == "number" && typeof right == "number")) {
+                        result = result <= right;
+                    }
+                    else {
+                        throw new PSCOperationValueTypeMismatchError(ctx, "<=", "string or number", `${result} <= ${right}`);
+                    }
+                    break;
+                default:
+                    throw new PSCImpossibleError(ctx, `Unknown comparison operator: ${operator}`);
+            }
+        }
+        return result;
+    };
+    visitAddExpr = async (ctx) => {
+        let result = this.#stringSmartCast(await this.visitMulExpr(ctx.mulExpr(0)));
+        for (let i = 1; i < ctx.mulExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitMulExpr(ctx.mulExpr(i)));
+            if (typeof result !== "number" || typeof right !== "number") {
+                throw new PSCOperationValueTypeMismatchError(ctx, "Addition or subtraction", "number", `${this.#asString(ctx, result)} and ${this.#asString(ctx, right)}`);
+            }
+            const operator = ctx.addOp(i - 1).getText();
+            switch (operator) {
+                case "+":
+                    result += right;
+                    break;
+                case "-":
+                    result -= right;
+                    break;
+                default:
+                    throw new PSCImpossibleError(ctx, `Unknown addition/subtraction operator: ${operator}`);
+            }
+        }
+        return result;
+    };
+    visitMulExpr = async (ctx) => {
+        let result = this.#stringSmartCast(await this.visitExpExpr(ctx.expExpr(0)));
+        for (let i = 1; i < ctx.expExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitExpExpr(ctx.expExpr(i)));
+            if (typeof result !== "number" || typeof right !== "number") {
+                throw new PSCOperationValueTypeMismatchError(ctx, "Multiplication/division/modulo", "number", `${this.#asString(ctx, result)} and ${this.#asString(ctx, right)}`);
+            }
+            const operator = ctx.mulOp(i - 1).getText();
+            switch (operator) {
+                case "*":
+                    result *= right;
+                    break;
+                case "/":
+                    result /= right;
+                    break;
+                case "mod":
+                case "%":
+                    result %= right;
+                    break;
+                default:
+                    throw new PSCImpossibleError(ctx, `Unknown multiplication operator: ${operator}`);
+            }
+        }
+        return result;
+    };
+    visitExpExpr = async (ctx) => {
+        let result = await this.visitUnaryExpr(ctx.unaryExpr(0));
+        for (let i = 1; i < ctx.unaryExpr_list().length; i++) {
+            const right = this.#stringSmartCast(await this.visitUnaryExpr(ctx.unaryExpr(i)));
+            if (typeof result !== "number" || typeof right !== "number") {
+                throw new PSCOperationValueTypeMismatchError(ctx, "Exponential", "number", `${this.#asString(ctx, result)} and ${this.#asString(ctx, right)}`);
+            }
+            const operator = ctx.expOp(i - 1).getText();
+            switch (operator) {
+                case "**":
+                case "^":
+                    result **= right;
+                    break;
+                default:
+                    throw new PSCImpossibleError(ctx, `Unknown exponentiation operator: ${operator}`);
+            }
+        }
+        return result;
+    };
+    visitUnaryExpr = async (ctx) => {
+        const minusCount = ctx.MINUS_list().length;
+        const plusCount = ctx.PLUS_list().length;
+        const value = this.#stringSmartCast(await this.visitNotExpr(ctx.notExpr()));
+        if (typeof value !== "number" && (minusCount > 0 || plusCount > 0)) {
+            throw new PSCOperationValueTypeMismatchError(ctx, "Unary negation/affirmation operator", "number", this.#asString(ctx, value));
+        }
+        if (minusCount % 2 === 0) {
+            return value;
+        }
+        else {
+            if (typeof value !== "number") {
+                // This should never happen, just for type safety
+                throw new PSCOperationValueTypeMismatchError(ctx, "Negative sign operator", "number", this.#asString(ctx, value));
+            }
+            else {
+                return -value;
+            }
+        }
+    };
+    visitNotExpr = async (ctx) => {
+        const notCount = ctx.NOT_list().length;
+        const value = this.#stringSmartCast(await this.visitPrimaryExpr(ctx.primaryExpr()));
+        if (typeof value !== "boolean" && notCount > 0) {
+            throw new PSCOperationValueTypeMismatchError(ctx, "NOT", "boolean", this.#asString(ctx, value));
+        }
+        if (notCount % 2 === 0) {
+            return value;
+        }
+        else {
+            if (typeof value !== "boolean") {
+                // This should never happen, just for type safety
+                throw new PSCOperationValueTypeMismatchError(ctx, "NOT", "boolean", this.#asString(ctx, value));
+            }
+            return !value;
+        }
+    };
+    visitPrimaryExpr = async (ctx) => {
+        if (ctx.LPAREN() && ctx.RPAREN()) {
+            const args = await Promise.all(ctx.expr_list().map((expr) => this.visitExpr(expr)));
+            const func = await this.visitPrimaryExpr(ctx.primaryExpr());
+            if (typeof func !== "function") {
+                throw new PSCOperationValueTypeMismatchError(ctx, "Function call", "function", this.#asString(ctx, func));
+            }
+            // Function must return a value
+            return await func(args);
+        }
+        else if (ctx.LSQUARE() && ctx.RSQUARE()) {
+            const indices = await Promise.all(ctx.expr_list().map((expr) => this.visitExpr(expr)));
+            const leftArr = await this.visitPrimaryExpr(ctx.primaryExpr());
+            return indices.reduce((arr, index) => {
+                if (!Array.isArray(arr)) {
+                    throw new PSCArrayAccessNotArrayError(ctx, this.#asString(ctx, arr));
+                }
+                const normalizedIndex = this.#normalizeArrayIndexOrThrow(ctx, index);
+                if (normalizedIndex > arr.length - 1) {
+                    throw new PSCInvalidArrayIndexError(ctx, this.#asString(ctx, index));
+                }
+                return arr[normalizedIndex];
+            }, leftArr);
+        }
+        else if (ctx.groupExpr()) {
+            return await this.visitGroupExpr(ctx.groupExpr());
+        }
+        throw new PSCImpossibleError(ctx, "Invalid primary");
+    };
+    visitGroupExpr = async (ctx) => {
+        if (ctx.expr()) {
+            return await this.visitExpr(ctx.expr());
+        }
+        else if (ctx.atom()) {
+            return await this.visitAtom(ctx.atom());
+        }
+        throw new PSCImpossibleError(ctx, "Invalid group expression");
+    };
+    visitAtom = async (ctx) => {
+        if (ctx.lits()) {
+            return await this.visitLits(ctx.lits());
+        }
+        else if (ctx.ID()) {
+            // Handle variable lookup here
+            return this.#readVariable(ctx, ctx.ID().getText());
+        }
+        throw new PSCImpossibleError(ctx, "Invalid atom");
+    };
+    visitLits = async (ctx) => {
+        if (ctx.floatLits()) {
+            return await this.visitFloatLits(ctx.floatLits());
+        }
+        else if (ctx.intLits()) {
+            return await this.visitIntLits(ctx.intLits());
+        }
+        else if (ctx.arrayLits()) {
+            return await this.visitArrayLits(ctx.arrayLits());
+        }
+        else if (ctx.STRING()) {
+            return this.#stringSmartCast(ctx.STRING().getText().slice(1, -1)); // Remove quotes
+        }
+        else if (ctx.BOOLEAN()) {
+            return ctx.BOOLEAN().getText().toLowerCase() === "true";
+        }
+        else if (ctx.NULL()) {
+            return null;
+        }
+        throw new PSCImpossibleError(ctx, "Invalid literal");
+    };
+    visitIntLits = async (ctx) => {
+        const sign = ctx.MINUS() !== null ? -1 : 1;
+        return parseInt(ctx.INTEGER().getText(), 10) * sign;
+    };
+    visitFloatLits = async (ctx) => {
+        const sign = ctx.MINUS() !== null ? -1 : 1;
+        return parseFloat(ctx.FLOAT().getText()) * sign;
+    };
+    visitArrayLits = async (ctx) => {
+        const elements = [];
+        if (ctx.expr_list()) {
+            for (const expr of ctx.expr_list()) {
+                elements.push(await this.visitExpr(expr));
+            }
+        }
+        return elements;
+    };
+    visitStmts = async (ctx) => {
+        for (const stmt of ctx.stmt_list()) {
+            await this.visitStmt(stmt);
+            if (this.#isReturning()) {
+                // If a return statement was executed, stop executing further statements
+                break;
+            }
+        }
+    };
+    visitStmt = async (ctx) => {
+        if (ctx.children == null ||
+            ctx.children.length != 1 ||
+            ctx.children[0] == null)
+            throw new PSCImpossibleError(ctx, "Statement must have exactly one child");
+        const child = ctx.children[0];
+        let ruleIndex;
+        try {
+            ruleIndex = child.ruleIndex;
+        }
+        catch (e) {
+            throw new PSCImpossibleError(ctx, `Failed to get ruleIndex from child: ${e}`);
+        }
+        const ruleName = PSCParser.ruleNames[ruleIndex];
+        if (!ruleName) {
+            throw new PSCImpossibleError(ctx, `Undefined rule name. ruleIndex ${ruleIndex} constructor.name ${child.constructor.name}`);
+        }
+        const eventParams = {
+            startLine: child.start.line,
+            startCol: child.start.column,
+            endLine: child.stop?.line,
+            endCol: child.stop !== undefined
+                ? child.stop.column + child.stop.stop - child.stop.start
+                : undefined,
+            stmtType: ruleName,
+        };
+        this.#eventBus.emit("pre_exec_stmt", eventParams);
+        // Dispatch appropriate visit method
+        await this.visit(ctx.children[0]);
+        this.#eventBus.emit("post_exec_stmt", eventParams);
+    };
+    visitBlock = async (ctx) => {
+        if (this.#options.strictVariableScope) {
+            this.#newVariableStack(ctx);
+        }
+        await this.visitStmts(ctx.stmts());
+        if (this.#options.strictVariableScope) {
+            this.#popVariableStack(ctx);
+        }
+    };
+    visitIfStmt = async (ctx) => {
+        // Validate statement structure
+        if (ctx.expr() === null) {
+            throw new PSCImpossibleError(ctx, "If statement must have a condition expression.");
+        }
+        if (ctx.block(0) === null) {
+            throw new PSCImpossibleError(ctx, "If statement must have a 'then' block.");
+        }
+        if (ctx.ELSE() && ctx.block(1) === null && ctx.ifStmt() === null) {
+            throw new PSCImpossibleError(ctx, "If statement with 'else' must have an 'else' block or an 'else if' statement.");
+        }
+        const condition = ctx.expr();
+        if (condition) {
+            // Evaluate the condition
+            const result = await this.visitExpr(condition);
+            // Ensure the result is evaluated to a boolean value
+            if (typeof result !== "boolean") {
+                throw new PSCConditionNotBooleanError(ctx.expr(), this.#asString(ctx, result));
+            }
+            if (result) {
+                // Execute the 'then' block
+                await this.visitBlock(ctx.block(0));
+            }
+            else if (ctx.ELSE()) {
+                if (ctx.block_list().length == 2) {
+                    // Execute the block after else
+                    // Execute the 'else' block if it exists
+                    await this.visitBlock(ctx.block(1));
+                }
+                else if (ctx.ifStmt()) {
+                    // Execute the ifStmt after else
+                    await this.visitIfStmt(ctx.ifStmt());
+                }
+            }
+        }
+    };
+    visitWhileStmt = async (ctx) => {
+        // Validate statement structure
+        if (ctx.expr() === null) {
+            throw new PSCImpossibleError(ctx, "While statement must have a condition expression.");
+        }
+        if (ctx.block() === null) {
+            throw new PSCImpossibleError(ctx, "While statement must have a block to execute.");
+        }
+        const condition = ctx.expr();
+        while (true) {
+            const eventParams = {
+                startLine: ctx.WHILE().symbol.line,
+                startCol: ctx.WHILE().symbol.column,
+                endLine: condition.stop?.line,
+                endCol: condition.stop !== undefined
+                    ? condition.stop.column + condition.stop.stop - condition.stop.start
+                    : undefined,
+            };
+            this.#eventBus.emit("pre_while_condition", eventParams);
+            const result = await this.visitExpr(condition);
+            // Ensure the result is evaluated to a boolean value
+            if (typeof result !== "boolean") {
+                throw new PSCConditionNotBooleanError(ctx.expr(), `Condition must evaluate to a boolean value, got: ${result}`);
+            }
+            this.#eventBus.emit("post_while_condition", {
+                ...eventParams,
+                shouldContinue: result,
+            });
+            if (!result) {
+                break;
+            }
+            await this.visitBlock(ctx.block());
+        }
+    };
+    visitDoWhileStmt = async (ctx) => {
+        if (ctx.expr() === null) {
+            throw new PSCImpossibleError(ctx, "Do-While statement must have a condition expression.");
+        }
+        if (ctx.block() === null) {
+            throw new PSCImpossibleError(ctx, "Do-While statement must have a block to execute.");
+        }
+        const condition = ctx.expr();
+        let result;
+        do {
+            await this.visitBlock(ctx.block());
+            const eventParams = {
+                startLine: ctx.WHILE().symbol.line,
+                startCol: ctx.WHILE().symbol.column,
+                endLine: condition.stop?.line,
+                endCol: condition.stop !== undefined
+                    ? condition.stop.column + condition.stop.stop - condition.stop.start
+                    : undefined,
+            };
+            this.#eventBus.emit("pre_do_while_condition", eventParams);
+            result = await this.visitExpr(condition);
+            // Ensure the result is evaluated to a boolean value
+            if (typeof result !== "boolean") {
+                throw new PSCConditionNotBooleanError(ctx.expr(), `Condition must evaluate to a boolean value, got: ${result}`);
+            }
+            this.#eventBus.emit("post_do_while_condition", {
+                ...eventParams,
+                shouldContinue: result,
+            });
+        } while (result);
+    };
+    visitRepeatUntilStmt = async (ctx) => {
+        if (ctx.expr() === null) {
+            throw new PSCImpossibleError(ctx, "Do-While statement must have a condition expression.");
+        }
+        if (ctx.block() === null) {
+            throw new PSCImpossibleError(ctx, "Do-While statement must have a block to execute.");
+        }
+        const condition = ctx.expr();
+        let result;
+        do {
+            await this.visitBlock(ctx.block());
+            const eventParams = {
+                startLine: ctx.UNTIL().symbol.line,
+                startCol: ctx.UNTIL().symbol.column,
+                endLine: condition.stop?.line,
+                endCol: condition.stop !== undefined
+                    ? condition.stop.column + condition.stop.stop - condition.stop.start
+                    : undefined,
+            };
+            this.#eventBus.emit("pre_repeat_until_condition", eventParams);
+            result = await this.visitExpr(condition);
+            // Ensure the result is evaluated to a boolean value
+            if (typeof result !== "boolean") {
+                throw new PSCConditionNotBooleanError(ctx.expr(), `Condition must evaluate to a boolean value, got: ${result}`);
+            }
+            this.#eventBus.emit("post_repeat_until_condition", {
+                ...eventParams,
+                shouldContinue: !result,
+            });
+        } while (!result);
+    };
+    visitForStmt = async (ctx) => {
+        if (ctx.ID() === null) {
+            throw new PSCImpossibleError(ctx, "For statement must have a loop variable.");
+        }
+        if (ctx.expr(0) === null || ctx.expr(1) === null) {
+            throw new PSCImpossibleError(ctx, "For statement must have both 'from' and 'to' expressions.");
+        }
+        if (ctx.block() === null) {
+            throw new PSCImpossibleError(ctx, "For statement must have a block to execute.");
+        }
+        const loopVar = ctx.ID().getText();
+        const fromExpr = ctx.expr(0);
+        const toExpr = ctx.expr(1);
+        const fromValue = await this.visitExpr(fromExpr);
+        const toValue = await this.visitExpr(toExpr);
+        const isDown = ctx.DOWN() !== null;
+        if (this.#variableExists(loopVar)) {
+            throw new PSCForVariableReuseError(ctx, loopVar);
+        }
+        if (typeof fromValue !== "number" ||
+            typeof toValue !== "number" ||
+            !Number.isInteger(fromValue) ||
+            !Number.isInteger(toValue)) {
+            throw new PSCForRangeNotIntegerError(ctx, `${fromValue} and ${toValue}`);
+        }
+        let oldValue = undefined;
+        for (let i = fromValue; isDown ? i >= toValue : i <= toValue; isDown ? i-- : i++) {
+            this.#eventBus.emit("for_variable_change", {
+                startLine: ctx.FOR().symbol.line,
+                startCol: ctx.FOR().symbol.column,
+                endLine: toExpr.stop?.line,
+                endCol: toExpr.stop !== undefined
+                    ? toExpr.stop.column + toExpr.stop.stop - toExpr.stop.start
+                    : undefined,
+                variableName: loopVar,
+                oldValue: oldValue,
+                newValue: i,
+            });
+            this.#assignVariable(ctx, loopVar, i);
+            await this.visitBlock(ctx.block());
+            this.#deleteVariable(ctx, loopVar);
+            oldValue = i;
+        }
+    };
+    visitAsmStmt = async (ctx) => {
+        const ref = await this.visitLvalue(ctx.lvalue());
+        const value = await this.visitExpr(ctx.expr());
+        ref.set(value);
+    };
+    visitLvalue = async (ctx) => {
+        if (ctx.ID()) {
+            const varName = ctx.ID().getText();
+            return {
+                get: () => this.#variableExists(varName)
+                    ? this.#readVariable(ctx, varName)
+                    : undefined,
+                set: (value) => this.#assignVariable(ctx, varName, value),
+            };
+        }
+        else if (ctx.lvalue() && ctx.LSQUARE() && ctx.RSQUARE()) {
+            const leftRef = await this.visitLvalue(ctx.lvalue());
+            const leftVal = leftRef.get();
+            const unnormalizedIndices = await Promise.all(ctx.expr_list().map((expr) => this.visitExpr(expr)));
+            return {
+                get: () => {
+                    // In lvalue array access, since we allow implicit array creation,
+                    // if leftVal is undefined, we return undefined instead of throwing.
+                    if (leftVal === undefined) {
+                        return undefined;
+                    }
+                    let current = leftVal;
+                    for (const unnormalizedIndex of unnormalizedIndices) {
+                        if (!Array.isArray(current)) {
+                            throw new PSCArrayAccessNotArrayError(ctx, this.#asString(ctx, current));
+                        }
+                        const normalizedIndex = this.#normalizeArrayIndexOrThrow(ctx, unnormalizedIndex);
+                        // Since we allow implicit array extension,
+                        // if the index is out of bounds, we return undefined instead of throwing.
+                        if (normalizedIndex >= current.length) {
+                            return undefined;
+                        }
+                        current = current[normalizedIndex];
+                    }
+                    return current;
+                },
+                set: (value) => {
+                    const arr = leftVal != undefined ? leftVal : [];
+                    if (!Array.isArray(arr)) {
+                        throw new PSCArrayAccessNotArrayError(ctx, this.#asString(ctx, arr));
+                    }
+                    // Walk to the parent of the final index, creating intermediate arrays as needed
+                    let current = arr;
+                    for (let i = 0; i < unnormalizedIndices.length - 1; i++) {
+                        const normalizedIndex = this.#normalizeArrayIndexOrThrow(ctx, unnormalizedIndices[i]);
+                        // Implicit extension of the array if the index is out of bounds
+                        while (current.length <= normalizedIndex) {
+                            current.push(undefined);
+                        }
+                        if (current[normalizedIndex] === undefined) {
+                            current[normalizedIndex] = [];
+                        }
+                        if (!Array.isArray(current[normalizedIndex])) {
+                            throw new PSCArrayAccessNotArrayError(ctx, this.#asString(ctx, current[normalizedIndex]));
+                        }
+                        current = current[normalizedIndex];
+                    }
+                    // Set the final index
+                    const lastNormalizedIndex = this.#normalizeArrayIndexOrThrow(ctx, unnormalizedIndices[unnormalizedIndices.length - 1]);
+                    while (current.length <= lastNormalizedIndex) {
+                        current.push(undefined);
+                    }
+                    current[lastNormalizedIndex] = value;
+                    leftRef.set(arr);
+                },
+            };
+        }
+        throw new PSCImpossibleError(ctx, "Invalid assignment left-hand side.");
+    };
+    visitInputStmt = async (ctx) => {
+        const ref = await this.visitLvalue(ctx.lvalue());
+        const value = this.#stringSmartCast(await this.#options.inputFunction?.());
+        ref.set(value);
+    };
+    visitOutputStmt = async (ctx) => {
+        const val = this.#asString(ctx, await this.visitExpr(ctx.expr()));
+        this.#options.outputFunction?.(val);
+    };
+    visitSubprogram = async (ctx) => {
+        const name = ctx.ID(0).getText();
+        const paramNames = ctx
+            .ID_list()
+            ?.slice(1, ctx.ID_list().length)
+            .map((id) => id.getText()) ?? [];
+        // Subprogram is stored as a variable in the current variable stack
+        this.#assignVariable(ctx, name, async (params) => {
+            if (params.length !== paramNames.length) {
+                throw new PSCUnmatchedArgumentsError(ctx, name, paramNames.length, params.length);
+            }
+            // Create a new variable stack for the subprogram execution ignoring strictVariableScope option.
+            // This ensures that variables defined within the subprogram do not interfere with those in the calling context.
+            // If strictVariableScope is true, there is no need to create a new variable stack here
+            // since that is automatically handled by the visitBlock method
+            if (!this.#options.strictVariableScope) {
+                this.#newVariableStack(ctx);
+            }
+            // Assign arguments to the new variable stack
+            for (let i = 0; i < paramNames.length; i++) {
+                this.#assignVariable(ctx, paramNames[i], params[i]);
+            }
+            await this.visitBlock(ctx.block());
+            if (!this.#options.strictVariableScope) {
+                this.#popVariableStack(ctx);
+            }
+            // Terminate the returning state here
+            return this.#terminateReturn() ?? null;
+        });
+    };
+    visitReturnStmt = async (ctx) => {
+        const value = await this.visitExpr(ctx.expr());
+        this.#initiateReturn(value);
+    };
+}
+//# sourceMappingURL=visitor.js.map