bmweb-cli 0.1.0

package/runtime/core/ipovm/builtins-text.js

@@ -0,0 +1,166 @@
+/**
+ * @file Builtins that convert between text and numbers: string length and
+ * slicing, int/real/string conversions, hex parsing, concatenation, and the
+ * date/time/API-string placeholders.
+ */
+
+/**
+ * The first string-like argument parsed as a decimal, a comma accepted as
+ * the decimal point; 0 when unparseable.
+ * @param {IpoValue[]} stack - the call's arguments
+ * @returns {number}
+ */
+function parseDecimalArg(stack) {
+  const v = parseFloat(String(asStr(firstText(stack)) || '').replace(',', '.'));
+  return Number.isFinite(v) ? v : 0;
+}
+
+/**
+ * strlen(->n, s): a bound value (Python's str subclass) counts, a slot does
+ * not. instr's Text argument is a concatenation (a bound value), so
+ * excluding it read length 0 and skipped the whole substring loop.
+ * @type {IpoBuiltin}
+ */
+function bStrlen(vm, stack) {
+  const x = firstText(stack);
+  storeOut(vm, stack, x == null ? 0 : asStr(x).length);
+}
+
+/**
+ * midstr(->dst, src, start, len): a 0-based substring of the LAST
+ * string-like argument (bound values included), bound to the source's key.
+ * @type {IpoBuiltin}
+ */
+function bMidstr(vm, stack) {
+  const strs = stack.filter((x) => isPlainStr(x) || isBound(x)).map(asStr);
+  const ints = allInts(stack);
+  const src = strs.length ? strs[strs.length - 1] : '';
+  // midstr(dest, source, start, count): start is 0-based. E46.IPO's own
+  // instr() probes from 0 and takes midstr(text, 0, 2) for a mode prefix and
+  // midstr(text, 2, n) for the name after it; the coding screens chunk a hex
+  // string at 0, 2, 4, ... -- none of which works 1-based.
+  const a = ints.length ? ints[0] : 0;
+  const n = ints.length > 1 ? ints[1] : src.length;
+  storeOut(
+    vm,
+    stack,
+    src.slice(Math.max(0, a), Math.max(0, a) + Math.max(0, n)),
+    keyed(stack)
+  );
+}
+
+/**
+ * inttostring / realtostring / formatnum(src, ->dst): the number's text,
+ * truncated to an integer. A BOUND VALUE COUNTS AS A STRING: a job result
+ * written through INPAapiResult* converts here, and matching plain strings
+ * only zeroed every converted result (S_ZUHEIZ printed "Startzähler : 0" for
+ * a counter the wire answered 7).
+ * @type {IpoBuiltin}
+ */
+function bInttostring(vm, stack) {
+  const n = firstNumberArg(stack);
+  storeOut(vm, stack, String(Math.trunc(n)), keyed(stack));
+}
+
+/**
+ * inttolong / bytetoint: a NUMBER out, not its text. Mapped to inttostring
+ * they handed the fault printer "42" as a string, so `< 0` and longtoreal
+ * saw no number and every entry read "Nr: 0".
+ * @type {IpoBuiltin}
+ */
+function bIntwiden(vm, stack) {
+  const n = firstNumberArg(stack);
+  storeOut(vm, stack, Math.trunc(n), keyed(stack));
+}
+
+/**
+ * stringtoreal(src, ->dst).
+ * @type {IpoBuiltin}
+ */
+function bStringtoreal(vm, stack) {
+  storeOut(vm, stack, parseDecimalArg(stack), keyed(stack));
+}
+
+/**
+ * stringtoint(src, ->dst): the decimal truncated.
+ * @type {IpoBuiltin}
+ */
+function bStringtoint(vm, stack) {
+  storeOut(vm, stack, Math.trunc(parseDecimalArg(stack)), keyed(stack));
+}
+
+/**
+ * hexconvert(src, ->b2, ->b1, ->b0, ->b3): a hex string split into bytes,
+ * in the order the scripts expect them.
+ * @type {IpoBuiltin}
+ */
+function bHexconvert(vm, stack) {
+  let v = parseInt(String(asStr(firstText(stack)) || '').trim() || '0', 16);
+  if (!Number.isFinite(v)) v = 0;
+  const refs = stack.filter(isRef);
+  const parts = [(v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff, (v >> 24) & 0xff];
+  refs.forEach((r, k) => {
+    if (k < 4) storeOut(vm, [r], parts[k]);
+  });
+}
+
+/**
+ * strcat(->dst, a, b, ...): every string-like argument joined (dest ref
+ * FIRST -- not order-aligned with the other conversions).
+ * @type {IpoBuiltin}
+ */
+function bStrcat(vm, stack) {
+  const ins = stack.filter((x) => isPlainStr(x) || isBound(x)).map(asStr);
+  storeOut(vm, stack, ins.join(''), keyed(stack));
+}
+
+/**
+ * The inttoreal/realtoint/longtoreal family: a number out, unchanged. A job
+ * result or a converted value arrives BOUND (its text plus the key it came
+ * from): convert the text, as inttostring does.
+ * @type {IpoBuiltin}
+ */
+function bNumconvert(vm, stack) {
+  storeOut(vm, stack, firstNumberArg(stack), keyed(stack));
+}
+
+/**
+ * getdate(->s): a fixed date offline.
+ * @type {IpoBuiltin}
+ */
+function bGetdate(vm, stack) {
+  storeOut(vm, stack, '01.01.2000');
+}
+
+/**
+ * gettime(->s): a fixed time offline.
+ * @type {IpoBuiltin}
+ */
+function bGettime(vm, stack) {
+  storeOut(vm, stack, '00:00:00');
+}
+
+/**
+ * getapistring(->s): empty.
+ * @type {IpoBuiltin}
+ */
+function bGetapistring(vm, stack) {
+  storeOut(vm, stack, '');
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    bStrlen,
+    bMidstr,
+    bInttostring,
+    bIntwiden,
+    bStringtoreal,
+    bStringtoint,
+    bHexconvert,
+    bStrcat,
+    bNumconvert,
+    bGetdate,
+    bGettime,
+    bGetapistring,
+  };
+}

