bmweb-cli 0.1.0

package/runtime/core/ipovm/operators.js

@@ -0,0 +1,229 @@
+/**
+ * @file The .IPO VM's operators: truthiness and numeric coercion of boxed
+ * values, and the `binop` token's arithmetic, comparison and logic -- with
+ * the slot/key identity of an operand carried onto the result so a draw
+ * stays bound to the reading it was computed from.
+ */
+
+/**
+ * Text that reads as a number: what `+` and unary minus treat as arithmetic
+ * when it arrives in a bound box (a job result is text with a key).
+ * @type {RegExp}
+ */
+const IPO_NUMERIC_TEXT_RE = /^-?\d+(\.\d+)?$/;
+
+/**
+ * The comparison operator names: their operands are recorded as predicate
+ * reads (a key a branch decides on) by the offline executor.
+ * @type {string[]}
+ */
+const IPO_COMPARE_OPS = ['eq', 'ne', 'lt', 'gt', 'le', 'ge'];
+
+/**
+ * INPA truthiness: '' and '0' are false, a boxed float is its number, a bound
+ * value is judged by its text.
+ * @param {IpoValue} v - any VM value
+ * @returns {boolean}
+ */
+function truthy(v) {
+  if (isFloat(v)) return !!v.v;
+  if (isBound(v)) v = v.s;
+  if (typeof v === 'string') return v !== '' && v !== '0';
+  return !!v;
+}
+
+/**
+ * Numeric value of any VM value; unparseable text is 0.
+ * @param {IpoValue} v - any VM value
+ * @returns {number}
+ */
+function num(v) {
+  if (isFloat(v)) return v.v;
+  if (isBound(v)) v = v.s;
+  if (typeof v === 'number') return v;
+  const f = parseFloat(String(v));
+  return Number.isNaN(f) ? 0 : f;
+}
+
+/**
+ * Does x read as a number for arithmetic purposes: an unboxed number, a
+ * boxed float, or a bound value whose text is numeric?
+ * @param {IpoValue} x - any VM value
+ * @returns {boolean}
+ */
+function looksNumeric(x) {
+  return (
+    typeof x === 'number' ||
+    isFloat(x) ||
+    (isBound(x) && IPO_NUMERIC_TEXT_RE.test(String(x.s).trim()))
+  );
+}
+
+/**
+ * The (slot, key) an arithmetic result should keep from its operands, so a
+ * scaled reading (slot13 * scale) keeps STAT_..._WERT's key/slot.
+ * @param {IpoValue} a - left operand
+ * @param {IpoValue} b - right operand
+ * @returns {[IpoSlot|null, string|null]}
+ */
+function carry(a, b) {
+  for (const x of [a, b]) {
+    if (isBound(x) && (x.key || x.slot)) return [x.slot, x.key];
+    if (isSlot(x)) return [x, null];
+  }
+  return [null, null];
+}
+
+/**
+ * A numeric result, wrapped to keep an operand's slot/key when one had it,
+ * and to keep FLOAT identity when the maths is real (either operand a float,
+ * or the result non-integral) -- so a later type filter still sees a float.
+ * @param {number} value - the computed number
+ * @param {IpoValue} a - left operand
+ * @param {IpoValue} b - right operand (null for unary minus)
+ * @returns {IpoValue}
+ */
+function boundNum(value, a, b) {
+  const [slot, key] = carry(a, b);
+  const real = isFloat(a) || isFloat(b) || !Number.isInteger(value);
+  if (slot == null && key == null) return real ? mkFloat(value) : value;
+  return mkBound(slot, String(value), key);
+}
+
+/**
+ * INPA equality. Strings (plain or bound) compare as text; floats as numbers;
+ * and, like Python's `==`, a bool equals its int (True == 1) -- a forced
+ * keypress guard is the bool true compared against the const 1, so it must
+ * read equal (LSZ's "start" gates STEUERN_IO on `g52 == 1`). JS === would say
+ * true !== 1, closing the guard and skipping the job.
+ * @param {IpoValue} a - left operand
+ * @param {IpoValue} b - right operand
+ * @returns {boolean}
+ */
+function cmpEq(a, b) {
+  if (isPlainStr(a) || isPlainStr(b) || isBound(a) || isBound(b)) {
+    return asStr(a) === asStr(b);
+  }
+  if (isFloat(a) || isFloat(b)) return num(a) === num(b);
+  if (typeof a === 'boolean' || typeof b === 'boolean') {
+    const na = typeof a === 'boolean' ? (a ? 1 : 0) : a;
+    const nb = typeof b === 'boolean' ? (b ? 1 : 0) : b;
+    return na === nb;
+  }
+  return a === b;
+}
+
+/**
+ * `+` on a slot or bound operand: concatenation that keeps the slot's
+ * identity and folds every other key into `extra`, so a row built as
+ * `<bound slot> + " Werte"` still draws bound to its reading.
+ * @param {IpoValue} a - left operand
+ * @param {IpoValue} b - right operand
+ * @param {IpoSlot} slot - the identity to keep
+ * @returns {IpoBound}
+ */
+function concatBound(a, b, slot) {
+  const [, key] = carry(a, b);
+  const out = mkBound(slot, asStr(a) + asStr(b), key);
+  const folded = [];
+  for (const x of [a, b]) {
+    if (isBound(x)) {
+      if (x.key && x.key !== key) folded.push(x.key);
+      for (const k of x.extra) if (k !== key) folded.push(k);
+    }
+  }
+  if (folded.length) out.extra = [...new Set(folded)];
+  return out;
+}
+
+/**
+ * The `add` operator. BOTH SIDES NUMERIC -> ARITHMETIC, boxed or not: INPA's
+ * + on int variables is addition; the slot/bound boxes exist so the offline
+ * derivation can bind draws, and letting a box force concatenation made a
+ * live accumulator compute '10'+10='1010' (llerh's setpoint on the second
+ * keypress). Otherwise + is concatenation, and a slot concatenated must keep
+ * its identity or the draw sees only text.
+ * @param {IpoValue} a - left operand
+ * @param {IpoValue} b - right operand
+ * @returns {IpoValue}
+ */
+function addOp(a, b) {
+  const numish = (x) => looksNumeric(x) || isSlot(x);
+  if (numish(a) && numish(b)) return boundNum(num(a) + num(b), a, b);
+  let slot = null;
+  for (const x of [a, b]) {
+    if (isSlot(x)) slot = x;
+    else if (isBound(x)) slot = x.slot;
+    if (slot != null) break;
+  }
+  if (slot != null) return concatBound(a, b, slot);
+  if (isPlainStr(a) || isPlainStr(b)) return asStr(a) + asStr(b);
+  return boundNum(num(a) + num(b), a, b);
+}
+
+/**
+ * The `neg` operator (0x6d) is UNARY MINUS (ipo_disasm ground truth): llerh's
+ * "-10" is `const 10; neg`, the clamp bounds are `const 128; neg`. Boolean-not
+ * only ever fit guard shapes; a numeric operand negates arithmetically.
+ * @param {IpoValue} a - the operand when passed first (null from the executor)
+ * @param {IpoValue} b - the operand as the executor passes it
+ * @returns {IpoValue}
+ */
+function negOp(a, b) {
+  const x = a == null ? b : a;
+  if (looksNumeric(x)) return boundNum(-num(x), x, null);
+  return !truthy(x);
+}
+
+/**
+ * Apply a `binop` token. Unknown names yield null.
+ * @param {string} name - operator name (add, sub, mul, div, eq, ne, lt, gt,
+ *   le, ge, and, or, neg)
+ * @param {IpoValue} a - left operand (null for neg)
+ * @param {IpoValue} b - right operand
+ * @returns {IpoValue}
+ */
+function binop(name, a, b) {
+  switch (name) {
+    case 'add':
+      return addOp(a, b);
+    case 'sub':
+      return boundNum(num(a) - num(b), a, b);
+    case 'mul':
+      return boundNum(num(a) * num(b), a, b);
+    case 'div':
+      return boundNum(num(b) ? num(a) / num(b) : 0, a, b);
+    case 'eq':
+      return cmpEq(a, b);
+    case 'ne':
+      return !cmpEq(a, b);
+    case 'lt':
+      return num(a) < num(b);
+    case 'gt':
+      return num(a) > num(b);
+    case 'le':
+      return num(a) <= num(b);
+    case 'ge':
+      return num(a) >= num(b);
+    case 'and':
+      return truthy(a) && truthy(b);
+    case 'or':
+      return truthy(a) || truthy(b);
+    case 'neg':
+      return negOp(a, b);
+    default:
+      return null;
+  }
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    IPO_COMPARE_OPS,
+    truthy,
+    num,
+    carry,
+    boundNum,
+    cmpEq,
+    binop,
+  };
+}

