mimo-lang 1.1.1 → 2.0.6

package/tools/convert/plugins/alya/visitors/expressions.js

@@ -0,0 +1,257 @@
+/**
+ * Expression visitors for the Mimo → Alya converter.
+ *
+ * Each evaluator method returns the register NAME (without '@') that holds
+ * the computed result. Callers must call freeTemp() for every allocTemp()
+ * they triggered.
+ */
+
+export const expressionVisitors = {
+    // =========================================================================
+    // Literals
+    // =========================================================================
+
+    evalLiteral(node) {
+        const val = node.value;
+
+        if (typeof val === 'number') {
+            const tmp = this.allocTemp();
+            if (Number.isInteger(val)) {
+                // Represent negatives via two's complement trick the assembler supports
+                if (val < 0) {
+                    this.writeLine(`@${tmp} := -${Math.abs(val)}`);
+                } else {
+                    this.writeLine(`@${tmp} := ${val}`);
+                }
+            } else {
+                // Float: embed as bit-pattern comment, store integer part only
+                this.writeLine(`; FLOAT ${val} — stored as truncated integer ${Math.trunc(val)}`);
+                this.writeLine(`@${tmp} := ${Math.trunc(val)}`);
+            }
+            return tmp;
+        }
+
+        if (typeof val === 'boolean') {
+            const tmp = this.allocTemp();
+            this.writeLine(`@${tmp} := ${val ? 1 : 0}`);
+            return tmp;
+        }
+
+        if (typeof val === 'string') {
+            // String literals: use LoadString + syscall
+            const tmp = this.allocTemp();
+            this.writeLine(`@${tmp} := "${val.replace(/"/g, '\\"')}"`);
+            return tmp;
+        }
+
+        if (val === null) {
+            const tmp = this.allocTemp();
+            this.writeLine(`@${tmp} := 0  ; null`);
+            return tmp;
+        }
+
+        const tmp = this.allocTemp();
+        this.writeLine(`; UNSUPPORTED literal type ${typeof val}`);
+        this.writeLine(`@${tmp} := 0`);
+        return tmp;
+    },
+
+    // =========================================================================
+    // Identifiers
+    // =========================================================================
+
+    evalIdentifier(node) {
+        // Return a "virtual register" that IS the variable.
+        // Alya allows @any_name so we don't need to copy.
+        return node.name;
+    },
+
+    // =========================================================================
+    // Binary expressions
+    // =========================================================================
+
+    evalBinary(node) {
+        const lReg = this.evalExpr(node.left);
+        const rReg = this.evalExpr(node.right);
+
+        const op = node.operator;
+        const tmp = this.allocTemp();
+
+        switch (op) {
+            // Arithmetic
+            case '+':  this.writeLine(`@${tmp} := @${lReg} + @${rReg}`); break;
+            case '-':  this.writeLine(`@${tmp} := @${lReg} - @${rReg}`); break;
+            case '*':  this.writeLine(`@${tmp} := @${lReg} * @${rReg}`); break;
+            case '/':  this.writeLine(`@${tmp} := @${lReg} / @${rReg}`); break;
+            case '%':  this.writeLine(`@${tmp} := @${lReg} % @${rReg}`); break;
+
+            // Comparison — produce 0/1 integer result
+            case '=':
+            case '==': this._emitCmp(tmp, lReg, rReg, '=='); break;
+            case '!=':
+            case '!':  this._emitCmp(tmp, lReg, rReg, '!='); break;
+            case '<':  this._emitCmp(tmp, lReg, rReg, '<');  break;
+            case '>':  this._emitCmp(tmp, lReg, rReg, '>');  break;
+            case '<=': this._emitCmp(tmp, lReg, rReg, '<='); break;
+            case '>=': this._emitCmp(tmp, lReg, rReg, '>='); break;
+
+            // Logical — short-circuit is expensive without branches;
+            // for simple boolean values we use bitwise AND/OR on 0/1 integers.
+            case 'and': this.writeLine(`@${tmp} := @${lReg} & @${rReg}`); break;
+            case 'or':  this.writeLine(`@${tmp} := @${lReg} | @${rReg}`); break;
+
+            // Bitwise
+            case '&':  this.writeLine(`@${tmp} := @${lReg} & @${rReg}`); break;
+            case '|':  this.writeLine(`@${tmp} := @${lReg} | @${rReg}`); break;
+            case '^':  this.writeLine(`@${tmp} := @${lReg} ^ @${rReg}`); break;
+            case '<<': this.writeLine(`@${tmp} := @${lReg} << @${rReg}`); break;
+            case '>>': this.writeLine(`@${tmp} := @${lReg} >> @${rReg}`); break;
+
+            default:
+                this.writeLine(`; UNSUPPORTED binary operator: ${op}`);
+                this.writeLine(`@${tmp} := 0`);
+        }
+
+        // Free operand temps (only if they are actual temps, not variable names)
+        this._maybeFreeTemp(rReg);
+        this._maybeFreeTemp(lReg);
+
+        return tmp;
+    },
+
+    /**
+     * Emit a comparison that leaves 1/0 in @dest.
+     * Pattern: load 1; if NOT condition goto skip; dest stays 1; skip: (else load 0)
+     * Actually simpler: load 1, then if cond holds goto done, else load 0; done:
+     */
+    _emitCmp(dest, lReg, rReg, op) {
+        const trueLabel = this.newLabel('cmpT');
+        const endLabel  = this.newLabel('cmpE');
+        // Invert the operator to jump to the "false" path
+        const invertOp = { '==': '!=', '!=': '==', '<': '>=', '>': '<=', '<=': '>', '>=': '<' };
+        const jumpOp = invertOp[op] || '!=';
+        this.writeLine(`@${dest} := 1`);
+        this.writeLine(`if @${lReg} ${op} @${rReg} goto ${trueLabel}`);
+        this.writeLine(`@${dest} := 0`);
+        this.writeLine(`goto ${endLabel}`);
+        this.writeLine(`${trueLabel}:`);
+        this.writeLine(`${endLabel}:`);
+    },
+
+    // =========================================================================
+    // Unary expressions
+    // =========================================================================
+
+    evalUnary(node) {
+        const argReg = this.evalExpr(node.argument);
+        const tmp = this.allocTemp();
+
+        switch (node.operator) {
+            case '-':
+                // negate: 0 - x
+                this.writeLine(`@${tmp} := 0`);
+                this.writeLine(`@${tmp} := @${tmp} - @${argReg}`);
+                break;
+            case 'not':
+            case '!': {
+                // Boolean NOT: 1 if argReg == 0, else 0
+                const skipLabel = this.newLabel('notT');
+                const endLabel  = this.newLabel('notE');
+                this.writeLine(`@${tmp} := 0`);
+                this.writeLine(`if @${argReg} != 0 goto ${skipLabel}`);
+                this.writeLine(`@${tmp} := 1`);
+                this.writeLine(`goto ${endLabel}`);
+                this.writeLine(`${skipLabel}:`);
+                this.writeLine(`${endLabel}:`);
+                break;
+            }
+            case '~':
+                this.writeLine(`@${tmp} := ~@${argReg}`);
+                break;
+            default:
+                this.writeLine(`; UNSUPPORTED unary: ${node.operator}`);
+                this.writeLine(`@${tmp} := @${argReg}`);
+        }
+
+        this._maybeFreeTemp(argReg);
+        return tmp;
+    },
+
+    // =========================================================================
+    // Inline if expression:  if cond then a else b
+    // =========================================================================
+
+    evalInlineIf(node) {
+        const condReg = this.evalExpr(node.condition);
+        const result  = this.allocTemp();
+        const elseLabel = this.newLabel('iiE');
+        const endLabel  = this.newLabel('iiF');
+
+        this.writeLine(`if @${condReg} == 0 goto ${elseLabel}`);
+        this._maybeFreeTemp(condReg);
+
+        // Consequent
+        const thenReg = this.evalExpr(node.consequent);
+        this.writeLine(`@${result} := @${thenReg}`);
+        this._maybeFreeTemp(thenReg);
+        this.writeLine(`goto ${endLabel}`);
+
+        this.writeLine(`${elseLabel}:`);
+        const altReg = this.evalExpr(node.alternate);
+        this.writeLine(`@${result} := @${altReg}`);
+        this._maybeFreeTemp(altReg);
+
+        this.writeLine(`${endLabel}:`);
+        return result;
+    },
+
+    // =========================================================================
+    // Call expression (used when a call appears inside an expression)
+    // =========================================================================
+
+    evalCall(node) {
+        // Evaluate and pass arguments via @__a0, @__a1, …
+        const argRegs = (node.arguments || []).map((arg) => this.evalExpr(arg));
+        argRegs.forEach((reg, i) => {
+            this.writeLine(`@__a${i} := @${reg}`);
+        });
+        argRegs.forEach((reg) => this._maybeFreeTemp(reg));
+
+        // Get callee name
+        let calleeName = null;
+        if (node.callee.type === 'Identifier') {
+            calleeName = node.callee.name;
+        } else if (node.callee.type === 'ModuleAccess') {
+            calleeName = `${node.callee.module}__${node.callee.property}`;
+        }
+
+        if (!calleeName) {
+            this.writeLine(`; UNSUPPORTED: complex callee in expression`);
+            const tmp = this.allocTemp();
+            this.writeLine(`@${tmp} := 0`);
+            return tmp;
+        }
+
+        // If inside a function, save/restore live registers around the call
+        if (this._inFunction) {
+            this._emitCallWithSave(calleeName);
+        } else {
+            this.writeLine(`call ${calleeName}`);
+        }
+
+        // Return value is in @__ret — copy to a temp so the caller can use it
+        const tmp = this.allocTemp();
+        this.writeLine(`@${tmp} := @__ret`);
+        return tmp;
+    },
+
+    // =========================================================================
+    // Internal helper: only free if this is a temp (starts with __t)
+    // =========================================================================
+
+    _maybeFreeTemp(regName) {
+        if (regName && regName.startsWith('__t')) {
+            this.freeTemp();
+        }
+    },
+};

