exprforge 0.1.0

package/emitters/csharp.js

@@ -0,0 +1,86 @@
+// exprforge/emitters/csharp.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `Math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `Math.${name}(${a}, ${b})`;
+}
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// NOT just capitalize(fn.name): C# forbids a member from sharing its
+// enclosing type's exact name (CS0542), unlike Java, which permits a
+// same-named non-constructor method. Fine as long as capitalize() changes
+// the name (e.g. "fibonacci" -> "Fibonacci"), but every AST-author name
+// that's already capitalized (e.g. this project's SpEf-prefixed samples)
+// makes capitalize() a no-op -- class and method end up identical, a real
+// compile error confirmed against a real sample, not a hypothetical.
+function wrapperClassName(fnName) {
+    return `${capitalize(fnName)}Impl`;
+}
+
+const emitter = new Emitter({
+    ext: "cs",
+    // Always suffixed with d: a bare integer-valued literal like `5` is a
+    // C# int by default, and int/int is integer division -- silently
+    // wrong if both operands of a div() ever happened to be int-valued
+    // literals. The suffix forces double everywhere, no exceptions,
+    // rather than only suffixing the cases that would otherwise break.
+    formatNumber: (v) => `${v}d`,
+    calls: {
+        sqrt: fn1("Sqrt"), abs: fn1("Abs"), sin: fn1("Sin"), cos: fn1("Cos"), tan: fn1("Tan"),
+        asin: fn1("Asin"), acos: fn1("Acos"), atan: fn1("Atan"), log: fn1("Log"),
+        log2: fn1("Log2"), log10: fn1("Log10"), exp: fn1("Exp"), floor: fn1("Floor"),
+        ceil: fn1("Ceiling"), round: fn1("Round"), trunc: fn1("Truncate"),
+        pow: fn2("Pow"), atan2: fn2("Atan2"), min: fn2("Min"), max: fn2("Max"),
+        // Math.Sign returns int, not double -- our AST is float64-only throughout.
+        sign: ([x]) => `((double) Math.Sign(${x}))`,
+        // No Math.Hypot in .NET -- same manual formula as QB64's/C's.
+        hypot: ([a, b]) => `Math.Sqrt((${a}) * (${a}) + (${b}) * (${b}))`,
+    },
+    // C# has a native ?: ternary, same syntax as JS/C/Java -- no override
+    // needed, this is exactly what base.js's default already emits.
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `        double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `public static class ${wrapperClassName(fn.name)}\n` +
+               `{\n` +
+               `    public static double ${fn.name}(${params})\n` +
+               `    {\n` +
+               letsBlock +
+               `        return ${body};\n` +
+               `    }\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: a native C# value tuple with
+    // named elements -- real field access (result.rx) with no wrapper
+    // type to declare, and (unlike Go's named returns) no risk of
+    // colliding with a same-named let binding, since a tuple literal's
+    // element names aren't pre-declared locals in the method body.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `        double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const returnType = `(${outputNames.map((n) => `double ${n}`).join(", ")})`;
+        const returnExpr = `(${outputNames.map((n) => `${n}: ${outputStrs[n]}`).join(", ")})`;
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `public static class ${wrapperClassName(fn.name)}\n` +
+               `{\n` +
+               `    public static ${returnType} ${fn.name}(${params})\n` +
+               `    {\n` +
+               letsBlock +
+               `        return ${returnExpr};\n` +
+               `    }\n` +
+               `}\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/go.js

@@ -0,0 +1,95 @@
+// exprforge/emitters/go.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `math.${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "go",
+    formatNumber: (v) => (Number.isInteger(v) ? `${v}.0` : String(v)),
+    calls: {
+        sqrt: fn1("Sqrt"), abs: fn1("Abs"), sin: fn1("Sin"), cos: fn1("Cos"), tan: fn1("Tan"),
+        asin: fn1("Asin"), acos: fn1("Acos"), atan: fn1("Atan"), log: fn1("Log"),
+        log2: fn1("Log2"), log10: fn1("Log10"), exp: fn1("Exp"), floor: fn1("Floor"),
+        ceil: fn1("Ceil"), round: fn1("Round"), trunc: fn1("Trunc"),
+        pow: fn2("Pow"), atan2: fn2("Atan2"), min: fn2("Min"), max: fn2("Max"), hypot: fn2("Hypot"),
+        // NOT math.Copysign(1, x): that only reads the sign bit, so it
+        // returns ±1 at x == 0 too, unlike JS's Math.sign(0) === 0 (and
+        // C's/Java's sign, which both special-case zero). Found by the
+        // kitchen-sink conformance test at exactly x - y == 0.
+        sign: ([x]) => `func() float64 { if ${x} > 0.0 { return 1.0 }; if ${x} < 0.0 { return -1.0 }; return 0.0 }()`,
+    },
+    // Go has no ternary operator at all (a deliberate language design
+    // choice) and `if` is a statement, not an expression — so there's no
+    // C-style `cond ? a : b` to fall back on. The standard idiom for an
+    // inline conditional *expression* is an immediately-invoked anonymous
+    // function; it's still one short-circuiting expression, so no change
+    // needed elsewhere.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `func() float64 { if ${L} ${condNode.op} ${R} { return ${thenStr} }; return ${elseStr} }()`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `${p} float64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `\tvar ${name} float64 = ${valueStr}`).join("\n");
+        // A let-chain can bind more names than any one function's body
+        // reads (e.g. a shared chain computes ux/uy/uz for three sibling
+        // single-component functions, each returning only one) — harmless
+        // everywhere else, but Go treats an unused local as a hard compile
+        // error, not a warning. Blank-discard every binding unconditionally
+        // rather than tracking which ones a given body actually reaches.
+        const guards = letBindings.map(({ name }) => `\t_ = ${name}`).join("\n");
+        const letsBlock = lets ? lets + "\n" + guards + "\n" : "";
+        // Only every emitter template here calls math.*, so this substring
+        // check is exact: omit the import when neither the body nor any let
+        // binding has a math call, or Go's "imported and not used" fails
+        // the build.
+        const mathImport = (body + lets).includes("math.") ? `import "math"\n\n` : "";
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `package exprforge\n\n` +
+               mathImport +
+               `func ${capitalize(fn.name)}(${params}) float64 {\n` +
+               letsBlock +
+               `\treturn ${body}\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: Go's native multiple return
+    // values. NOT named return values (`(rx, ry float64)`) even though
+    // that reads nicer in the signature: those are sugar for pre-declared
+    // locals in the function's own scope, which collides — a real,
+    // hit-on-the-first-real-sample bug — whenever an output name matches
+    // a let-binding name (e.g. a "rx" output alongside an internal "rx"
+    // intermediate). Plain unnamed return types sidestep that whole class
+    // of collision regardless of what any AST author names things; a
+    // leading doc comment documents the order instead.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `${p} float64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `\tvar ${name} float64 = ${valueStr}`).join("\n");
+        const guards = letBindings.map(({ name }) => `\t_ = ${name}`).join("\n");
+        const letsBlock = lets ? lets + "\n" + guards + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const returnTypes = outputNames.map(() => "float64").join(", ");
+        const returnStmt = outputNames.map((n) => outputStrs[n]).join(", ");
+        const mathImport = (lets + returnStmt).includes("math.") ? `import "math"\n\n` : "";
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `package exprforge\n\n` +
+               mathImport +
+               `// Returns (${outputNames.join(", ")}).\n` +
+               `func ${capitalize(fn.name)}(${params}) (${returnTypes}) {\n` +
+               letsBlock +
+               `\treturn ${returnStmt}\n` +
+               `}\n`;
+    },
+});
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+module.exports = emitter;