package/runtime/core/ipovm/emissions.js

@@ -0,0 +1,138 @@
+/**
+ * @file What a run of the .IPO VM produces: the drawn lines, the menu items,
+ * the jobs it sent, the dialogs it opened, and the navigation it performed.
+ * One Emissions object per run; the driver reads it after the run settles.
+ */
+
+/**
+ * One drawn cell of a LINE. `t` says what drew it: a printed literal, a
+ * value bound to a result key, a lamp (digitalout) or a bar (analogout).
+ * @typedef {object} IpoElement
+ * @property {'text'|'value'|'lamp'|'gauge'} t - element kind
+ * @property {string} [s] - the text (a literal, or the live text of a value)
+ * @property {string} [key] - the result key a value/lamp/gauge is bound to
+ * @property {string[]} [also] - other keys folded into a concatenated value
+ * @property {Record<string, string>} [map] - a lookup table the value came from
+ * @property {string} [unit] - the *_EINH key drawn beside a value
+ * @property {number} [row] - screen row, relative to its LINE
+ * @property {number} [col] - screen column
+ * @property {number} [lrow] - the script's own row, once the driver rebases `row`
+ * @property {number} [min] - analogout scale minimum
+ * @property {number} [max] - analogout scale maximum
+ * @property {number} [warnLo] - analogout valid-band low edge
+ * @property {number} [warnHi] - analogout valid-band high edge
+ * @property {string} [fmt] - analogout display format ("6.2")
+ * @property {string} [on] - digitalout's TrueText
+ * @property {string} [off] - digitalout's FalseText
+ */
+
+/**
+ * One LINE block's output: a logical line of INPA's virtual screen.
+ * @typedef {object} IpoLine
+ * @property {string|null} label - the LINE's name (what Select offers), or null
+ * @property {IpoElement[]} elements - the cells it drew
+ * @property {string} [jobArg] - the job argument the line was drawn for
+ */
+
+/**
+ * A menu ITEM as the run saw it: the F-key, its caption, and what pressing
+ * it was found to do.
+ * @typedef {object} IpoItem
+ * @property {number} nr - F-key number (11..20 = shifted)
+ * @property {string} [label] - caption
+ * @property {boolean} [fromSetitem] - declared by setitem() rather than an ITEM token
+ * @property {number|null} [on] - setitem's third argument: 1 shows the key, 0 hides it
+ * @property {string} [menu] - the menu it opens
+ * @property {string} [screen] - the screen it sets
+ * @property {string} [job] - the job it sends
+ * @property {string} [jobArg] - that job's argument
+ * @property {boolean} [stateJob] - the job was found inside a state machine
+ * @property {string} [stateEnter] - the state machine it starts
+ * @property {boolean} [faultRead] - it switches the fault-read mode
+ * @property {string[]} [prompt] - the input prompts it shows
+ * @property {string[]} [messages] - the message boxes it opens
+ * @property {string} [action] - select | deselect | exit | printscreen
+ * @property {boolean} [appTool] - scriptchange/callwin: an app-side tool
+ * @property {[number, IpoValue]} [_sel] - a record index it selects (`const v; store global`)
+ */
+
+/**
+ * A job the run sent.
+ * @typedef {object} IpoJobRecord
+ * @property {string} job - job name
+ * @property {string|null} sgbd - the SGBD the script addressed
+ * @property {string} [arg] - the argument, when not fed by an input dialog
+ */
+
+/**
+ * A message box the run opened.
+ * @typedef {object} IpoMessage
+ * @property {string} title - the box's title
+ * @property {string|null} body - its text
+ */
+
+/** Everything one run of a proc emitted. */
+class Emissions {
+  constructor() {
+    /** @type {string|null} settitle/setmenutitle */
+    this.title = null;
+    /** @type {IpoItem[]} */
+    this.items = [];
+    /** @type {IpoLine[]} */
+    this.lines = [];
+    /** @type {IpoJobRecord[]} */
+    this.jobs = [];
+    /** @type {string|null} the menu setmenu() handed control to */
+    this.menu = null;
+    /** @type {string|null} the screen setscreen() set */
+    this.screen = null;
+    /** @type {IpoMessage[]} */
+    this.messages = [];
+    /** @type {string[]} every builtin called, in order */
+    this.calls = [];
+    /** @type {string[]} the %STATE labels the run parked at */
+    this.states = [];
+    /** @type {string[]} result keys read (executed branches and harvested ones) */
+    this.reads = [];
+    /** @type {Set<string>} result keys a branch decided on */
+    this.predicateReads = new Set();
+    /** @type {string|null} the .IPO a scriptchange() handed control to */
+    this.scriptChange = null;
+    /**
+     * clearrect / ftextclear: screen areas the body blanked, in the
+     * script's own row / column coordinates; the runtime drops the cells
+     * it still holds there.
+     * @type {{row: number, col: number, h: number, w: number}[]}
+     */
+    this.clears = [];
+    /**
+     * viewopen(file): the text file the script wrote and asked INPA to show
+     * (a whole-vehicle fault protocol), as its lines.
+     * @type {{path: string, lines: string[]}|null}
+     */
+    this.view = null;
+    /**
+     * setscreen's second argument: TRUE = a frequent screen, re-run its cycle
+     * while it is current (INPA's WM_TIMER loop); null = no setscreen.
+     * @type {boolean|null}
+     */
+    this.screenFrequent = null;
+    /** @type {boolean} blankscreen: the runtime clears the painted grid before the next cycle */
+    this.blank = false;
+    /** @type {boolean} exit: the script ended itself (INPA returns to script selection) */
+    this.exit = false;
+    /**
+     * setstate(&sm): the state machine a key handed control to. In wire mode
+     * the driver runs it (its picker, its job, its parks); offline the
+     * builtin executes it for the lift.
+     * @type {string|null}
+     */
+    this.stateEnter = null;
+    /** @type {boolean} deselect(): the line filter Select set is cleared */
+    this.deselect = false;
+  }
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { Emissions };
+}

