exprforge 0.2.0 → 0.2.1

package/emitters/zig.js

@@ -0,0 +1,126 @@
+// exprforge/emitters/zig.js
+const Emitter = require("./base.js");
+
+// Zig's reserved words plus the small set of extra identifiers this
+// emitter's own output introduces (Result, the struct-suite convention
+// below) -- same role as QB64_RESERVED in emitters/qb64.js. Zig is
+// case-sensitive, unlike QB64/Fortran, so this checks exact names.
+const ZIG_RESERVED = new Set([
+    "addrspace", "align", "allowzero", "and", "anyframe", "anytype", "asm", "async",
+    "await", "break", "callconv", "catch", "comptime", "const", "continue", "defer",
+    "else", "enum", "errdefer", "error", "export", "extern", "fn", "for", "if",
+    "inline", "noalias", "noinline", "nosuspend", "opaque", "or", "orelse", "packed",
+    "pub", "resume", "return", "linksection", "struct", "suspend", "switch", "test",
+    "threadlocal", "try", "union", "unreachable", "usingnamespace", "var", "volatile",
+    "while", "true", "false", "null", "undefined", "void", "type", "anyerror",
+    "std", "result",
+]);
+
+function checkReservedNames(names) {
+    for (const name of names) {
+        if (ZIG_RESERVED.has(name)) {
+            throw new Error(
+                `emitter for .zig: "${name}" is a reserved Zig keyword/identifier and can't be used as a ` +
+                `function/variable/parameter name -- rename it (see ZIG_RESERVED in emitters/zig.js)`,
+            );
+        }
+    }
+}
+
+function mathFn(name) {
+    return (args) => `std.math.${name}(${args.join(", ")})`;
+}
+
+function builtin(name) {
+    return ([x]) => `@${name}(${x})`;
+}
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+const emitter = new Emitter({
+    ext: "zig",
+    // Every literal is forced through @as(f64, ...), not left bare --
+    // confirmed against a real compiler that a bare literal reaching a
+    // comptime-eligible call (e.g. std.math.sqrt(2.0) with no runtime f64
+    // operand anywhere) gets evaluated at Zig's extended comptime_float
+    // precision instead of truncated to an actual IEEE 754 double, giving
+    // a DIFFERENT (more precise, not less) result than every other target
+    // here. @as(f64, ...) forces real double-precision truncation before
+    // any arithmetic happens, regardless of whether the surrounding
+    // expression also involves a runtime variable.
+    formatNumber: (v) => `@as(f64, ${String(v)})`,
+    calls: {
+        // Compiler builtins (map to LLVM intrinsics directly).
+        abs: builtin("abs"), exp: builtin("exp"), log: builtin("log"),
+        log2: builtin("log2"), log10: builtin("log10"),
+        floor: builtin("floor"), ceil: builtin("ceil"), round: builtin("round"), trunc: builtin("trunc"),
+        min: builtin2("min"), max: builtin2("max"),
+        // std.math functions -- not compiler builtins, but ordinary Zig
+        // stdlib functions with the expected 1/2-arg float signatures.
+        sqrt: mathFn("sqrt"), sin: mathFn("sin"), cos: mathFn("cos"), tan: mathFn("tan"),
+        asin: mathFn("asin"), acos: mathFn("acos"), atan: mathFn("atan"), atan2: mathFn("atan2"),
+        hypot: mathFn("hypot"),
+        // pow needs an explicit type argument (std.math.pow(T, x, y)) --
+        // unlike every other std.math function here, it's not purely
+        // inferred from its float arguments.
+        pow: ([x, y]) => `std.math.pow(f64, ${x}, ${y})`,
+        // std.math.sign is genuinely zero-aware (confirmed: sign(0.0) ==
+        // 0.0) -- unlike most other targets here, this doesn't need to be
+        // hand-built to get the zero case right (see Go's/Rust's sign()
+        // history in this project for what happens when a language's
+        // native sign function isn't).
+        sign: mathFn("sign"),
+    },
+    // Zig has no ?: ternary, but if/else as an EXPRESSION (not just a
+    // statement) works exactly like this project's select() -- including
+    // evaluating both branches, since there's no separate "lazy" form.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `(if ((${L}) ${condNode.op} (${R})) ${thenStr} else ${elseStr})`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        checkReservedNames([fn.name, ...fn.params, ...letBindings.map((b) => b.name)]);
+        const params = fn.params.map((p) => `${p}: f64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name}: f64 = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `const std = @import("std");\n\n` +
+               `pub fn ${fn.name}(${params}) f64 {\n` +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: a small struct type (same idea
+    // as C's typedef struct, Rust's struct) returned by value -- Zig has
+    // no native tuple-with-names or multi-return.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const outputNames = Object.keys(outputStrs);
+        checkReservedNames([fn.name, ...fn.params, ...outputNames, ...letBindings.map((b) => b.name)]);
+        const resultName = `${capitalize(fn.name)}Result`;
+        const params = fn.params.map((p) => `${p}: f64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name}: f64 = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const structFields = outputNames.map((n) => `    ${n}: f64,`).join("\n");
+        const initFields = outputNames.map((n) => `        .${n} = ${outputStrs[n]},`).join("\n");
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `const std = @import("std");\n\n` +
+               `pub const ${resultName} = struct {\n${structFields}\n};\n\n` +
+               `pub fn ${fn.name}(${params}) ${resultName} {\n` +
+               letsBlock +
+               `    return ${resultName}{\n${initFields}\n    };\n` +
+               `}\n`;
+    },
+});
+
+// builtin2 is used by the calls table above but defined after it's
+// referenced (function declarations hoist) -- kept next to builtin/mathFn
+// rather than above them so the two "2-arg compiler builtin" and "1-arg
+// compiler builtin" helpers read as a pair.
+function builtin2(name) {
+    return ([a, b]) => `@${name}(${a}, ${b})`;
+}
+
+module.exports = emitter;