package/emitters/java.js

@@ -0,0 +1,76 @@
+// exprforge/emitters/java.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `Math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `Math.${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "java",
+    formatNumber: (v) => (Number.isInteger(v) ? `${v}.0` : String(v)),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), log: fn1("log"),
+        log10: fn1("log10"), exp: fn1("exp"), floor: fn1("floor"), ceil: fn1("ceil"),
+        signum: fn1("signum"),
+        pow: fn2("pow"), atan2: fn2("atan2"), min: fn2("min"), max: fn2("max"), hypot: fn2("hypot"),
+        // Math has no log2; Java also lacks round-to-double and trunc directly.
+        log2: ([x]) => `(Math.log(${x}) / Math.log(2.0))`,
+        round: ([x]) => `((double) Math.round(${x}))`,
+        trunc: ([x]) => `(double) (long) (${x})`,
+        sign: fn1("signum"),
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `        double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `public final class ${capitalize(fn.name)} {\n` +
+               `    private ${capitalize(fn.name)}() {\n` +
+               `    }\n\n` +
+               `    public static double ${fn.name}(${params}) {\n` +
+               letsBlock +
+               `        return ${body};\n` +
+               `    }\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: Java has no native multi-return,
+    // so this nests a small immutable Result class inside the same
+    // top-level class every function here already gets, keeping everything
+    // in the one per-function file this project's output layout assumes.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `        double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const fields = outputNames.map((n) => `        public final double ${n};`).join("\n");
+        const ctorParams = outputNames.map((n) => `double ${n}`).join(", ");
+        const ctorAssigns = outputNames.map((n) => `            this.${n} = ${n};`).join("\n");
+        const newArgs = outputNames.map((n) => outputStrs[n]).join(", ");
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `public final class ${capitalize(fn.name)} {\n` +
+               `    private ${capitalize(fn.name)}() {\n` +
+               `    }\n\n` +
+               `    public static final class Result {\n` +
+               `${fields}\n\n` +
+               `        Result(${ctorParams}) {\n` +
+               `${ctorAssigns}\n` +
+               `        }\n` +
+               `    }\n\n` +
+               `    public static Result ${fn.name}(${params}) {\n` +
+               letsBlock +
+               `        return new Result(${newArgs});\n` +
+               `    }\n` +
+               `}\n`;
+    },
+});
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+module.exports = emitter;