package/runtime/core/ipovm/hosts.js

@@ -0,0 +1,191 @@
+/**
+ * @file Where the script's questions about the car get answered. The VM asks
+ * its host for job results, JOB_STATUS and the input-dialog state; the
+ * offline host answers with placeholders, the fed host serves what the wire
+ * returned. The VM does not know the difference.
+ */
+
+/**
+ * What a job's answer looks like when fed to the VM: the flat union of every
+ * result set's keys, plus -- optionally -- the sets themselves, numbered as
+ * EDIABAS numbers them (0 = the system record, 1..n = what the job produced).
+ * @typedef {Map<string, string> & {sets?: Array<Record<string, string>>}} IpoFeed
+ */
+
+/**
+ * The host interface the VM calls.
+ * @typedef {object} IpoHost
+ * @property {(sgbd: string|null, job: string|null, arg: string|null, results: null) => object} job -
+ *   run a job (offline hosts return nothing; the driven VM suspends instead)
+ * @property {(key: string, opts?: {integer?: boolean, set?: number, default?: *}) => (string|number)} result -
+ *   INPAapiResult*: the value of a result key, numeric when asked as integer
+ * @property {() => string} status - INPAapiCheckJobStatus: the last job's JOB_STATUS
+ * @property {() => number} inputstate - getinputstate's placeholder
+ * @property {(m: IpoFeed|object) => void} [feed] - accept a job's results (FeedHost)
+ * @property {() => number} [count] - INPAapiResultSets: how many sets the job produced
+ */
+
+/**
+ * The OFFLINE host (mirrors ipo_vm.py's Host): jobs return nothing, reads read
+ * empty except the two invariants -- JOB_STATUS is OKAY, an integer read is 1
+ * (one of every list) -- which is enough to walk the tree and draw the
+ * maximal structure.
+ * @implements {IpoHost}
+ */
+class OkHost {
+  /**
+   * A job run offline produces nothing.
+   * @param {string|null} _sgbd - SGBD the script addressed
+   * @param {string|null} _job - job name
+   * @param {string|null} _arg - job argument
+   * @param {null} _results - unused
+   * @returns {object}
+   */
+  job(_sgbd, _job, _arg, _results) {
+    return {};
+  }
+
+  /**
+   * A placeholder read: JOB_STATUS, 1 for an integer, else the default or ''.
+   * @param {string} key - result key
+   * @param {{integer?: boolean, set?: number, default?: *}} [opts] - read options
+   * @returns {string|number}
+   */
+  result(key, opts = {}) {
+    if (key === 'JOB_STATUS') return this.status();
+    if (opts.integer) return 1;
+    return opts.default != null ? opts.default : '';
+  }
+
+  /**
+   * Offline every job succeeds.
+   * @returns {string}
+   */
+  status() {
+    return 'OKAY';
+  }
+
+  /**
+   * Offline every input is confirmed (the guard tests `== 0`).
+   * @returns {number}
+   */
+  inputstate() {
+    return 0;
+  }
+}
+
+/**
+ * A host the driver FEEDS: resume(resultsMap) lands here, and the machine's
+ * INPAapiResult* reads serve from the most recent job's results -- including
+ * JOB_STATUS, so INPAapiCheckJobStatus sees the wire's own verdict.
+ * @implements {IpoHost}
+ */
+class FeedHost {
+  constructor() {
+    /** @type {Map<string, string>} the flat union of the last job's keys */
+    this.map = new Map();
+    /**
+     * EDIABAS numbers a job's result sets 0..n: set 0 is the system record
+     * (OBJECT, VARIANTE, JOBNAME, SAETZE), sets 1..n are what the job
+     * produced -- one per fault for FS_LESEN, the last one carrying
+     * JOB_STATUS. A feed may carry that array as `sets`; the flat map is the
+     * union of every set and answers a read that names no set.
+     * @type {Array<Record<string, string>>|null}
+     */
+    this.sets = null;
+  }
+
+  /**
+   * Take a job's results as the current answer.
+   * @param {IpoFeed|object} m - a Map (with an optional `sets` array) or a plain object
+   * @returns {void}
+   */
+  feed(m) {
+    this.map = m instanceof Map ? m : new Map(Object.entries(m || {}));
+    this.sets = m && Array.isArray(m.sets) ? m.sets : null;
+  }
+
+  /**
+   * The driven VM never runs a job through the host: it suspends and the
+   * driver feeds the answer back.
+   * @param {string|null} _sgbd - SGBD the script addressed
+   * @param {string|null} _job - job name
+   * @param {string|null} _arg - job argument
+   * @param {null} _results - unused
+   * @returns {object}
+   */
+  job(_sgbd, _job, _arg, _results) {
+    return {};
+  }
+
+  /**
+   * INPAapiResultSets: how many sets the job produced (n, without set 0).
+   * @returns {number}
+   */
+  count() {
+    return this.sets ? Math.max(0, this.sets.length - 1) : 1;
+  }
+
+  /**
+   * A read served from the numbered set when one is named and carried, else
+   * from the flat map. JOB_STATUS is asked of the last set; the wire's
+   * verdict answers wherever the shim put it.
+   * @param {string} key - result key
+   * @param {{integer?: boolean, set?: number, default?: *}} [opts] - read options
+   * @returns {string|number}
+   */
+  /**
+   * The value behind a key as the wire delivered it (a binary result is
+   * bytes, not text): from the numbered set when one is named, else the
+   * flat map.
+   * @param {string} key - the result name
+   * @param {{set?: number}} [opts]
+   * @returns {*}
+   */
+  raw(key, opts = {}) {
+    const si = opts.set;
+    if (this.sets && si != null && si >= 0 && si < this.sets.length) {
+      const s = this.sets[si] || {};
+      return Object.prototype.hasOwnProperty.call(s, key) ? s[key] : undefined;
+    }
+    return this.map.get(key);
+  }
+
+  result(key, opts = {}) {
+    let v;
+    const si = opts.set;
+    if (this.sets && si != null && si >= 0 && si < this.sets.length) {
+      const s = this.sets[si] || {};
+      v = Object.prototype.hasOwnProperty.call(s, key) ? s[key] : undefined;
+      if (v == null && key === 'JOB_STATUS') return this.status();
+    } else {
+      if (key === 'JOB_STATUS') return this.status();
+      v = this.map.get(key);
+    }
+    if (v == null) {
+      return opts.integer ? 0 : opts.default != null ? opts.default : '';
+    }
+    return opts.integer ? parseInt(v, 10) || 0 : String(v);
+  }
+
+  /**
+   * The fed JOB_STATUS, OKAY when the feed carried none.
+   * @returns {string}
+   */
+  status() {
+    const st = this.map.get('JOB_STATUS');
+    return st != null ? String(st) : 'OKAY';
+  }
+
+  /**
+   * getinputstate's placeholder when nothing was driven.
+   * @returns {number}
+   */
+  inputstate() {
+    return 0;
+  }
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { OkHost, FeedHost };
+}