package/runtime/core/ipovm/structures.js

@@ -0,0 +1,250 @@
+/**
+ * @file INPA's binary-structure helpers (CreateStructure / SetStructureMode /
+ * Structure{Byte,Int,Long,String}) and the import32 sprintf the scripts'
+ * own hex formatters (chr, bytetohexstring, longtohexstring) build on.
+ * Offline these stay noops (the Python twin's behaviour, parity-diffed); a
+ * LIVE run needs them or every helper pops its own "Error: Handle" box and
+ * prints nothing.
+ */
+
+/** The builtin names a live run answers here. */
+const IPO_STRUCT_FNS = new Set([
+  'CreateStructure',
+  'SetStructureMode',
+  'StructureByte',
+  'StructureInt',
+  'StructureLong',
+  'StructureString',
+]);
+
+/** Byte width of each fixed-width structure accessor. */
+const IPO_STRUCT_WIDTH = {
+  StructureByte: 1,
+  StructureInt: 2,
+  StructureLong: 4,
+};
+
+/** SetStructureMode: 0 writes into the buffer, 1 reads out of it. */
+const IPO_STRUCT_WRITE = 0;
+
+/** CreateStructure's buffer size when the script names none. */
+const IPO_STRUCT_DEFAULT_SIZE = 1024;
+
+/**
+ * A structure the VM owns, behind a numeric handle.
+ * @typedef {object} IpoStructure
+ * @property {Uint8Array} buf - the bytes
+ * @property {number} mode - the mode it was created in (the effective mode is VM-wide)
+ */
+
+/**
+ * The low bytes of a string, one per character (the structure buffers hold
+ * single-byte text).
+ * @param {string} s - the text
+ * @returns {number[]}
+ */
+function ipoStringBytes(s) {
+  const out = [];
+  for (const ch of String(s || '')) out.push(ch.charCodeAt(0) & 0xff);
+  return out;
+}
+
+/**
+ * The number a structure argument holds: a bound value's text, a boxed
+ * float's value, else Number(); 0 when not finite.
+ * @param {IpoValue} v - the argument
+ * @returns {number}
+ */
+function structNum(v) {
+  if (isBound(v)) v = v.s;
+  if (isFloat(v)) return v.v;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Answer one structure builtin on a live run. A structure is a byte buffer
+ * behind a handle (never 0: 0 is the failure code). Mode 0 writes, 1 reads.
+ * Structure{Byte,Int,Long,String}(handle, offset[, len], value | out ref):
+ * the handle is the first non-out argument (a slot read or a ref); a write
+ * takes the last non-ref argument as its value, a read stores through the
+ * last ref.
+ * @param {IpoVm} vm - the running VM (owns `structs` and `_structMode`)
+ * @param {string} name - the builtin's name (one of IPO_STRUCT_FNS)
+ * @param {IpoValue[]} stack - the call's arguments
+ * @returns {void}
+ */
+/**
+ * The current value behind a reference (through chained refs).
+ * @param {IpoVm} vm - the running VM
+ * @param {IpoRef} r - the reference
+ * @returns {*}
+ */
+function ipoRefValue(vm, r) {
+  const { n, map } = vm._refTarget(r, vm.frame);
+  return map.get(n);
+}
+
+function ipoStructureCall(vm, name, stack) {
+  if (!vm.structs) vm.structs = new Map();
+  const refs = stack.filter(isRef);
+  const nums = stack
+    .map((x) => (isPlainInt(x) ? x : isFloat(x) ? x.v : null))
+    .filter((x) => x != null);
+  if (name === 'CreateStructure') {
+    const size = nums.length ? Math.max(1, nums[0]) : IPO_STRUCT_DEFAULT_SIZE;
+    const h = vm.structs.size + 1;
+    vm.structs.set(h, { buf: new Uint8Array(size), mode: IPO_STRUCT_WRITE });
+    storeOut(vm, stack, h);
+    return;
+  }
+  if (name === 'SetStructureMode') {
+    vm._structMode = nums.length ? nums[0] : IPO_STRUCT_WRITE;
+    return;
+  }
+  const handle = structNum(
+    stack.find((x) => !isRef(x) && (isPlainInt(x) || isBound(x)))
+  );
+  const st = vm.structs.get(handle);
+  if (!st) return;
+  const off = nums.length > 1 ? nums[1] : nums.length ? nums[0] : 0;
+  const width = IPO_STRUCT_WIDTH[name] || 0;
+  const mode = vm._structMode || IPO_STRUCT_WRITE;
+  if (width) {
+    if (mode === IPO_STRUCT_WRITE) {
+      // the value comes by value or, as longtohexstring packs its number,
+      // by reference (StructureLong(handle, 0, &value))
+      const vals = stack.filter((x) => !isRef(x));
+      const v = structNum(
+        refs.length
+          ? ipoRefValue(vm, refs[refs.length - 1])
+          : vals[vals.length - 1]
+      );
+      for (let i = 0; i < width; i++) {
+        if (off + i < st.buf.length) st.buf[off + i] = (v >>> (8 * i)) & 0xff;
+      }
+    } else {
+      let v = 0;
+      for (let i = width - 1; i >= 0; i--) v = v * 256 + (st.buf[off + i] || 0);
+      storeOut(vm, refs.slice(-1), v);
+    }
+    return;
+  }
+  // StructureString(handle, offset, len, out string | string)
+  // StructureString(handle, offset, length, &text): length 0 means "to the
+  // NUL", which is how chr() reads the one byte it packed back as a string
+  const len = nums.length > 2 && nums[2] > 0 ? nums[2] : st.buf.length - off;
+  if (mode === IPO_STRUCT_WRITE) {
+    let sv = stack.find((x) => isPlainStr(x) || (isBound(x) && !isRef(x)));
+    if (sv == null && refs.length) sv = ipoRefValue(vm, refs[refs.length - 1]);
+    const bytes = ipoStringBytes(asStr(sv == null ? '' : sv));
+    for (let i = 0; i < Math.min(len, bytes.length); i++) {
+      if (off + i < st.buf.length) st.buf[off + i] = bytes[i];
+    }
+  } else {
+    let out = '';
+    for (let i = 0; i < len && off + i < st.buf.length; i++) {
+      const b = st.buf[off + i];
+      if (b === 0) break;
+      out += String.fromCharCode(b);
+    }
+    storeOut(vm, refs.slice(-1), out);
+  }
+}
+
+/**
+ * sprintf through import32: (out string ref, format, handle ref, out count
+ * ref). The import table is per-file and carries no names, but the scripts
+ * use it for ONE thing the formatters must honour: a sprintf of a
+ * structure's bytes ("%08lX") into an out string. The format is the only
+ * string carrying '%'; the value is the structure's long at offset 0 (what
+ * the formatters just wrote), or the argument itself when it is not a
+ * handle.
+ * @param {IpoVm} vm - the running VM
+ * @param {IpoValue[]} stack - the call's arguments
+ * @returns {void}
+ */
+function ipoDllCall(vm, stack) {
+  const refs = stack.filter(isRef);
+  // the format is usually computed ('%0' + width + 'lX'), so a bound string
+  const fmtArg = stack.find(
+    (x) => (isPlainStr(x) || isBound(x)) && asStr(x).includes('%')
+  );
+  if (!fmtArg) return ipoDllFileDialog(vm, stack, refs);
+  if (!refs.length) return;
+  const fmt = asStr(fmtArg);
+  let value = 0;
+  if (refs.length > 1) {
+    const raw = ipoRefValue(vm, refs[1]);
+    const n = Number(isBound(raw) ? raw.s : isFloat(raw) ? raw.v : raw);
+    const st = vm.structs && vm.structs.get(n);
+    if (st) {
+      for (let i = 3; i >= 0; i--) value = value * 256 + (st.buf[i] || 0);
+    } else if (Number.isFinite(n)) value = n;
+  }
+  const m = fmt.match(/%(0?)(\d*)(l?)([xXdus])/);
+  let text = fmt;
+  if (m) {
+    const width = m[2] ? Number(m[2]) : 0;
+    let body;
+    if (m[4] === 'x') body = (value >>> 0).toString(16);
+    else if (m[4] === 'X') body = (value >>> 0).toString(16).toUpperCase();
+    else if (m[4] === 'u') body = String(value >>> 0);
+    else body = String(value);
+    const pad = m[1] === '0' ? '0' : ' ';
+    while (body.length < width) body = pad + body;
+    text = fmt.replace(m[0], body);
+  }
+  storeOut(vm, [refs[0]], text);
+  if (refs.length > 2) storeOut(vm, [refs[refs.length - 1]], text.length);
+}
+
+/**
+ * The other import the scripts call: the "save as" dialog. The whole-vehicle
+ * scripts allocate a 256-byte buffer, call the dialog with (filter, &buffer,
+ * length, &rc), and take the buffer as the file name when rc > 0. Live, the
+ * runtime shows the platform's own picker: the call suspends, and the
+ * resume value (the chosen name, '' for cancel) fills the buffer and rc.
+ * The alloc/free calls around it carry no format and no such shape: no-ops.
+ * @param {IpoVm} vm - the running VM
+ * @param {IpoValue[]} stack - the call's arguments
+ * @param {IpoRef[]} refs - its references
+ * @returns {object|null} a 'file' suspension, or null
+ */
+function ipoDllFileDialog(vm, stack, refs) {
+  const plain = stack.filter((x) => !isRef(x));
+  const isDialog =
+    refs.length === 2 &&
+    plain.length === 2 &&
+    (isPlainStr(plain[0]) || isBound(plain[0])) &&
+    isPlainInt(plain[1]);
+  if (!isDialog) return null;
+  return { kind: 'file', filter: asStr(plain[0]), stack, out: vm.out };
+}
+
+/**
+ * The picker's answer into the dialog's refs: the buffer takes the name,
+ * rc its length (0 = cancelled, the script then does nothing).
+ * @param {IpoVm} vm - the running VM
+ * @param {IpoValue[]} stack - the parked call's arguments
+ * @param {string} name - the chosen file name ('' when cancelled)
+ * @returns {void}
+ */
+function ipoDllFileAnswer(vm, stack, name) {
+  const refs = stack.filter(isRef);
+  const text = name == null ? '' : String(name);
+  if (refs.length < 2) return;
+  storeOut(vm, [refs[0]], text);
+  storeOut(vm, [refs[1]], text.length);
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    IPO_STRUCT_FNS,
+    ipoDllFileDialog,
+    ipoDllFileAnswer,
+    ipoStringBytes,
+    ipoStructureCall,
+    ipoDllCall,
+  };
+}