package/math/index.js

@@ -67,6 +67,14 @@ function cross3(ax, ay, az, bx, by, bz) {
 // with another normalize3() binding inside the same function body, and a
 // process-wide counter trivially guarantees that regardless of how many
 // times normalize3 is called across however many functions.
+//
+// The name itself starts with a letter, not "__" -- confirmed against a
+// real Fortran compiler ("Invalid character in name") that a leading
+// underscore isn't a valid identifier start there, unlike JS/Python/etc.
+// This is an internal implementation detail (never part of any documented
+// return value or public name), so there's nothing for a leading-"__"
+// convention to usefully signal here that a portable identifier can't
+// signal just as well.
 let normalizeGensymCounter = 0;
 
 // Safe-normalize a 3-D vector. Returns { x, y, z } (same shape as cross3).
@@ -85,7 +93,7 @@ let normalizeGensymCounter = 0;
 // name avoids a "duplicate let binding name" throw if normalize3 is called
 // more than once inside one function (e.g. normalizing two vectors).
 function normalize3(x, y, z, fx = num(0), fy = num(1), fz = num(0)) {
-    const lenName = `__exprforgeMathNrmLen${normalizeGensymCounter++}`;
+    const lenName = `efMathNrmLen${normalizeGensymCounter++}`;
     return {
         x: letIn(lenName, len3(x, y, z), safeDiv(x, v(lenName), fx)),
         y: safeDiv(y, v(lenName), fy),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exprforge",
-  "version": "0.2.0",
-  "description": "Author a math expression once as an AST, emit identical-behavior implementations in JS, TypeScript, Python, C#, Lua, QB64, C, Java, Go, and Rust.",
+  "version": "0.2.1",
+  "description": "Author a math expression once as an AST, emit identical-behavior implementations in JS, TypeScript, Python, C#, Lua, QB64, C, Java, Go, Rust, Perl, PHP, Julia, Fortran, Zig, Scheme, and COBOL.",
   "main": "index.js",
   "type": "commonjs",
   "exports": {

package/samples/math-demo.js

@@ -10,17 +10,21 @@
 const { v, num, outputs } = require("../ast.js");
 const { safeDiv, dot3, len3, cross3, normalize3, clamp } = require("../math/index.js");
 
-const MATH_DEMO_PARAMS = ["ax", "ay", "az", "bx", "by", "bz", "t", "lo", "hi"];
+// "byy", not "by": BY is a reserved COBOL keyword (BY REFERENCE/BY VALUE/
+// BY CONTENT) -- confirmed against a real compiler ("syntax error,
+// unexpected BY") that it can't be used as a data-item name there, same
+// kind of unavoidable per-language collision as "len"/"mag" below.
+const MATH_DEMO_PARAMS = ["ax", "ay", "az", "bx", "byy", "bz", "t", "lo", "hi"];
 
-const cross = cross3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz"));
+const cross = cross3(v("ax"), v("ay"), v("az"), v("bx"), v("byy"), v("bz"));
 const normA = normalize3(v("ax"), v("ay"), v("az"));
-const normB = normalize3(v("bx"), v("by"), v("bz"));
+const normB = normalize3(v("bx"), v("byy"), v("bz"));
 
 const MathDemo = {
     name: "MathDemo",
     params: MATH_DEMO_PARAMS,
     body: outputs({
-        dot: dot3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz")),
+        dot: dot3(v("ax"), v("ay"), v("az"), v("bx"), v("byy"), v("bz")),
         // "mag", not "len": LEN is a reserved QB64 builtin (string/array
         // length) -- see test/conformance.test.js's normalizeXAst comment.
         mag: len3(v("ax"), v("ay"), v("az")),