package/emitters/js.js

@@ -0,0 +1,49 @@
+// exprforge/emitters/js.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `Math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `Math.${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "js",
+    formatNumber: (v) => String(v),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), log: fn1("log"),
+        log2: fn1("log2"), log10: fn1("log10"), exp: fn1("exp"), floor: fn1("floor"),
+        ceil: fn1("ceil"), round: fn1("round"), trunc: fn1("trunc"), sign: fn1("sign"),
+        pow: fn2("pow"), atan2: fn2("atan2"), min: fn2("min"), max: fn2("max"), hypot: fn2("hypot"),
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `// AUTO-GENERATED by ExprForge — do not hand-edit.\n` +
+               `function ${fn.name}(${fn.params.join(", ")}) {\n` +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n\n` +
+               `module.exports = { ${fn.name} };\n`;
+    },
+    // Multiple named outputs from one call: a plain object literal, JS's
+    // native idiom for this — no new type needed.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const fields = Object.entries(outputStrs)
+            .map(([name, valueStr]) => `        ${name}: ${valueStr},`)
+            .join("\n");
+        return `// AUTO-GENERATED by ExprForge — do not hand-edit.\n` +
+               `function ${fn.name}(${fn.params.join(", ")}) {\n` +
+               letsBlock +
+               `    return {\n${fields}\n    };\n` +
+               `}\n\n` +
+               `module.exports = { ${fn.name} };\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/lua.js

@@ -0,0 +1,103 @@
+// exprforge/emitters/lua.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `math.${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "lua",
+    // Lua accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9") -- no suffix or conversion needed.
+    // Integer-valued literals may be Lua's integer subtype (5.3+), but
+    // that's safe here: every bin op comes from ast.js's own +-*/ set,
+    // and Lua's `/` is always true (float) division regardless of
+    // operand types, unlike C#'s int/int trap.
+    formatNumber: (v) => String(v),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), exp: fn1("exp"),
+        min: fn2("min"), max: fn2("max"),
+        // Lua 5.3+ removed math.atan2 -- math.atan(y, x) with a second
+        // argument is the replacement.
+        atan2: fn2("atan"),
+        // Lua 5.3+ removed math.pow -- ^ is the exponentiation operator
+        // (always float-producing, like / ).
+        pow: ([x, y]) => `(${x} ^ ${y})`,
+        // math.log takes an optional base -- covers log/log2/log10 in one
+        // function rather than three.
+        log: fn1("log"),
+        log2: ([x]) => `math.log(${x}, 2)`,
+        log10: ([x]) => `math.log(${x}, 10)`,
+        // math.floor/math.ceil return Lua's integer subtype (5.3+), not
+        // float -- +0.0 coerces back, matching this project's float64-only
+        // model everywhere else.
+        floor: ([x]) => `(math.floor(${x}) + 0.0)`,
+        ceil: ([x]) => `(math.ceil(${x}) + 0.0)`,
+        // No math.round in Lua at any version -- the standard manual idiom
+        // (floor(x+0.5)) matches JS's/Java's round-half-up convention, not
+        // C/Go/Rust's round-half-away-from-zero -- same already-documented,
+        // already-avoided-in-tests divergence as elsewhere in this project,
+        // not a new one.
+        round: ([x]) => `(math.floor(${x} + 0.5) + 0.0)`,
+        // No math.trunc either -- math.modf(x) returns (integral,
+        // fractional) parts as its two results; parenthesizing the call
+        // selects just the first (Lua's standard idiom for narrowing a
+        // multi-return to one value), which is exactly trunc(x), and
+        // already float-typed.
+        trunc: ([x]) => `(math.modf(${x}))`,
+        // No math.sign either. Lua's and/or conditional idiom is safe here
+        // specifically because only nil/false are falsy in Lua -- 0.0 (or
+        // any number) is always truthy, unlike JS/Python/C. Zero-aware by
+        // construction (see Go's/Rust's sign() history in this project for
+        // what happens when it isn't).
+        sign: ([x]) => `((${x} > 0) and 1.0 or ((${x} < 0) and -1.0 or 0.0))`,
+        // No math.hypot in Lua's standard library at any version.
+        hypot: ([a, b]) => `math.sqrt((${a}) * (${a}) + (${b}) * (${b}))`,
+    },
+    // Lua has no ?: ternary. `cond and a or b` is the standard idiom --
+    // safe here for the same reason sign() above is: every value in this
+    // AST is a number, and only nil/false are ever falsy in Lua, so `a`
+    // (the then-branch) is never mistaken for "falsy" regardless of its
+    // numeric value (unlike this same idiom in some other languages).
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `((${L} ${condNode.op} ${R}) and (${thenStr}) or (${elseStr}))`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    local ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `-- AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `function ${fn.name}(${params})\n` +
+               letsBlock +
+               `    return ${body}\n` +
+               `end\n`;
+    },
+    // Multiple named outputs from one call: Lua's native multiple return
+    // values -- the cleanest of any target here, no wrapper type and no
+    // collision risk (unlike Go's named returns, `local` declarations in
+    // the body and the trailing `return` list are entirely separate
+    // namespaces). A leading comment documents the order, since Lua's
+    // returns are positional, not named, at the call site.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    local ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const returnStmt = outputNames.map((n) => outputStrs[n]).join(", ");
+        return `-- AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `-- Returns (${outputNames.join(", ")}).\n` +
+               `function ${fn.name}(${params})\n` +
+               letsBlock +
+               `    return ${returnStmt}\n` +
+               `end\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/python.js

@@ -0,0 +1,85 @@
+// exprforge/emitters/python.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `math.${name}(${a}, ${b})`;
+}
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+const emitter = new Emitter({
+    ext: "py",
+    // Python accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9"), unlike QB64/C# -- no conversion or
+    // suffix needed. Integer-valued literals stay Python ints, but that's
+    // safe here: every bin op comes from ast.js's own +-*/ set, and
+    // Python 3's `/` is always true (float) division regardless of
+    // operand types, unlike C#'s int/int trap.
+    formatNumber: (v) => String(v),
+    calls: {
+        sqrt: fn1("sqrt"), abs: ([x]) => `abs(${x})`, sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), atan2: fn2("atan2"),
+        log: fn1("log"), log2: fn1("log2"), log10: fn1("log10"), exp: fn1("exp"),
+        pow: fn2("pow"), min: ([a, b]) => `min(${a}, ${b})`, max: ([a, b]) => `max(${a}, ${b})`,
+        hypot: fn2("hypot"),
+        // math.floor/ceil/trunc and builtin round() all return int in
+        // Python 3, not float -- wrap to stay float64 throughout, matching
+        // every other target here, rather than silently switching types.
+        floor: ([x]) => `float(math.floor(${x}))`,
+        ceil: ([x]) => `float(math.ceil(${x}))`,
+        trunc: ([x]) => `float(math.trunc(${x}))`,
+        round: ([x]) => `float(round(${x}))`,
+        // No math.sign in Python's stdlib -- build it directly. Zero-aware
+        // by construction (see Go's/Rust's sign() history in this project
+        // for what happens when it isn't).
+        sign: ([x]) => `(1.0 if ${x} > 0 else (-1.0 if ${x} < 0 else 0.0))`,
+    },
+    // Python has no ?: ternary; `a if cond else b` is its conditional
+    // expression instead, and it's just as short-circuiting.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `(${thenStr} if (${L} ${condNode.op} ${R}) else ${elseStr})`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `import math\n\n\n` +
+               `def ${fn.name}(${params}):\n` +
+               letsBlock +
+               `    return ${body}\n`;
+    },
+    // Multiple named outputs from one call: a small local class (dot
+    // access, result.rx) rather than a plain dict -- consistent with
+    // every other target here (C/Rust's struct, C#/Go's tuple, Java's
+    // nested Result class), and a fixed, self-documenting field set
+    // instead of an untyped mapping.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const className = `${capitalize(fn.name)}Result`;
+        const ctorParams = outputNames.join(", ");
+        const ctorAssigns = outputNames.map((n) => `        self.${n} = ${n}`).join("\n");
+        const ctorArgs = outputNames.map((n) => outputStrs[n]).join(", ");
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `import math\n\n\n` +
+               `class ${className}:\n` +
+               `    def __init__(self, ${ctorParams}):\n` +
+               `${ctorAssigns}\n\n\n` +
+               `def ${fn.name}(${params}):\n` +
+               letsBlock +
+               `    return ${className}(${ctorArgs})\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/qb64.js