package/tools/convert/plugins/alya/visitors/statements.js

@@ -0,0 +1,403 @@
+/**
+ * Statement visitors for the Mimo → Alya converter.
+ * Mixed into MimoToAlyaConverter via Object.assign.
+ */
+
+export const statementVisitors = {
+    // =========================================================================
+    // Program
+    // =========================================================================
+
+    visitProgram(node) {
+        // Handled by convert() — should not be called directly.
+        (node.body || []).forEach((stmt) => this.visitNode(stmt));
+    },
+
+    // =========================================================================
+    // show statement  →  print @reg (integers/booleans)
+    //                    syscall    (strings)
+    // =========================================================================
+
+    visitShowStatement(node) {
+        const reg = this.evalExpr(node.expression);
+        const exprNode = node.expression;
+
+        // If the expression is a string literal, use syscall 2
+        if (exprNode.type === 'Literal' && typeof exprNode.value === 'string') {
+            this.writeLine(`; show (string)`);
+            this.writeLine(`@r0 := 2`);
+            this.writeLine(`@r1 := @${reg}`);
+            this.writeLine(`syscall`);
+        } else {
+            this.writeLine(`print @${reg}`);
+        }
+
+        this._maybeFreeTemp(reg);
+    },
+
+    // =========================================================================
+    // Variable declarations  (set / let / const)
+    // =========================================================================
+
+    visitVariableDeclaration(node) {
+        // Track as a local if we're inside a function
+        this._trackLocal(node.identifier);
+
+        const reg = this.evalExpr(node.value);
+        if (reg !== node.identifier) {
+            this.writeLine(`@${node.identifier} := @${reg}`);
+            this._maybeFreeTemp(reg);
+        }
+        // If evalExpr returned the variable name itself (identifier → itself), no copy needed.
+    },
+
+    // =========================================================================
+    // Return statement
+    // =========================================================================
+
+    visitReturnStatement(node) {
+        if (node.argument) {
+            const reg = this.evalExpr(node.argument);
+            this.writeLine(`@__ret := @${reg}`);
+            this._maybeFreeTemp(reg);
+        } else {
+            this.writeLine(`@__ret := 0`);
+        }
+        this.writeLine(`return`);
+    },
+
+    // =========================================================================
+    // Function declaration — deferred to _emitFunction in to_alya.js
+    // =========================================================================
+
+    visitFunctionDeclaration(node) {
+        // Top-level functions are collected in convert() and emitted before __main.
+        // If we encounter a nested function declaration (not supported), warn and skip.
+        if (this._inFunction) {
+            this.writeLine(`; UNSUPPORTED: nested function declaration '${node.name}'`);
+        }
+        // Already handled in convert(); nothing to emit here.
+    },
+
+    // =========================================================================
+    // Call statement  (standalone call, with optional destination)
+    // =========================================================================
+
+    visitCallStatement(node) {
+        // Evaluate args
+        const argRegs = (node.arguments || []).map((arg) => this.evalExpr(arg));
+        argRegs.forEach((reg, i) => {
+            this.writeLine(`@__a${i} := @${reg}`);
+        });
+        argRegs.forEach((reg) => this._maybeFreeTemp(reg));
+
+        // Callee
+        let calleeName = null;
+        if (node.callee.type === 'Identifier') {
+            calleeName = node.callee.name;
+        } else if (node.callee.type === 'ModuleAccess') {
+            calleeName = `${node.callee.module}__${node.callee.property}`;
+        }
+
+        if (!calleeName) {
+            this.writeLine(`; UNSUPPORTED: complex callee`);
+            return;
+        }
+
+        // If inside a function, save/restore live registers around the call
+        if (this._inFunction) {
+            this._emitCallWithSave(calleeName);
+        } else {
+            this.writeLine(`call ${calleeName}`);
+        }
+
+        // Capture return value if destination specified
+        if (node.destination) {
+            this.writeLine(`@${node.destination.name} := @__ret`);
+        }
+    },
+
+    // =========================================================================
+    // Assignment operators  (+=, -=, *=, /=, etc.)
+    // These appear as VariableDeclaration nodes with kind 'set' after
+    // the variable is already declared, OR as separate AssignmentStatement
+    // nodes (if the parser emits them that way).
+    // =========================================================================
+
+    visitAssignmentStatement(node) {
+        // node.identifier: string name
+        // node.operator: '=', '+=', '-=', '*=', '/='
+        // node.value: expression node
+        const reg = this.evalExpr(node.value);
+        const op = node.operator;
+
+        switch (op) {
+            case '=':
+                if (reg !== node.identifier) {
+                    this.writeLine(`@${node.identifier} := @${reg}`);
+                }
+                break;
+            case '+=': this.writeLine(`@${node.identifier} += @${reg}`); break;
+            case '-=': this.writeLine(`@${node.identifier} -= @${reg}`); break;
+            case '*=': this.writeLine(`@${node.identifier} *= @${reg}`); break;
+            case '/=': this.writeLine(`@${node.identifier} /= @${reg}`); break;
+            default:
+                // Fallback: evaluate and assign
+                this.writeLine(`; assignment op '${op}' mapped to plain assign`);
+                this.writeLine(`@${node.identifier} := @${reg}`);
+        }
+
+        this._maybeFreeTemp(reg);
+    },
+
+    visitPropertyAssignment(node) {
+        this.writeLine(`; UNSUPPORTED: PropertyAssignment`);
+    },
+
+    visitBracketAssignment(node) {
+        this.writeLine(`; UNSUPPORTED: BracketAssignment`);
+    },
+
+    visitDestructuringAssignment(node) {
+        this.writeLine(`; UNSUPPORTED: DestructuringAssignment`);
+    },
+
+    // =========================================================================
+    // if / else if / else
+    // =========================================================================
+
+    visitIfStatement(node) {
+        const endLabel = this.newLabel('ifEnd');
+        this._emitIfChain(node, endLabel);
+        this.writeLine(`${endLabel}:`);
+    },
+
+    _emitIfChain(node, endLabel) {
+        const condReg = this.evalExpr(node.condition);
+        const nextLabel = this.newLabel('ifNext');
+
+        // Jump past this branch if condition is false (== 0)
+        this.writeLine(`if @${condReg} == 0 goto ${nextLabel}`);
+        this._maybeFreeTemp(condReg);
+
+        // Consequent block
+        (node.consequent || []).forEach((stmt) => this.visitNode(stmt));
+        this.writeLine(`goto ${endLabel}`);
+
+        this.writeLine(`${nextLabel}:`);
+
+        if (node.alternate) {
+            if (node.alternate.type === 'IfStatement') {
+                // else if chain
+                this._emitIfChain(node.alternate, endLabel);
+            } else if (Array.isArray(node.alternate)) {
+                // plain else block
+                node.alternate.forEach((stmt) => this.visitNode(stmt));
+            } else {
+                // single statement alternate
+                this.visitNode(node.alternate);
+            }
+        }
+    },
+
+    visitGuardStatement(node) {
+        // guard condition else <block> end
+        // → if (!condition) { block }
+        const condReg = this.evalExpr(node.condition);
+        const skipLabel = this.newLabel('guardEnd');
+        this.writeLine(`if @${condReg} != 0 goto ${skipLabel}`);
+        this._maybeFreeTemp(condReg);
+        (node.alternate || node.elseBlock || []).forEach((stmt) => this.visitNode(stmt));
+        this.writeLine(`${skipLabel}:`);
+    },
+
+    // =========================================================================
+    // while loop
+    // =========================================================================
+
+    visitWhileStatement(node) {
+        const loopLabel = this.newLabel('wLoop');
+        const endLabel  = this.newLabel('wEnd');
+
+        this.pushLoop(endLabel, loopLabel);
+
+        this.writeLine(`${loopLabel}:`);
+
+        const condReg = this.evalExpr(node.condition);
+        this.writeLine(`if @${condReg} == 0 goto ${endLabel}`);
+        this._maybeFreeTemp(condReg);
+
+        (node.body || []).forEach((stmt) => this.visitNode(stmt));
+        this.writeLine(`goto ${loopLabel}`);
+        this.writeLine(`${endLabel}:`);
+
+        this.popLoop();
+    },
+
+    // =========================================================================
+    // for … in <iterable>
+    //
+    // Only range() is supported.  Produces:
+    //   @var := start
+    //   loop: if @var >= end goto end
+    //     body
+    //     @var += 1 (or step)
+    //   goto loop
+    //   end:
+    // =========================================================================
+
+    visitForStatement(node) {
+        const varName = node.variable.name;
+        const loopLabel = this.newLabel('fLoop');
+        const endLabel  = this.newLabel('fEnd');
+        const iterable  = node.iterable;
+
+        this.pushLoop(endLabel, loopLabel);
+
+        // Only support range() iterables
+        if (iterable.type === 'RangeLiteral' ||
+            (iterable.type === 'CallExpression' &&
+             iterable.callee?.name === 'range')) {
+            this._emitForRange(varName, loopLabel, endLabel, iterable, node.body || []);
+        } else if (iterable.type === 'RangeLiteral') {
+            this._emitForRange(varName, loopLabel, endLabel, iterable, node.body || []);
+        } else {
+            this.writeLine(`; UNSUPPORTED for-in: only range() is supported`);
+        }
+
+        this.popLoop();
+    },
+
+    _emitForRange(varName, loopLabel, endLabel, rangeNode, body) {
+        // RangeLiteral: { start, end }  (step always 1 in Mimo)
+        // CallExpression to range(start, end) — also 1 step
+        let startNode, endNode;
+
+        if (rangeNode.type === 'RangeLiteral') {
+            startNode = rangeNode.start;
+            endNode   = rangeNode.end;
+        } else {
+            // range(start, end) call
+            const args = rangeNode.arguments || [];
+            if (args.length === 1) {
+                startNode = { type: 'Literal', value: 0 };
+                endNode   = args[0];
+            } else {
+                startNode = args[0];
+                endNode   = args[1];
+            }
+        }
+
+        const startReg = this.evalExpr(startNode);
+        this.writeLine(`@${varName} := @${startReg}`);
+        this._maybeFreeTemp(startReg);
+
+        const endReg = this.evalExpr(endNode);
+        // Stash the end value in a dedicated register so the loop condition
+        // doesn't re-evaluate it on every iteration.
+        const endVar = `__fe${this._labelCounter}`;
+        this.writeLine(`@${endVar} := @${endReg}`);
+        this._maybeFreeTemp(endReg);
+
+        this.writeLine(`${loopLabel}:`);
+        this.writeLine(`if @${varName} >= @${endVar} goto ${endLabel}`);
+        body.forEach((stmt) => this.visitNode(stmt));
+        this.writeLine(`@${varName} += 1`);
+        this.writeLine(`goto ${loopLabel}`);
+        this.writeLine(`${endLabel}:`);
+    },
+
+    // =========================================================================
+    // loop … end  (infinite loop with break/continue)
+    // =========================================================================
+
+    visitLoopStatement(node) {
+        const loopLabel = this.newLabel('loop');
+        const endLabel  = this.newLabel('loopEnd');
+
+        this.pushLoop(endLabel, loopLabel);
+        this.writeLine(`${loopLabel}:`);
+        (node.body || []).forEach((stmt) => this.visitNode(stmt));
+        this.writeLine(`goto ${loopLabel}`);
+        this.writeLine(`${endLabel}:`);
+        this.popLoop();
+    },
+
+    // =========================================================================
+    // break / continue
+    // =========================================================================
+
+    visitBreakStatement(node) {
+        const loop = this.currentLoop();
+        if (loop) {
+            this.writeLine(`goto ${loop.breakLabel}`);
+        } else {
+            this.writeLine(`; break outside loop — ignored`);
+        }
+    },
+
+    visitContinueStatement(node) {
+        const loop = this.currentLoop();
+        if (loop) {
+            this.writeLine(`goto ${loop.continueLabel}`);
+        } else {
+            this.writeLine(`; continue outside loop — ignored`);
+        }
+    },
+
+    // =========================================================================
+    // Labeled statement (Mimo: label name ... end)
+    // =========================================================================
+
+    visitLabeledStatement(node) {
+        this.writeLine(`${node.label}:`);
+        this.visitNode(node.statement);
+    },
+
+    // =========================================================================
+    // try / catch / throw  — not supported
+    // =========================================================================
+
+    visitTryStatement(node) {
+        this.writeLine(`; UNSUPPORTED: try/catch — executing try block only`);
+        (node.tryBlock || []).forEach((stmt) => this.visitNode(stmt));
+    },
+
+    visitThrowStatement(node) {
+        this.writeLine(`; UNSUPPORTED: throw — emitting halt`);
+        this.writeLine(`halt`);
+    },
+
+    // =========================================================================
+    // import — not supported
+    // =========================================================================
+
+    visitImportStatement(node) {
+        this.writeLine(`; UNSUPPORTED: import '${node.path}' as ${node.alias}`);
+    },
+
+    // =========================================================================
+    // Decorators — not supported
+    // =========================================================================
+
+    visitDecoratorStatement(node) {
+        this.writeLine(`; UNSUPPORTED: decorator`);
+    },
+
+    // =========================================================================
+    // Pipe expression statement (rare but possible)
+    // =========================================================================
+
+    visitPipeExpression(node) {
+        const reg = this.evalExpr(node);
+        this._maybeFreeTemp(reg);
+    },
+
+    // =========================================================================
+    // Match statement — not supported
+    // =========================================================================
+
+    visitMatchStatement(node) {
+        this.writeLine(`; UNSUPPORTED: match statement`);
+    },
+};