cppbolt 0.1.1 → 1.0.0

package/dist/host.js

@@ -0,0 +1,408 @@
+"use strict";
+// Formatting helpers for the C printf runtime contract.
+// These reproduce the exact C printf rounding semantics for float/double output.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWasmHost = createWasmHost;
+function roundToEvenExact(vNum, prec) {
+    if (isNaN(vNum))
+        return "nan";
+    if (vNum === Infinity)
+        return "inf";
+    if (vNum === -Infinity)
+        return "-inf";
+    if (Object.is(vNum, -0)) {
+        return "-0" + (prec > 0 ? "." + "0".repeat(prec) : "");
+    }
+    if (vNum === 0) {
+        return "0" + (prec > 0 ? "." + "0".repeat(prec) : "");
+    }
+    const isNeg = vNum < 0;
+    const v = Math.abs(vNum);
+    const buf = new ArrayBuffer(8);
+    const view = new DataView(buf);
+    view.setFloat64(0, v, false);
+    const bits = view.getBigUint64(0, false);
+    const rawExp = Number((bits >> 52n) & 0x7ffn);
+    const rawMantissa = bits & 0xfffffffffffffn;
+    let mantissa;
+    let exp;
+    if (rawExp === 0) {
+        mantissa = rawMantissa;
+        exp = -1022 - 52;
+    }
+    else {
+        mantissa = rawMantissa | (1n << 52n);
+        exp = rawExp - 1023 - 52;
+    }
+    const P = BigInt(prec);
+    const p5 = 5n ** P;
+    const expP = BigInt(exp) + P;
+    let num;
+    let den;
+    if (expP >= 0n) {
+        num = mantissa * 2n ** expP * p5;
+        den = 1n;
+    }
+    else {
+        num = mantissa * p5;
+        den = 2n ** -expP;
+    }
+    const Q = num / den;
+    const R = num % den;
+    const twoR = R * 2n;
+    let rounded;
+    if (twoR < den) {
+        rounded = Q;
+    }
+    else if (twoR > den) {
+        rounded = Q + 1n;
+    }
+    else {
+        rounded = Q % 2n === 0n ? Q : Q + 1n;
+    }
+    let s = rounded.toString();
+    if (prec > 0) {
+        while (s.length <= prec) {
+            s = "0" + s;
+        }
+        const intPart = s.slice(0, s.length - prec);
+        const fracPart = s.slice(s.length - prec);
+        s = intPart + "." + fracPart;
+    }
+    return (isNeg ? "-" : "") + s;
+}
+function formatExpExact(vNum, prec) {
+    if (isNaN(vNum))
+        return "nan";
+    if (vNum === Infinity)
+        return "inf";
+    if (vNum === -Infinity)
+        return "-inf";
+    if (Object.is(vNum, -0)) {
+        const zeros = prec > 0 ? "." + "0".repeat(prec) : "";
+        return "-0" + zeros + "e+00";
+    }
+    if (vNum === 0) {
+        const zeros = prec > 0 ? "." + "0".repeat(prec) : "";
+        return "0" + zeros + "e+00";
+    }
+    const isNeg = vNum < 0;
+    const v = Math.abs(vNum);
+    let exp = Math.floor(Math.log10(v));
+    const buf = new ArrayBuffer(8);
+    const view = new DataView(buf);
+    view.setFloat64(0, v, false);
+    const bits = view.getBigUint64(0, false);
+    const rawExp = Number((bits >> 52n) & 0x7ffn);
+    const rawMantissa = bits & 0xfffffffffffffn;
+    let mantissa;
+    let bexp;
+    if (rawExp === 0) {
+        mantissa = rawMantissa;
+        bexp = -1022 - 52;
+    }
+    else {
+        mantissa = rawMantissa | (1n << 52n);
+        bexp = rawExp - 1023 - 52;
+    }
+    let Q;
+    let R;
+    let den;
+    while (true) {
+        const shift = prec - exp;
+        const S = BigInt(shift);
+        let num;
+        if (S >= 0n) {
+            const p5 = 5n ** S;
+            const expP = BigInt(bexp) + S;
+            if (expP >= 0n) {
+                num = mantissa * 2n ** expP * p5;
+                den = 1n;
+            }
+            else {
+                num = mantissa * p5;
+                den = 2n ** -expP;
+            }
+        }
+        else {
+            const negS = -S;
+            const p5 = 5n ** negS;
+            const expP = BigInt(bexp) - negS;
+            if (expP >= 0n) {
+                num = mantissa * 2n ** expP;
+                den = p5;
+            }
+            else {
+                num = mantissa;
+                den = p5 * 2n ** -expP;
+            }
+        }
+        Q = num / den;
+        R = num % den;
+        if (Q === 0n && v > 0) {
+            exp--;
+            continue;
+        }
+        if (Q >= 10n ** BigInt(prec + 1)) {
+            exp++;
+            continue;
+        }
+        break;
+    }
+    const twoR = R * 2n;
+    let rounded;
+    if (twoR < den) {
+        rounded = Q;
+    }
+    else if (twoR > den) {
+        rounded = Q + 1n;
+    }
+    else {
+        rounded = Q % 2n === 0n ? Q : Q + 1n;
+    }
+    if (rounded >= 10n ** BigInt(prec + 1)) {
+        rounded = rounded / 10n;
+        exp++;
+    }
+    let s = rounded.toString();
+    while (s.length < prec + 1) {
+        s = "0" + s;
+    }
+    const mStr = s[0] + (prec > 0 ? "." + s.slice(1) : "");
+    const expSign = exp >= 0 ? "+" : "-";
+    const expVal = Math.abs(exp).toString().padStart(2, "0");
+    return (isNeg ? "-" : "") + mStr + "e" + expSign + expVal;
+}
+function formatGExact(vNum, prec, alternate = false) {
+    if (isNaN(vNum))
+        return "nan";
+    if (vNum === Infinity)
+        return "inf";
+    if (vNum === -Infinity)
+        return "-inf";
+    if (!prec || prec <= 0)
+        prec = 1;
+    if (Object.is(vNum, -0) || vNum === 0) {
+        if (!alternate)
+            return Object.is(vNum, -0) ? "-0" : "0";
+        const res = roundToEvenExact(vNum, prec - 1);
+        return res.includes(".") ? res : res + ".";
+    }
+    const v = Math.abs(vNum);
+    const exp = Math.floor(Math.log10(v));
+    let res;
+    if (exp < -4 || exp >= prec) {
+        res = formatExpExact(vNum, prec - 1);
+        if (!alternate) {
+            let [m, e] = res.split("e");
+            if (m.includes(".")) {
+                m = m.replace(/0+$/, "").replace(/\.$/, "");
+            }
+            res = m + "e" + e;
+        }
+        else if (Number.isFinite(vNum) && !res.includes(".")) {
+            const e = res.indexOf("e");
+            res = e >= 0 ? res.slice(0, e) + "." + res.slice(e) : res + ".";
+        }
+    }
+    else {
+        const pAfterDot = Math.max(0, prec - 1 - exp);
+        res = roundToEvenExact(vNum, pAfterDot);
+        if (!alternate) {
+            if (res.includes(".")) {
+                res = res.replace(/0+$/, "").replace(/\.$/, "");
+            }
+        }
+        else if (Number.isFinite(vNum) && !res.includes(".")) {
+            res += ".";
+        }
+    }
+    return res;
+}
+/**
+ * Creates the runtime import environment (`env.*`) required by programs
+ * compiled with cppbolt.
+ *
+ * Every module emitted by the compiler imports exactly five functions:
+ * `print_char`, `print_int`, `print_double`, `read_char`, and `exit`.
+ * This function provides all five with correct printf-exact semantics that
+ * match the compiler's runtime contract.
+ */
+function createWasmHost(options = {}) {
+    const { stdin, onStdout, onExit } = options;
+    let stdoutBuffer = "";
+    let inPos = 0;
+    const writeStdout = (str) => {
+        stdoutBuffer += str;
+        if (onStdout) {
+            onStdout(str);
+        }
+    };
+    const imports = {
+        env: {
+            print_char: (ch) => {
+                writeStdout(String.fromCharCode(ch));
+            },
+            print_int: (val, radix, width, precision, flags) => {
+                const isZeroPad = (flags & 1) !== 0;
+                const isLeftAlign = (flags & 2) !== 0;
+                const isShowSign = (flags & 4) !== 0;
+                const isSpaceSign = (flags & 8) !== 0;
+                const isUppercase = (flags & 16) !== 0;
+                const isUnsigned = (flags & 32) !== 0;
+                const isAlternate = (flags & 64) !== 0;
+                let numVal = BigInt(val);
+                let isNeg = false;
+                if (isUnsigned) {
+                    numVal = BigInt.asUintN(64, numVal);
+                }
+                else {
+                    if (numVal < 0n) {
+                        isNeg = true;
+                        numVal = -numVal;
+                    }
+                }
+                let s = numVal.toString(radix);
+                if (isUppercase) {
+                    s = s.toUpperCase();
+                }
+                if (precision >= 0) {
+                    if (precision === 0 && numVal === 0n) {
+                        s = "";
+                    }
+                    else {
+                        while (s.length < precision) {
+                            s = "0" + s;
+                        }
+                    }
+                }
+                let signStr = "";
+                if (isNeg) {
+                    signStr = "-";
+                }
+                else if (!isUnsigned && isShowSign) {
+                    signStr = "+";
+                }
+                else if (!isUnsigned && isSpaceSign) {
+                    signStr = " ";
+                }
+                let prefix = "";
+                if (isAlternate) {
+                    if (radix === 8) {
+                        if (!s.startsWith("0")) {
+                            prefix = "0";
+                        }
+                    }
+                    else if (radix === 16 && numVal !== 0n) {
+                        prefix = isUppercase ? "0X" : "0x";
+                    }
+                }
+                let fullStr;
+                if (precision < 0 && isZeroPad && !isLeftAlign) {
+                    let zeros = "";
+                    while (signStr.length + prefix.length + zeros.length + s.length <
+                        width) {
+                        zeros += "0";
+                    }
+                    fullStr = signStr + prefix + zeros + s;
+                }
+                else {
+                    fullStr = signStr + prefix + s;
+                }
+                if (fullStr.length < width) {
+                    const padLen = width - fullStr.length;
+                    const pad = " ".repeat(padLen);
+                    fullStr = isLeftAlign ? fullStr + pad : pad + fullStr;
+                }
+                writeStdout(fullStr);
+                return fullStr.length;
+            },
+            print_double: (val, width, precision, mode, flags) => {
+                const isAlternate = (flags & 64) !== 0;
+                let s = "";
+                if (mode === 0) {
+                    const prec = precision >= 0 ? precision : 6;
+                    s = formatGExact(val, prec, isAlternate);
+                }
+                else if (mode === 1) {
+                    const p = precision >= 0 ? precision : 6;
+                    s = roundToEvenExact(val, p);
+                    if (isAlternate && Number.isFinite(val) && !s.includes(".")) {
+                        s += ".";
+                    }
+                }
+                else if (mode === 2) {
+                    const p = precision >= 0 ? precision : 6;
+                    s = formatExpExact(val, p);
+                    if (isAlternate && Number.isFinite(val) && !s.includes(".")) {
+                        const e = s.indexOf("e");
+                        s = e >= 0 ? s.slice(0, e) + "." + s.slice(e) : s + ".";
+                    }
+                }
+                else {
+                    throw new Error("unknown float format mode: " + mode);
+                }
+                if ((flags & 16) !== 0) {
+                    s = s.toUpperCase();
+                }
+                const isZeroPad = (flags & 1) !== 0;
+                const isLeftAlign = (flags & 2) !== 0;
+                const isShowSign = (flags & 4) !== 0;
+                const isSpaceSign = (flags & 8) !== 0;
+                let sign = "";
+                if (s.startsWith("-")) {
+                    sign = "-";
+                    s = s.slice(1);
+                }
+                else if (isShowSign) {
+                    sign = "+";
+                }
+                else if (isSpaceSign) {
+                    sign = " ";
+                }
+                if (width > 0 && sign.length + s.length < width) {
+                    const padLen = width - sign.length - s.length;
+                    if (isZeroPad && !isLeftAlign && Number.isFinite(val)) {
+                        s = sign + "0".repeat(padLen) + s;
+                    }
+                    else {
+                        const pad = " ".repeat(padLen);
+                        s = isLeftAlign ? sign + s + pad : pad + sign + s;
+                    }
+                }
+                else {
+                    s = sign + s;
+                }
+                writeStdout(s);
+                return s.length;
+            },
+            read_char: () => {
+                if (typeof stdin === "function") {
+                    return stdin();
+                }
+                else if (typeof stdin === "string") {
+                    if (inPos < stdin.length) {
+                        return stdin.charCodeAt(inPos++);
+                    }
+                    return -1;
+                }
+                return -1;
+            },
+            exit: (code) => {
+                if (onExit) {
+                    onExit(code);
+                }
+                else if (typeof process !== "undefined" &&
+                    typeof process.exit === "function") {
+                    process.exit(code);
+                }
+                // A browser with no onExit hook has nothing to stop the wasm program;
+                // browser hosts should supply onExit (the playground throws from it).
+            },
+        },
+    };
+    return {
+        imports,
+        getStdout: () => stdoutBuffer,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { CppBoltCompiler } from "./compiler.js";
+import { type WasmHostOptions } from "./host.js";
+import { type RunResult } from "./runner.js";
+export { CppBoltCompiler, CompileError, createCompiler } from "./compiler.js";
+export { createWasmHost } from "./host.js";
+export type { WasmHost, WasmHostOptions } from "./host.js";
+export { CppBoltRunner } from "./runner.js";
+export type { RunResult } from "./runner.js";
+/**
+ * Compiles `source` and runs the resulting module in one call.
+ *
+ * Builds a fresh host for the run, so streaming output and stdin are configured
+ * through `options`. Throws `CompileError` if `source` does not compile.
+ */
+export declare function compileAndRun(compiler: CppBoltCompiler, source: string, options?: WasmHostOptions): Promise<RunResult>;

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CppBoltRunner = exports.createWasmHost = exports.createCompiler = exports.CompileError = exports.CppBoltCompiler = void 0;
+exports.compileAndRun = compileAndRun;
+const host_js_1 = require("./host.js");
+const runner_js_1 = require("./runner.js");
+// Re-exports — the public surface of the package.
+var compiler_js_1 = require("./compiler.js");
+Object.defineProperty(exports, "CppBoltCompiler", { enumerable: true, get: function () { return compiler_js_1.CppBoltCompiler; } });
+Object.defineProperty(exports, "CompileError", { enumerable: true, get: function () { return compiler_js_1.CompileError; } });
+Object.defineProperty(exports, "createCompiler", { enumerable: true, get: function () { return compiler_js_1.createCompiler; } });
+var host_js_2 = require("./host.js");
+Object.defineProperty(exports, "createWasmHost", { enumerable: true, get: function () { return host_js_2.createWasmHost; } });
+var runner_js_2 = require("./runner.js");
+Object.defineProperty(exports, "CppBoltRunner", { enumerable: true, get: function () { return runner_js_2.CppBoltRunner; } });
+/**
+ * Compiles `source` and runs the resulting module in one call.
+ *
+ * Builds a fresh host for the run, so streaming output and stdin are configured
+ * through `options`. Throws `CompileError` if `source` does not compile.
+ */
+async function compileAndRun(compiler, source, options) {
+    const host = (0, host_js_1.createWasmHost)(options);
+    const runner = new runner_js_1.CppBoltRunner(host);
+    const bytes = compiler.compile(source);
+    return runner.run(bytes);
+}

package/dist/runner.d.ts

@@ -0,0 +1,29 @@
+import type { WasmHost } from "./host.js";
+/**
+ * The outcome of running a compiled WebAssembly program.
+ */
+export interface RunResult {
+    /** Everything the program wrote to stdout. */
+    stdout: string;
+    /** The program's exit status, or 134 if it trapped. */
+    exitCode: number;
+}
+/**
+ * Instantiates and executes a compiled cppbolt module against a host.
+ *
+ * The runner knows nothing about how the bytes were produced, so it works
+ * equally with bytes from `CppBoltCompiler.compile()` and with a `.wasm` file
+ * loaded from disk or fetched from a URL.
+ */
+export declare class CppBoltRunner {
+    private readonly host;
+    constructor(host: WasmHost);
+    /**
+     * Instantiates `wasmBytes`, calls the program entry point (`main`, falling
+     * back to `_start`), and collects its stdout and exit status.
+     *
+     * A WebAssembly trap is reported as exit status 134 rather than thrown, so
+     * callers can inspect partial output the same way a shell would.
+     */
+    run(wasmBytes: Uint8Array): Promise<RunResult>;
+}

package/dist/runner.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CppBoltRunner = void 0;
+/**
+ * Instantiates and executes a compiled cppbolt module against a host.
+ *
+ * The runner knows nothing about how the bytes were produced, so it works
+ * equally with bytes from `CppBoltCompiler.compile()` and with a `.wasm` file
+ * loaded from disk or fetched from a URL.
+ */
+class CppBoltRunner {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Instantiates `wasmBytes`, calls the program entry point (`main`, falling
+     * back to `_start`), and collects its stdout and exit status.
+     *
+     * A WebAssembly trap is reported as exit status 134 rather than thrown, so
+     * callers can inspect partial output the same way a shell would.
+     */
+    async run(wasmBytes) {
+        const { instance } = await WebAssembly.instantiate(wasmBytes, this.host.imports);
+        let exitCode = 0;
+        try {
+            const exports = instance.exports;
+            const fn = exports.main ?? exports._start;
+            if (fn)
+                exitCode = fn() ?? 0;
+        }
+        catch {
+            // A WebAssembly trap — treat it like SIGABRT (exit 134), matching the
+            // standalone host runner.
+            return { stdout: this.host.getStdout(), exitCode: 134 };
+        }
+        return { stdout: this.host.getStdout(), exitCode };
+    }
+}
+exports.CppBoltRunner = CppBoltRunner;

package/package.json

@@ -1,14 +1,27 @@
 {
   "name": "cppbolt",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "A C++ compiler targeting WebAssembly",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/AJTimePyro/cppbolt.git"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "jsdelivr": "./dist/cppbolt.browser.js",
+  "unpkg": "./dist/cppbolt.browser.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./wasm/cppbolt.wasm": "./wasm/cppbolt.wasm"
+  },
   "files": [
+    "dist/",
     "wasm/cppbolt.wasm",
     "README.md"
-  ]
+  ],
+  "funding": "https://github.com/sponsors/AJTimePyro"
 }