@@ -0,0 +1,127 @@
+// exprforge/emitters/qb64.js
+const Emitter = require("./base.js");
+
+const HALF_PI = "1.5707963267948966#";
+
+// QB64/BASIC builtins that silently conflict with a variable or parameter
+// of the same name (case-insensitive) -- confirmed painful in practice
+// (see this project's QB64 gotchas memory, from a sibling game project).
+// Checked below so a collision fails loudly at emission time with a
+// specific name to fix, instead of as a cryptic QB64 compiler error later.
+const QB64_RESERVED = new Set([
+    "len", "val", "str", "int", "abs", "sqr", "sgn", "fix", "rnd", "log", "exp",
+    "sin", "cos", "tan", "atn",
+    "left", "right", "mid", "asc", "chr", "instr", "ltrim", "rtrim", "ucase", "lcase",
+    "space", "string", "hex", "oct",
+    "peek", "inp", "out", "timer", "date", "time", "tab", "spc", "pos",
+]);
+
+function checkReservedNames(names) {
+    for (const name of names) {
+        if (QB64_RESERVED.has(name.toLowerCase())) {
+            throw new Error(
+                `emitter for .bas: "${name}" is a reserved QB64 builtin and can't be used as a ` +
+                `variable/parameter name -- rename it (see QB64_RESERVED in emitters/qb64.js)`,
+            );
+        }
+    }
+}
+
+const emitter = new Emitter({
+    ext: "bas",
+    // JS renders very small/large magnitudes in exponential notation
+    // (String(1e-9) === "1e-9"), and QB64 doesn't accept that combined
+    // with a # suffix ("Invalid expression", confirmed against a real
+    // compiler). Classic BASIC's own exponential form uses D (not E) as
+    // the marker for a double-precision literal -- and needs no separate
+    // # suffix, since D already says "double".
+    formatNumber: (v) => {
+        const s = String(v);
+        return /e/i.test(s) ? s.replace(/e/i, "D") : `${s}#`;
+    },
+    calls: {
+        sqrt: ([x]) => `SQR(${x})`,
+        abs: ([x]) => `ABS(${x})`,
+        sin: ([x]) => `SIN(${x})`,
+        cos: ([x]) => `COS(${x})`,
+        tan: ([x]) => `TAN(${x})`,
+        atan: ([x]) => `ATN(${x})`,
+        exp: ([x]) => `EXP(${x})`,
+        log: ([x]) => `LOG(${x})`,
+        sign: ([x]) => `SGN(${x})`,
+        min: ([a, b]) => `_MIN(${a}, ${b})`,
+        max: ([a, b]) => `_MAX(${a}, ${b})`,
+        round: ([x]) => `_ROUND(${x})`,
+        pow: ([base, exp]) => `(${base} ^ ${exp})`,
+        asin: ([x]) => `ATN(${x} / SQR(-(${x}) * (${x}) + 1#))`,
+        acos: ([x]) => `(${HALF_PI} - ATN(${x} / SQR(-(${x}) * (${x}) + 1#)))`,
+        atan2: ([y, x]) => `_ATAN2(${y}, ${x})`,
+        log2: ([x]) => `(LOG(${x}) / LOG(2#))`,
+        log10: ([x]) => `(LOG(${x}) / LOG(10#))`,
+        floor: ([x]) => `INT(${x})`,
+        ceil: ([x]) => `(-INT(-(${x})))`,
+        trunc: ([x]) => `(SGN(${x}) * INT(ABS(${x})))`,
+        hypot: ([a, b]) => `SQR((${a}) * (${a}) + (${b}) * (${b}))`,
+    },
+    // QB64 has no ternary operator. Comparison operators return -1 (true)
+    // or 0 (false), so the algebraically equivalent expression is:
+    //   (-1 * then) * cond + else * (1 + cond)
+    // cond=-1 (true):  (-1*then)*-1 + else*0 = then
+    // cond= 0 (false): (-1*then)* 0 + else*1 = else
+    // Both `then` and `else` are always evaluated here (see select()'s
+    // doc comment in ast.js) — same as every other target.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        const cond = `(${L} ${condNode.op} ${R})`;
+        return `((-1# * ${thenStr}) * ${cond} + ${elseStr} * (1# + ${cond}))`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        checkReservedNames([fn.name, ...fn.params, ...letBindings.map((b) => b.name)]);
+        const params = fn.params.map((p) => `${p} AS DOUBLE`).join(", ");
+        // NOT `Dim name# AS DOUBLE`: combining the # sigil with an AS
+        // DOUBLE clause on the same DIM is a syntax error in QB64
+        // ("DIM: Expected ,") -- confirmed against a real compiler. Every
+        // reference elsewhere is already the bare (unsuffixed) name (see
+        // emitExpr's "var" case in base.js), so the fix is just dropping
+        // the sigil here too, not adding it anywhere else.
+        const lets = letBindings
+            .map(({ name, valueStr }) => `    Dim ${name} AS DOUBLE : ${name} = ${valueStr}`)
+            .join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `' AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `FUNCTION ${fn.name}# (${params})\n` +
+               letsBlock +
+               `    ${fn.name}# = ${body}\n` +
+               `END FUNCTION\n`;
+    },
+    // Multiple named outputs from one call: QB64 has no struct/tuple return,
+    // so this emits a SUB instead of a FUNCTION, with the outputs as
+    // trailing parameters — SUB params are by reference by default in
+    // QB64/BASIC, so assigning to them writes back to the caller's
+    // variables. This is the classic BASIC multi-output idiom.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const outputNames = Object.keys(outputStrs);
+        checkReservedNames([fn.name, ...fn.params, ...outputNames, ...letBindings.map((b) => b.name)]);
+        const inParams = fn.params.map((p) => `${p} AS DOUBLE`);
+        const outParams = outputNames.map((n) => `${n} AS DOUBLE`);
+        // NOT `Dim name# AS DOUBLE`: combining the # sigil with an AS
+        // DOUBLE clause on the same DIM is a syntax error in QB64
+        // ("DIM: Expected ,") -- confirmed against a real compiler. Every
+        // reference elsewhere is already the bare (unsuffixed) name (see
+        // emitExpr's "var" case in base.js), so the fix is just dropping
+        // the sigil here too, not adding it anywhere else.
+        const lets = letBindings
+            .map(({ name, valueStr }) => `    Dim ${name} AS DOUBLE : ${name} = ${valueStr}`)
+            .join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const assigns = outputNames.map((n) => `    ${n} = ${outputStrs[n]}`).join("\n");
+        return `' AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `SUB ${fn.name} (${[...inParams, ...outParams].join(", ")})\n` +
+               letsBlock +
+               `${assigns}\n` +
+               `END SUB\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/registry.js

@@ -0,0 +1,15 @@
+// exprforge/emitters/registry.js
+// Add a new language: write emitters/<lang>.js exporting an Emitter instance,
+// then add one line here. Nothing else in the project needs to change.
+module.exports = {
+    js: require("./js.js"),
+    ts: require("./typescript.js"),
+    qb64: require("./qb64.js"),
+    c: require("./c.js"),
+    java: require("./java.js"),
+    go: require("./go.js"),
+    rust: require("./rust.js"),
+    csharp: require("./csharp.js"),
+    python: require("./python.js"),
+    lua: require("./lua.js"),
+};