exprforge 0.2.0 → 0.2.1

package/README.md

@@ -10,10 +10,18 @@
 [![Java](https://github.com/theraccoonbear/exprforge/actions/workflows/test-java.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-java.yml)
 [![Go](https://github.com/theraccoonbear/exprforge/actions/workflows/test-go.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-go.yml)
 [![Rust](https://github.com/theraccoonbear/exprforge/actions/workflows/test-rust.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-rust.yml)
+[![Perl](https://github.com/theraccoonbear/exprforge/actions/workflows/test-perl.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-perl.yml)
+[![PHP](https://github.com/theraccoonbear/exprforge/actions/workflows/test-php.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-php.yml)
+[![Julia](https://github.com/theraccoonbear/exprforge/actions/workflows/test-julia.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-julia.yml)
+[![Fortran](https://github.com/theraccoonbear/exprforge/actions/workflows/test-fortran.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-fortran.yml)
+[![Zig](https://github.com/theraccoonbear/exprforge/actions/workflows/test-zig.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-zig.yml)
+[![Scheme](https://github.com/theraccoonbear/exprforge/actions/workflows/test-scheme.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-scheme.yml)
+[![COBOL](https://github.com/theraccoonbear/exprforge/actions/workflows/test-cobol.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-cobol.yml)
 
 Author a math expression once, as a small AST, and emit verified,
 identical-behavior implementations in JavaScript, TypeScript, Python, C#,
-Lua, QB64, C, Java, Go, and Rust.
+Lua, QB64, C, Java, Go, Rust, Perl, PHP, Julia, Fortran, Zig, Scheme
+(Guile), and COBOL (GnuCOBOL).
 
 No parser, no dependencies. You build the AST directly with plain JS
 functions; the same tree is walked once per target language.
@@ -27,6 +35,23 @@ mainstream languages. This exists for two things SymPy doesn't do:
 - A conformance test harness that actually proves the emitted targets
   agree numerically, not just that they compile.
 
+Two shapes of real use this tends to fall into:
+
+- **Keeping concurrent codebases in sync.** A client/server split (game
+  client prediction + authoritative server, or any two independently
+  deployed services) where both sides need to compute the *same* formula
+  and disagree — desync, or a cheat signal — the moment they drift. One
+  AST, not two hand-maintained implementations that quietly diverge.
+- **De-risking a migration.** Replacing an older implementation (a COBOL
+  batch job, a Fortran numerical kernel) with a new one doesn't require
+  trusting a manual port — emit the same formula into both the legacy
+  target and the new one, and let the conformance suite prove they agree
+  before cutover, not after.
+
+Neither is "translate my code for me" — it's "prove two independent
+implementations of one formula actually match," which is a narrower,
+checkable claim.
+
 ## Install
 
 ```
@@ -130,6 +155,29 @@ Write `emitters/<lang>.js` exporting an `Emitter` instance (see any
 existing file as a template), then add one line to
 `emitters/registry.js`. Nothing else changes — proven by the TypeScript
 emitter, added with no changes to `base.js`, `build.js`, or `index.js`.
+`Emitter` is a real class (not just a factory function), so a target that
+needs to intercept how expressions themselves get rendered — not just
+`calls`/`emitSelect`/`formatFunction`, all ordinary config — can subclass
+it instead: Perl/PHP override `emitExpr`'s `"var"` case to add the `$`
+sigil every reference needs, Scheme overrides the `"bin"` case for prefix
+notation. See `emitters/scheme.js` and `emitters/perl.js`.
+
+### Reserved-word collisions
+
+Several emitters (QB64, Fortran, Zig, Scheme, COBOL) guard against a
+generated variable/parameter/function name colliding with that language's
+own reserved words or builtins — a `<LANG>_RESERVED` set checked at
+emission time, throwing a clear error instead of producing code that fails
+to compile somewhere downstream with no context (see e.g. `QB64_RESERVED`
+in `emitters/qb64.js`). **These lists are not, and can't practically be,
+exhaustive** — each covers the collisions that came up in this project's
+own samples plus the obvious/common ones for that language, not every
+reserved word in every language's full grammar. If you're naming your own
+functions/params/`letIn` bindings, especially ones you know will target a
+specific language, it's still on you to know that language's reserved
+words — Perl/PHP mostly sidestep this (every variable is `$`-sigiled, so
+it can't collide with a bareword keyword), but the sigil-free languages
+above genuinely can't be fully guarded against in advance.
 
 ## Named subexpressions and conditional values
 
@@ -214,11 +262,14 @@ multi-value idiom it has, since none of them agree:
 | Target | Shape |
 |---|---|
 | JS | object literal |
-| Go, Lua | native multiple return values |
-| C# | a native named value tuple (`(double rx, double ry)`) |
-| C / Rust | a small `...Result` struct, returned by value |
+| Go, Lua, Scheme | native multiple return values (`(values ...)` in Scheme) |
+| C#, Julia | a native named value tuple / named tuple |
+| C / Rust / Zig | a small `...Result` struct, returned by value |
 | Java, Python | a nested/local `Result` class |
-| QB64 | a `SUB` with the outputs as trailing by-reference parameters |
+| QB64, Fortran | a `SUB`/`subroutine` with the outputs as trailing by-reference (`intent(out)`) parameters |
+| Perl | a hash ref (`{ rx => ..., ry => ... }`) |
+| PHP | an associative array (`['rx' => ..., 'ry' => ...]`) |
+| COBOL | a callable `PROGRAM-ID`, every output as a trailing `BY REFERENCE` parameter, invoked via `CALL "name" USING ...` — COBOL's *scalar* case uses this same shape too, not a `FUNCTION`-style return (see Testing below) |
 
 Go specifically does **not** use *named* return values (`(rx, ry float64)`)
 even though Go supports them and it reads nicer: those are sugar for
@@ -254,20 +305,21 @@ Runs `node --test`. For each sample, that's two kinds of check:
 
 The compiled/interpreted-language checks need their toolchain on `PATH`
 and skip (not fail) when it's missing, so `npm test` degrades gracefully
-on any one machine. Every one of `tsc`/`qb64pe`/`dotnet`/`python3`/`lua`
-is treated exactly like gcc/go/rustc/javac: looked up on `PATH`, never a
-project dependency — exprforge only ever generates source text for these,
-it doesn't execute or type-check any of it itself. `package.json` has
-zero dependencies of any kind, matching this.
+on any one machine. Every one of `tsc`/`qb64pe`/`dotnet`/`python3`/`lua`/
+`perl`/`php`/`julia`/`gfortran`/`zig`/`guile3.0`/`cobc` is treated exactly
+like gcc/go/rustc/javac: looked up on `PATH`, never a project
+dependency — exprforge only ever generates source text for these, it
+doesn't execute or type-check any of it itself. `package.json` has zero
+dependencies of any kind, matching this.
 
 CI is one workflow file per target language (`.github/workflows/test-*.yml`),
 run in parallel — they have nothing to do with each other, so there's no
-reason to serialize installing nine different toolchains (QB64-PE alone,
-built from source and cached by version, takes several minutes) into one
-job, and splitting by file rather than by job within one file is also
-what gets each language its own real status badge above, not just one
-combined "did everything pass" badge. Each workflow installs only its own
-toolchain and runs `EXPRFORGE_TEST_TARGETS=<Label> npm test`; that
+reason to serialize installing sixteen different toolchains (QB64-PE
+alone, built from source and cached by version, takes several minutes)
+into one job, and splitting by file rather than by job within one file is
+also what gets each language its own real status badge above, not just
+one combined "did everything pass" badge. Each workflow installs only its
+own toolchain and runs `EXPRFORGE_TEST_TARGETS=<Label> npm test`; that
 environment variable (read once in `test/conformance.test.js`) filters
 the target lists down to just that one language, plus the toolchain-
 independent JS/reference checks, which every workflow repeats — cheap,
@@ -304,6 +356,66 @@ compiling/running against a real toolchain rather than assumed to work:
   `math.atan2` (use two-argument `math.atan(y, x)`); there's no
   `math.round` or `math.trunc` or `math.sign` at any version (manual
   `floor(x+0.5)`, `math.modf(x)`, and an `and`/`or` chain respectively).
+- **Perl / PHP**: every variable reference needs a `$` sigil, which
+  `base.js`'s shared `emitExpr` doesn't produce for anything — both
+  subclass `Emitter` to override just the `"var"` case (see "Adding a
+  language" above) rather than needing a new hook every other emitter
+  would have to ignore. Perl has no `log2()`/`trunc()`/`hypot()` in core
+  (POSIX supplies `trunc`/`hypot`, `log2` is derived); PHP has no
+  `trunc()` at all (`floor`/`ceil` picked by sign instead, not an `(int)`
+  cast, which would misbehave outside PHP's platform integer range).
+- **Julia**: `round()` defaults to ties-to-even (banker's rounding), not
+  ties-away-from-zero like every other target here —
+  `round(x, RoundNearestTiesAway)` used explicitly to actually match,
+  not just avoid the untested case. `sign(-0.0)` returns `-0.0`, which is
+  numerically equal to `0.0` for the tolerance-based comparisons this
+  project uses, so it isn't a real divergence.
+- **Fortran**: a literal without the `D0` exponent marker is parsed as
+  *single*-precision first, then widened — silently losing precision
+  before it reaches a `real(8)` variable, unlike every other target's
+  literals — so every literal gets it, not just ones already in
+  scientific notation. `FLOOR`/`CEILING` return the default `INTEGER`
+  kind, not `REAL`, wrapped back with `REAL(..., 8)`. No ternary, but
+  `MERGE(then, else, mask)` is a genuine expression-level conditional —
+  confirmed to evaluate both branches regardless of `mask`, matching
+  `select()`'s own contract exactly. The native 2-argument `SIGN(A, B)`
+  ("magnitude of A, sign of B") is *not* this project's `sign(x)` —
+  `SIGN(1.0, 0.0)` returns `1.0`, not `0.0` — built from `MERGE` instead.
+- **Zig**: `std.debug.print` writes to **stderr** by design, not
+  stdout — the conformance harness has to use
+  `std.io.getStdOut().writer()` instead, or every result silently comes
+  back empty. A fully-literal expression with no runtime operand (e.g.
+  `sqrt(2.0)` alone) gets evaluated at Zig's extended `comptime_float`
+  precision instead of truncated to an actual IEEE double, unless
+  explicitly `@as(f64, ...)`-cast — every literal gets that cast, not
+  just ones that would otherwise hit this.
+- **Scheme (Guile)**: a bare integer literal like `2` is *exact* in
+  Scheme's reader syntax, and exact arithmetic that never touches an
+  inexact (float) operand stays exact — `(/ 1 3)` prints as the fraction
+  `1/3`, not `0.333...`. Every literal gets `.0` appended unless it
+  already has a decimal point or exponent, forcing inexactness by literal
+  syntax alone rather than relying on some other operand in the same
+  expression happening to already be a float.
+- **COBOL (GnuCOBOL)**: has no expression-level conditional at all — no
+  ternary, no `MERGE`-equivalent. `select()` is built from six small
+  helper `FUNCTION-ID` modules (one per comparator), but confirmed
+  against a real compile+run that a user-defined `FUNCTION` call
+  *silently miscomputes* — no error, just a wrong number — when given a
+  complex argument (one containing its own nested call); every argument
+  to a helper gets spilled into its own `COMPUTE`d temp first, always,
+  not just when an argument "looks complex." `BY VALUE` parameter passing
+  is explicitly flagged "unfinished" by the compiler — every function
+  uses `BY REFERENCE` (the default) instead, which is also why COBOL is
+  the one target where even a *scalar* function's return value is a
+  trailing by-reference parameter (see the outputs table above), not a
+  `FUNCTION`-style return: calling a user `FUNCTION` by name breaks if
+  that name contains an underscore (confirmed against a real compiler),
+  while `CALL "name"` takes it as a plain string literal, immune to that.
+  Source lines have a real ~512-byte cap — long expressions (e.g.
+  `samples/kitchen-sink.js`'s summed call to all 22 functions) get
+  wrapped at word boundaries. The native `FUNCTION SIGN` is
+  1-argument (`SIGN(x)`), unlike Fortran's identically-named
+  2-argument intrinsic — and unlike Fortran's, is genuinely zero-safe.
 
 One test (`normalizeX`) is deliberately excluded from the QB64 check
 only: it exists specifically to demonstrate the "don't guard division

package/emitters/cobol.js

@@ -0,0 +1,410 @@
+// exprforge/emitters/cobol.js
+//
+// Targets GnuCOBOL (free-format source, USAGE COMP-2 for double precision)
+// -- see test/conformance.test.js for the exact `cobc` invocation this is
+// verified against.
+//
+// select()/cmp() needed a genuinely different emission strategy than every
+// other target here, because of one real, confirmed-by-compiling
+// structural limit: GnuCOBOL has no expression-level conditional at all --
+// no ternary, no Fortran-style MERGE(). A user-defined `FUNCTION-ID`
+// module CAN be called from inside an expression (`FUNCTION name(...)`),
+// which looks like a way to build one (a tiny "pick a branch" helper
+// function) -- but confirmed against a real compile+run that GnuCOBOL 3.2
+// silently miscomputes (no error, just a wrong/garbage numeric result)
+// when such a call receives a COMPLEX argument, i.e. one containing its
+// own nested FUNCTION call, rather than a bare variable or literal. Every
+// real select() usage has exactly that shape (see
+// samples/spline-frame.js, math/index.js's safeDiv/clamp/normalize3).
+//
+// The fix: six small helper FUNCTION-ID modules (one per comparator, EF_CMP
+// below), always prepended to the emitted source, PLUS forcing every
+// argument passed to them through its own COMPUTE into a fresh temp
+// variable first -- confirmed safe, since a bare-variable-argument call to
+// a user-defined FUNCTION-ID was the one case that worked correctly in
+// testing. That turns emitSelect from a pure "node -> expression string"
+// function (every other emitter's shape, including this file's own calls
+// table) into a STATEFUL one that also spills COMPUTE statements -- see
+// the CobolEmitter class below, which is the one thing in this file that
+// isn't just config passed to `new Emitter(...)` like every other target.
+//
+// No FUNCTION ATAN2 exists in GnuCOBOL either (FUNCTION ATAN is
+// 1-argument only), and the standard quadrant-corrected formula needs
+// exactly this same branching -- built from the same select-hoisting
+// machinery as select() itself, not a separate mechanism.
+const Emitter = require("./base.js");
+
+// COBOL reserved words plus every intrinsic-function name this emitter's
+// calls table depends on -- same role as QB64_RESERVED in emitters/qb64.js.
+// COBOL is case-insensitive, so names are checked lowercased. Not
+// exhaustive (COBOL's real reserved-word list runs into the hundreds), but
+// covers the words a generated variable/parameter/function name could
+// plausibly collide with in practice.
+const COBOL_RESERVED = new Set([
+    "identification", "division", "program-id", "function-id", "environment",
+    "configuration", "repository", "data", "working-storage", "linkage", "section",
+    "procedure", "using", "returning", "intent", "usage", "comp-2", "value", "by",
+    "reference", "content", "if", "else", "end-if", "compute", "move", "to", "call",
+    "goback", "stop", "run", "display", "perform", "until", "end-perform", "and",
+    "or", "not", "true", "false", "zero", "zeros", "zeroes", "spaces", "high-value",
+    "low-value", "function", "sqrt", "abs", "sin", "cos", "tan", "asin", "acos",
+    "atan", "exp", "log", "log10", "integer", "integer-part", "sign", "min", "max", "mod",
+]);
+
+function checkReservedNames(names) {
+    for (const name of names) {
+        if (COBOL_RESERVED.has(name.toLowerCase())) {
+            throw new Error(
+                `emitter for .cob: "${name}" is a reserved COBOL word/intrinsic and can't be used as a ` +
+                `function/variable/parameter name -- rename it (see COBOL_RESERVED in emitters/cobol.js)`,
+            );
+        }
+    }
+}
+
+function fn1(name) {
+    return ([x]) => `FUNCTION ${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `FUNCTION ${name}(${a}, ${b})`;
+}
+
+// One helper FUNCTION-ID per comparator, each named ef-cmp-<suffix> --
+// hyphenated, never underscored (confirmed against a real compiler that a
+// user-defined FUNCTION call breaks on an underscored name -- see
+// samples/spline-frame.js's "wy_wire" param for why that's not just a
+// theoretical concern). "ne" uses NOT = rather than the symbolic <>,
+// simply because NOT = is unambiguously standard COBOL and <> wasn't worth
+// separately confirming for a helper this narrow.
+const CMP_HELPERS = {
+    ">": { suffix: "gt", test: "L > R" },
+    "<": { suffix: "lt", test: "L < R" },
+    ">=": { suffix: "ge", test: "L >= R" },
+    "<=": { suffix: "le", test: "L <= R" },
+    "==": { suffix: "eq", test: "L = R" },
+    "!=": { suffix: "ne", test: "L NOT = R" },
+};
+
+// The REPOSITORY paragraph every caller of an ef-cmp-* helper needs --
+// shared between formatFunction/formatSuite below, and terminated with a
+// period only after the LAST entry (REPOSITORY is one sentence, not one
+// statement per line -- confirmed against a real compiler that a missing
+// trailing period here breaks the DATA DIVISION that follows).
+const CMP_REPOSITORY =
+    `       REPOSITORY.\n` +
+    Object.values(CMP_HELPERS)
+        .map(({ suffix }, i, arr) => `           FUNCTION ef-cmp-${suffix}${i === arr.length - 1 ? "." : ""}`)
+        .join("\n") +
+    "\n";
+
+const CMP_HELPER_SOURCE = Object.values(CMP_HELPERS)
+    .map(
+        ({ suffix, test }) => `       IDENTIFICATION DIVISION.
+       FUNCTION-ID. ef-cmp-${suffix}.
+       DATA DIVISION.
+       LINKAGE SECTION.
+       01 L USAGE COMP-2.
+       01 R USAGE COMP-2.
+       01 THEN-VAL USAGE COMP-2.
+       01 ELSE-VAL USAGE COMP-2.
+       01 RESULT USAGE COMP-2.
+       PROCEDURE DIVISION USING L R THEN-VAL ELSE-VAL RETURNING RESULT.
+           IF ${test}
+               MOVE THEN-VAL TO RESULT
+           ELSE
+               MOVE ELSE-VAL TO RESULT
+           END-IF
+           GOBACK.
+       END FUNCTION ef-cmp-${suffix}.
+`,
+    )
+    .join("\n");
+
+// GnuCOBOL caps physical source line length (confirmed against a real
+// compiler: "source text exceeds 512 bytes, will be truncated", on
+// samples/kitchen-sink.js's single expression summing all 22 Math
+// functions -- the one AST big enough to ever hit this). Free-format
+// COBOL allows a statement to simply continue on the next line with no
+// continuation marker (confirmed against a real compiler), so a long line
+// just gets broken at word boundaries, well under the real limit.
+function wrapLine(line, maxWidth = 100) {
+    if (line.length <= maxWidth) return line;
+    const words = line.split(" ");
+    const wrapped = [];
+    let current = "";
+    for (const word of words) {
+        if (current && current.length + 1 + word.length > maxWidth) {
+            wrapped.push(current);
+            current = `               ${word}`;
+        } else {
+            current = current ? `${current} ${word}` : word;
+        }
+    }
+    if (current) wrapped.push(current);
+    return wrapped.join("\n");
+}
+
+// A small stateful pool that emitSelect below uses to hoist arguments into
+// fresh temp variables before ever calling an ef-cmp-* helper -- see the
+// file header for why that's required, not optional. Reset once per
+// top-level emitExpr call (one per let-binding, one per output field, one
+// for a select-free body) so temp declarations only need to cover what
+// that one statement actually produced -- but the NAME counter itself is
+// shared (passed in, not owned) across every pool created in one
+// emitFunction call. Confirmed the hard way: an earlier version gave each
+// pool its own counter starting at 0, so two different let-bindings could
+// each mint an "ef-tmp-0", and GnuCOBOL correctly rejected the resulting
+// duplicate WORKING-STORAGE declaration as "ambiguous; needs
+// qualification".
+class TempPool {
+    constructor(counter) {
+        this.counter = counter;
+        this.lines = [];
+        this.decls = [];
+    }
+
+    // Spills `valueStr` into a freshly named temp, recording both the
+    // COMPUTE that sets it and the 01-level declaration it'll need, and
+    // returns the bare name -- always safe to pass to a user-defined
+    // FUNCTION-ID call, unlike valueStr itself.
+    spill(valueStr) {
+        const name = `ef-tmp-${this.counter.next++}`;
+        this.decls.push(name);
+        this.lines.push(wrapLine(`           COMPUTE ${name} = ${valueStr}`));
+        return name;
+    }
+}
+
+class CobolEmitter extends Emitter {
+    emitFunction(fn) {
+        const { collectLets } = require("../ast.js");
+        const { bindings, body } = collectLets(fn.body);
+        const counter = { next: 0 };
+
+        const letLines = [];
+        const letDecls = [];
+        for (const { name, node } of bindings) {
+            checkReservedNames([name]);
+            this._pool = new TempPool(counter);
+            const valueStr = this.emitExpr(node);
+            letLines.push(...this._pool.lines);
+            letDecls.push(...this._pool.decls, name);
+            letLines.push(wrapLine(`           COMPUTE ${name} = ${valueStr}`));
+        }
+
+        if (body.type === "outputs") {
+            if (!this.formatSuiteImpl) {
+                throw new Error(`emitter for .${this.ext}: no formatSuite configured -- multi-output suites aren't supported for this target yet`);
+            }
+            const outputStrs = {};
+            const outputLines = [];
+            for (const [name, node] of Object.entries(body.fields)) {
+                this._pool = new TempPool(counter);
+                outputStrs[name] = this.emitExpr(node);
+                outputLines.push(...this._pool.lines);
+                letDecls.push(...this._pool.decls);
+            }
+            return this.formatSuiteImpl(fn, outputStrs, letLines, letDecls, outputLines);
+        }
+
+        this._pool = new TempPool(counter);
+        const bodyStr = this.emitExpr(body);
+        const bodyLines = this._pool.lines;
+        letDecls.push(...this._pool.decls);
+        return this.formatFunctionImpl(fn, bodyStr, letLines, letDecls, bodyLines);
+    }
+}
+
+// JS renders very small/large magnitudes in exponential notation
+// (String(1e-9) === "1e-9"), and COBOL numeric literals don't accept that
+// syntax at all -- confirmed against a real compiler ("'1e-9' is not
+// defined"). Expanded to plain decimal digit-by-digit instead of via
+// toFixed(): toFixed(20) reveals a binary float's true (imprecise) decimal
+// expansion for values like 4.2 ("4.20000000000000017764"), where this
+// instead shifts the SAME shortest-round-trip digits String(v) already
+// picked, so e.g. 1e-9 becomes exactly "0.000000001", nothing more.
+function expandExponential(s) {
+    const m = s.match(/^(-?)(\d+)(?:\.(\d+))?e([+-]?\d+)$/i);
+    if (!m) return s;
+    const [, sign, intPart, fracPart = "", expStr] = m;
+    const digits = intPart + fracPart;
+    const pointPos = intPart.length + Number(expStr);
+    let result;
+    if (pointPos <= 0) {
+        result = `0.${"0".repeat(-pointPos)}${digits}`;
+    } else if (pointPos >= digits.length) {
+        result = `${digits}${"0".repeat(pointPos - digits.length)}`;
+    } else {
+        result = `${digits.slice(0, pointPos)}.${digits.slice(pointPos)}`;
+    }
+    return sign + result;
+}
+
+const emitter = new CobolEmitter({
+    ext: "cob",
+    formatNumber: (v) => {
+        const s = String(v);
+        return /e/i.test(s) ? expandExponential(s) : s;
+    },
+    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"), log: fn1("LOG"), log10: fn1("LOG10"),
+        min: fn2("MIN"), max: fn2("MAX"),
+        pow: ([x, y]) => `(${x} ** ${y})`,
+        // No LOG2 intrinsic -- derive it (nesting two intrinsics is fine;
+        // only nesting a call inside a USER-DEFINED function's argument
+        // was the confirmed problem -- see the file header).
+        log2: ([x]) => `(FUNCTION LOG(${x}) / FUNCTION LOG(2.0))`,
+        // No HYPOT intrinsic -- derive it the same way.
+        hypot: ([a, b]) => `FUNCTION SQRT((${a}) ** 2 + (${b}) ** 2)`,
+        // FUNCTION INTEGER is floor (greatest integer <= x, confirmed
+        // against a real compiler, including for negatives). COMPUTE's
+        // automatic numeric conversion hands it back as COMP-2 with no
+        // explicit cast needed, unlike Fortran's REAL(..., 8) wrap.
+        floor: fn1("INTEGER"),
+        // No CEILING intrinsic -- negate, floor, negate back. Confirmed:
+        // ceil(2.2)=3, ceil(-2.2)=-2.
+        ceil: ([x]) => `(0 - FUNCTION INTEGER(0 - (${x})))`,
+        // FUNCTION INTEGER-PART truncates toward zero directly -- confirmed
+        // against a real compiler (2.7->2, -2.7->-2), no derivation needed.
+        trunc: fn1("INTEGER-PART"),
+        // No ROUND-as-an-expression intrinsic (COBOL's ROUNDED is a
+        // COMPUTE/ADD statement modifier, not composable inline). Built
+        // from FUNCTION SIGN and FUNCTION INTEGER instead -- both purely
+        // intrinsic, so unlike select() this doesn't need the hoisting
+        // machinery at all. GnuCOBOL's FUNCTION SIGN is 1-argument
+        // (SIGN(x) -> -1/0/1), NOT Fortran's 2-argument SIGN(A,B)
+        // "magnitude of A, sign of B" -- confirmed the hard way (a first
+        // version of this formula copied Fortran's 2-arg convention here
+        // by mistake and got "FUNCTION 'SIGN' has wrong number of
+        // arguments" from a real compiler). Also unlike Fortran's SIGN,
+        // confirmed zero-safe (SIGN(0.0) == 0.0 for real, not just by
+        // accident of a multiplied-away wrong case), so this needs no
+        // separate correction the way Fortran's round() does. Rounds ties
+        // away from zero, matching every other target here.
+        round: ([x]) => `(FUNCTION SIGN(${x}) * FUNCTION INTEGER(FUNCTION ABS(${x}) + 0.5))`,
+        // Confirmed zero-safe against a real compiler (SIGN(0.0) == 0.0,
+        // unlike Fortran's identically-named but 2-argument intrinsic --
+        // see round() above) -- no hoisting/spilling machinery needed,
+        // unlike every other emitter here that has to hand-build this.
+        sign: fn1("SIGN"),
+        // No FUNCTION ATAN2 -- the standard quadrant-corrected formula,
+        // built from ef-cmp-* the same way select() itself composes them
+        // (see emitSelect below). EVERY argument to EVERY ef-cmp-* call
+        // must be a bare, already-spilled name -- including ones built
+        // from ANOTHER ef-cmp-* call's result -- since a nested
+        // `FUNCTION ef-cmp-x(...)` used directly as an argument to another
+        // `FUNCTION ef-cmp-y(...)` hits the exact same confirmed bug as a
+        // nested intrinsic call would (see the file header); the first
+        // version of this formula got that wrong (nested an ef-cmp-lt
+        // call straight into ef-cmp-gt's argument list) and silently
+        // computed garbage, caught only by actually compiling and running
+        // it. So: absolutely nothing here is inlined -- every intermediate
+        // result, including literals, gets its own spill() first.
+        //
+        // Arrow function, not a plain one: base.js's emitExpr calls
+        // `this.calls[node.name](args)` unbound (unlike emitSelectImpl,
+        // which the Emitter constructor explicitly .bind(this)s) -- an
+        // arrow here closes over the `emitter` const below by reference
+        // instead, which is fully assigned by the time this ever actually
+        // runs (during some later emitFunction call), even though it's
+        // referenced before that `const` is declared in this same object
+        // literal.
+        atan2: (args) => {
+            const [yRaw, xRaw] = args;
+            const pool = emitter._pool;
+            const y = pool.spill(yRaw);
+            const x = pool.spill(xRaw);
+            const atanYX = pool.spill(`FUNCTION ATAN(${y} / ${x})`);
+            const zero = pool.spill("0.0");
+            const piOver2 = pool.spill("1.5707963267948966");
+            const negPiOver2 = pool.spill("-1.5707963267948966");
+            const atanPlusPi = pool.spill(`(${atanYX} + 3.141592653589793)`);
+            const atanMinusPi = pool.spill(`(${atanYX} - 3.141592653589793)`);
+            // x == 0 case: sign of y (0 conventionally maps to 0.0, same
+            // convention JS's/Python's atan2(0,0) use).
+            const yNegSubcase = pool.spill(`FUNCTION ef-cmp-lt(${y}, ${zero}, ${negPiOver2}, ${zero})`);
+            const xZeroCase = pool.spill(`FUNCTION ef-cmp-gt(${y}, ${zero}, ${piOver2}, ${yNegSubcase})`);
+            // x < 0 case: quadrant-corrected by the sign of y.
+            const xNegCase = pool.spill(`FUNCTION ef-cmp-ge(${y}, ${zero}, ${atanPlusPi}, ${atanMinusPi})`);
+            const xNegOrZeroCase = pool.spill(`FUNCTION ef-cmp-lt(${x}, ${zero}, ${xNegCase}, ${xZeroCase})`);
+            return `FUNCTION ef-cmp-gt(${x}, ${zero}, ${atanYX}, ${xNegOrZeroCase})`;
+        },
+    },
+    // See the file header and TempPool above for why this spills into
+    // temps instead of nesting inline: a user-defined FUNCTION-ID call
+    // (ef-cmp-*) confirmed miscomputes when given a complex argument, so
+    // every one of L/R/then/else gets its own COMPUTE into a fresh temp
+    // first, and the picker call itself only ever receives bare names.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const { suffix } = CMP_HELPERS[condNode.op];
+        const L = this._pool.spill(this.emitExpr(condNode.left));
+        const R = this._pool.spill(this.emitExpr(condNode.right));
+        const thenTmp = this._pool.spill(thenStr);
+        const elseTmp = this._pool.spill(elseStr);
+        return `FUNCTION ef-cmp-${suffix}(${L}, ${R}, ${thenTmp}, ${elseTmp})`;
+    },
+    // Both the scalar and suite cases use the SAME convention: a callable
+    // PROGRAM-ID with every output (the single return value, or every
+    // outputs() field) as a trailing BY REFERENCE parameter -- COBOL's
+    // default parameter-passing mode, confirmed reliable (BY VALUE is
+    // explicitly flagged "unfinished" by a real GnuCOBOL compile). This
+    // also sidesteps a second confirmed rough edge: calling a FUNCTION-ID
+    // module by name (`FUNCTION word(...)`) breaks if that name contains
+    // an underscore (confirmed against a real compiler -- see e.g.
+    // samples/spline-frame.js's "wy_wire" param), while CALL "name" takes
+    // the program name as a plain string literal, immune to that.
+    formatFunction: (fn, body, letLines, letDecls, bodyLines) => {
+        checkReservedNames([fn.name, ...fn.params]);
+        const linkageParams = [...fn.params, "ef-result"];
+        const paramDecls = linkageParams.map((p) => `       01 ${p} USAGE COMP-2.`).join("\n");
+        const wsDecls = letDecls.map((n) => `       01 ${n} USAGE COMP-2.`).join("\n");
+        return `       >>SOURCE FORMAT FREE\n` +
+               `      *> AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               CMP_HELPER_SOURCE + "\n" +
+               `       IDENTIFICATION DIVISION.\n` +
+               `       PROGRAM-ID. ${fn.name}.\n` +
+               `       ENVIRONMENT DIVISION.\n` +
+               `       CONFIGURATION SECTION.\n` +
+               CMP_REPOSITORY +
+               `       DATA DIVISION.\n` +
+               (wsDecls ? `       WORKING-STORAGE SECTION.\n${wsDecls}\n` : "") +
+               `       LINKAGE SECTION.\n` +
+               paramDecls + "\n" +
+               `       PROCEDURE DIVISION USING ${linkageParams.join(" ")}.\n` +
+               [...letLines, ...bodyLines].join("\n") + (letLines.length || bodyLines.length ? "\n" : "") +
+               wrapLine(`           COMPUTE ef-result = ${body}`) + "\n" +
+               `           GOBACK.\n` +
+               `       END PROGRAM ${fn.name}.\n`;
+    },
+    formatSuite: (fn, outputStrs, letLines, letDecls, outputLines) => {
+        const outputNames = Object.keys(outputStrs);
+        checkReservedNames([fn.name, ...fn.params, ...outputNames]);
+        const linkageParams = [...fn.params, ...outputNames];
+        const paramDecls = linkageParams.map((p) => `       01 ${p} USAGE COMP-2.`).join("\n");
+        const wsDecls = letDecls.map((n) => `       01 ${n} USAGE COMP-2.`).join("\n");
+        const assigns = outputNames.map((n) => wrapLine(`           COMPUTE ${n} = ${outputStrs[n]}`)).join("\n");
+        return `       >>SOURCE FORMAT FREE\n` +
+               `      *> AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               CMP_HELPER_SOURCE + "\n" +
+               `       IDENTIFICATION DIVISION.\n` +
+               `       PROGRAM-ID. ${fn.name}.\n` +
+               `       ENVIRONMENT DIVISION.\n` +
+               `       CONFIGURATION SECTION.\n` +
+               CMP_REPOSITORY +
+               `       DATA DIVISION.\n` +
+               (wsDecls ? `       WORKING-STORAGE SECTION.\n${wsDecls}\n` : "") +
+               `       LINKAGE SECTION.\n` +
+               paramDecls + "\n" +
+               `       PROCEDURE DIVISION USING ${linkageParams.join(" ")}.\n` +
+               (letLines.length ? letLines.join("\n") + "\n" : "") +
+               (outputLines.length ? outputLines.join("\n") + "\n" : "") +
+               assigns + "\n" +
+               `           GOBACK.\n` +
+               `       END PROGRAM ${fn.name}.\n`;
+    },
+});
+
+module.exports = emitter;