cppbolt 0.1.1 → 1.0.0

package/dist/cppbolt.browser.js

@@ -0,0 +1,509 @@
+"use strict";
+var CppBolt = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // npm/src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    CompileError: () => CompileError,
+    CppBoltCompiler: () => CppBoltCompiler,
+    CppBoltRunner: () => CppBoltRunner,
+    compileAndRun: () => compileAndRun,
+    createCompiler: () => createCompiler,
+    createWasmHost: () => createWasmHost
+  });
+
+  // npm/src/host.ts
+  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 res2 = roundToEvenExact(vNum, prec - 1);
+      return res2.includes(".") ? res2 : res2 + ".";
+    }
+    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;
+  }
+  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);
+          }
+        }
+      }
+    };
+    return {
+      imports,
+      getStdout: () => stdoutBuffer
+    };
+  }
+
+  // npm/src/runner.ts
+  var CppBoltRunner = class {
+    constructor(host) {
+      this.host = 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 {
+        return { stdout: this.host.getStdout(), exitCode: 134 };
+      }
+      return { stdout: this.host.getStdout(), exitCode };
+    }
+  };
+
+  // npm/src/compiler.ts
+  function tryRequire(id) {
+    if (typeof __require !== "function") return null;
+    try {
+      return __require(id);
+    } catch {
+      return null;
+    }
+  }
+  var fs = tryRequire("fs");
+  var path = tryRequire("path");
+  var scriptSrc = typeof document !== "undefined" && document.currentScript instanceof HTMLScriptElement ? document.currentScript.src : null;
+  function decodeString(memory, ptr, len) {
+    return new TextDecoder().decode(new Uint8Array(memory.buffer, ptr, len));
+  }
+  var CompileError = class extends Error {
+    diagnostic;
+    constructor(diagnostic) {
+      super(diagnostic);
+      this.name = "CompileError";
+      this.diagnostic = diagnostic;
+    }
+  };
+  var CppBoltCompiler = class {
+    _exports;
+    constructor(instance) {
+      this._exports = instance.exports;
+    }
+    compile(source) {
+      const ex = this._exports;
+      const mem = ex.memory;
+      const srcBytes = new TextEncoder().encode(source);
+      const srcPtr = ex.alloc_buffer(srcBytes.length);
+      new Uint8Array(mem.buffer, srcPtr, srcBytes.length).set(srcBytes);
+      const resultPtr = ex.compile_wasm(srcPtr, srcBytes.length);
+      ex.dealloc_buffer(srcPtr, srcBytes.length);
+      if (resultPtr === 0) {
+        throw new CompileError(
+          decodeString(mem, ex.get_error_ptr(), ex.get_error_len())
+        );
+      }
+      const resultLen = ex.get_result_len();
+      const output = new Uint8Array(mem.buffer, resultPtr, resultLen).slice();
+      ex.free_result(resultPtr, resultLen);
+      return output;
+    }
+  };
+  async function createCompiler() {
+    if (fs && path && typeof __dirname === "string") {
+      const localPath = path.join(__dirname, "..", "wasm", "cppbolt.wasm");
+      if (fs.existsSync(localPath)) {
+        return new CppBoltCompiler(
+          await loadFromBytes(fs.readFileSync(localPath))
+        );
+      }
+    }
+    const wasmUrl = scriptSrc ? new URL("../wasm/cppbolt.wasm", scriptSrc).href : null;
+    if (wasmUrl) {
+      return new CppBoltCompiler(await loadFromResponse(await fetch(wasmUrl)));
+    }
+    throw new Error(
+      "cppbolt: could not locate wasm binary. Load this script from a URL (CDN / local server) or use the Node.js package."
+    );
+  }
+  async function loadFromResponse(response) {
+    if (!response.ok) {
+      throw new Error(`cppbolt: failed to fetch wasm (HTTP ${response.status})`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/wasm")) {
+      const { instance } = await WebAssembly.instantiateStreaming(response, {});
+      return instance;
+    }
+    return loadFromBytes(await response.arrayBuffer());
+  }
+  async function loadFromBytes(bytes) {
+    const { instance } = await WebAssembly.instantiate(bytes, {});
+    return instance;
+  }
+
+  // npm/src/index.ts
+  async function compileAndRun(compiler, source, options) {
+    const host = createWasmHost(options);
+    const runner = new CppBoltRunner(host);
+    const bytes = compiler.compile(source);
+    return runner.run(bytes);
+  }
+  return __toCommonJS(index_exports);
+})();

package/dist/host.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Options for the runtime import environment used by compiled programs.
+ */
+export interface WasmHostOptions {
+    /**
+     * Stdin source for `read_char`.
+     * - A `string` is consumed character by character; EOF returns -1.
+     * - A `() => number` callback is called once per character; return -1 for EOF.
+     * - Omit (or leave undefined) for no stdin input.
+     */
+    stdin?: string | (() => number);
+    /**
+     * Called whenever the program writes characters to stdout.
+     * Receives the chunk as a string; chunks are flushed per print call,
+     * not per character.
+     */
+    onStdout?: (chunk: string) => void;
+    /**
+     * Called when the program invokes `exit(code)`.
+     * If omitted, falls back to `process.exit(code)` in Node.js. Browser hosts
+     * should provide this hook because there is no `process` to terminate.
+     */
+    onExit?: (code: number) => void;
+}
+/**
+ * The runtime host for a compiled C++ WebAssembly program.
+ * Pass `imports` to `WebAssembly.instantiate`, then call `getStdout()` to
+ * retrieve the accumulated output after the program finishes.
+ */
+export interface WasmHost {
+    /** The WebAssembly import object — provide this to `WebAssembly.instantiate`. */
+    imports: WebAssembly.Imports;
+    /** Returns all stdout output accumulated since the host was created. */
+    getStdout(): string;
+}
+/**
+ * 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.
+ */
+export declare function createWasmHost(options?: WasmHostOptions): WasmHost;