@portll/cobolwork 0.5.0 → 0.7.0

package/lib/hlasm/asm/sections.mjs

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for HLASM section and linkage instructions: CSECT, DSECT, RSECT, START, COM, LOCTR, ENTRY,
+// EXTRN, WXTRN, AMODE, RMODE, ALIAS, XATTR, CATTR, DXD, CXD.
+import { HlasmSyntax, NAME, splitOperands } from '../operands.mjs';
+import { parseExpression } from '../expr.mjs';
+
+const AMODE_VALUES = new Set(['24', '31', '64', 'ANY', 'ANY31', 'ANY64']);
+const RMODE_VALUES = new Set(['24', '31', '64', 'ANY']);
+const XATTR_VALUES = {
+  ATTRIBUTES: null,
+  LINKAGE: new Set(['OS', 'XPLINK']),
+  PSECT: null,
+  REFERENCE: new Set(['DIRECT', 'INDIRECT', 'DATA', 'CODE']),
+  SCOPE: new Set(['SECTION', 'MODULE', 'LIBRARY', 'IMPORT', 'EXPORT']),
+};
+const CATTR_VALUES = {
+  ALIGN: null,
+  DEFLOAD: true,
+  EXECUTABLE: true,
+  FILL: null,
+  NOLOAD: true,
+  NOTEXECUTABLE: true,
+  NOTREUSABLE: true,
+  PART: null,
+  PRIORITY: null,
+  READONLY: true,
+  REFRESH: true,
+  RENT: true,
+  REUSABLE: true,
+  RMODE: new Set(['24', '31', 'ANY', '64']),
+};
+
+function noOperand(kind, st, requireName) {
+  if (st.field.trim()) throw new HlasmSyntax(`${kind} takes no operand`);
+  if (requireName && !st.name) throw new HlasmSyntax(`${kind} requires a name`);
+  return { kind, name: st.name || null };
+}
+
+function nameList(kind, st) {
+  const ops = splitOperands(st.field);
+  if (!ops.length) throw new HlasmSyntax(`${kind} requires at least one operand`);
+  const names = [];
+  const parts = [];
+  for (const op of ops) {
+    const t = op.trim();
+    if (!t) throw new HlasmSyntax(`${kind} has an empty operand`);
+    const m = /^PART\(([\s\S]*)\)$/i.exec(t);
+    if (m) {
+      for (const p of m[1].split(',')) {
+        const n = p.trim();
+        if (!NAME.test(n)) throw new HlasmSyntax(`${kind} PART has an invalid name '${n}'`);
+        parts.push(n.toUpperCase());
+      }
+    } else if (NAME.test(t)) {
+      names.push(t.toUpperCase());
+    } else {
+      throw new HlasmSyntax(`${kind} operand '${t}' is not a name or PART(...)`);
+    }
+  }
+  return { kind, names, parts };
+}
+
+function mode(kind, st, values) {
+  const ops = splitOperands(st.field);
+  if (ops.length !== 1) throw new HlasmSyntax(`${kind} takes exactly one operand`);
+  const v = ops[0].trim().toUpperCase();
+  if (!values.has(v)) throw new HlasmSyntax(`${kind} operand '${v}' is not a valid mode`);
+  return { kind, name: st.name || null, mode: v };
+}
+
+function alias(st) {
+  const ops = splitOperands(st.field);
+  if (ops.length !== 1) throw new HlasmSyntax('ALIAS takes exactly one operand');
+  if (!st.name) throw new HlasmSyntax('ALIAS requires a name');
+  const t = ops[0].trim();
+  const m = /^([CX])'((?:[^']|'')*)'$/i.exec(t);
+  if (!m) throw new HlasmSyntax('ALIAS operand must be C\'string\' or X\'hex\'');
+  return { kind: 'ALIAS', name: st.name, alias: { type: m[1].toUpperCase(), text: m[2] } };
+}
+
+function xattr(st) {
+  if (!st.name) throw new HlasmSyntax('XATTR requires a name');
+  const ops = splitOperands(st.field);
+  if (!ops.length) throw new HlasmSyntax('XATTR requires at least one operand');
+  const attributes = {};
+  for (const op of ops) {
+    const t = op.trim();
+    const m = /^([A-Z]+)(?:\(([\s\S]*)\))?$/i.exec(t);
+    if (!m) throw new HlasmSyntax(`XATTR operand '${t}' is not a keyword`);
+    const key = m[1].toUpperCase();
+    if (!(key in XATTR_VALUES)) throw new HlasmSyntax(`XATTR keyword '${key}' is not recognised`);
+    const val = m[2] !== undefined ? m[2].trim() : null;
+    if (val !== null) {
+      const allowed = XATTR_VALUES[key];
+      if (allowed && !allowed.has(val.toUpperCase())) throw new HlasmSyntax(`XATTR ${key} value '${val}' is not valid`);
+    }
+    attributes[key] = val !== null ? val : true;
+  }
+  return { kind: 'XATTR', name: st.name, attributes };
+}
+
+function cattr(st) {
+  if (!st.name) throw new HlasmSyntax('CATTR requires a name');
+  const ops = splitOperands(st.field);
+  if (!ops.length) throw new HlasmSyntax('CATTR requires at least one operand');
+  const attributes = {};
+  for (const op of ops) {
+    const t = op.trim();
+    const m = /^([A-Z]+)(?:\(([\s\S]*)\))?$/i.exec(t);
+    if (!m) throw new HlasmSyntax(`CATTR operand '${t}' is not a keyword`);
+    const key = m[1].toUpperCase();
+    if (!(key in CATTR_VALUES)) throw new HlasmSyntax(`CATTR keyword '${key}' is not recognised`);
+    const val = m[2] !== undefined ? m[2].trim() : null;
+    if (val !== null) {
+      const allowed = CATTR_VALUES[key];
+      if (allowed instanceof Set && !allowed.has(val.toUpperCase())) throw new HlasmSyntax(`CATTR ${key} value '${val}' is not valid`);
+    }
+    attributes[key] = val !== null ? val : true;
+  }
+  return { kind: 'CATTR', name: st.name, attributes };
+}
+
+function dxd(st) {
+  if (!st.name) throw new HlasmSyntax('DXD requires a name');
+  const ops = splitOperands(st.field);
+  if (ops.length !== 1) throw new HlasmSyntax('DXD takes exactly one operand');
+  return { kind: 'DXD', name: st.name, operand: ops[0].trim() };
+}
+
+export const parsers = {
+  CSECT: (st) => noOperand('CSECT', st, false),
+  // An unnamed dummy section, like an unnamed COM, is defined when the name entry is omitted.
+  // https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=sections-unnamed-section
+  DSECT: (st) => noOperand('DSECT', st, false),
+  RSECT: (st) => noOperand('RSECT', st, false),
+  COM: (st) => noOperand('COM', st, false),
+  START: (st) => {
+    const ops = splitOperands(st.field);
+    if (ops.length > 1) throw new HlasmSyntax('START takes at most one operand');
+    const origin = ops.length ? parseExpression(ops[0].trim()) : null;
+    return { kind: 'START', name: st.name || null, origin };
+  },
+  LOCTR: (st) => {
+    if (!st.name) throw new HlasmSyntax('LOCTR requires a name');
+    if (st.field.trim()) throw new HlasmSyntax('LOCTR takes no operand');
+    return { kind: 'LOCTR', name: st.name };
+  },
+  ENTRY: (st) => nameList('ENTRY', st),
+  EXTRN: (st) => nameList('EXTRN', st),
+  WXTRN: (st) => nameList('WXTRN', st),
+  AMODE: (st) => mode('AMODE', st, AMODE_VALUES),
+  RMODE: (st) => mode('RMODE', st, RMODE_VALUES),
+  ALIAS: alias,
+  XATTR: xattr,
+  CATTR: cattr,
+  DXD: dxd,
+  CXD: (st) => {
+    if (st.field.trim()) throw new HlasmSyntax('CXD takes no operand');
+    return { kind: 'CXD', name: st.name || null };
+  },
+};

package/lib/hlasm/asm/symbols.mjs

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// The assembler instructions that define symbols and move or read the location counter: EQU, ORG,
+// CNOP, LTORG, USING, DROP, OPSYN, END, PUSH and POP.
+// https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=instructions-equ-instruction
+import { HlasmSyntax, NAME, splitOperands } from '../operands.mjs';
+import { parseExpression } from '../expr.mjs';
+
+const ASSEMBLER_TYPES = new Set(['AR', 'CR', 'CR32', 'CR64', 'FPR', 'GR', 'GR32', 'GR64', 'VR']);
+const STACKED = new Set(['PRINT', 'USING', 'ACONTROL', 'NOPRINT']);
+const optional = (text) => (text ? parseExpression(text) : null);
+
+function equ(st) {
+  if (!st.name) throw new HlasmSyntax('EQU needs a name');
+  const ops = splitOperands(st.field || '');
+  if (!ops.length || !ops[0]) throw new HlasmSyntax('EQU needs a value');
+  if (ops.length > 5) throw new HlasmSyntax(`EQU takes at most five operands, not ${ops.length}`);
+  const assemblerType = ops[4] ? ops[4].toUpperCase() : null;
+  if (assemblerType && !ASSEMBLER_TYPES.has(assemblerType)) throw new HlasmSyntax(`${ops[4]} is not an assembler type`);
+  return { kind: 'EQU', name: st.name, value: parseExpression(ops[0]), length: optional(ops[1]), type: optional(ops[2]), programType: optional(ops[3]), assemblerType };
+}
+
+function org(st) {
+  const ops = splitOperands(st.field || '');
+  if (!ops.length) return { kind: 'ORG', value: null, boundary: null, offset: null };
+  if (ops.length > 3) throw new HlasmSyntax(`ORG takes at most three operands, not ${ops.length}`);
+  const boundary = ops[1] ? Number(ops[1]) : null;
+  if (ops[1] && !(Number.isInteger(boundary) && boundary >= 2 && boundary <= 4096 && (boundary & (boundary - 1)) === 0)) throw new HlasmSyntax(`ORG boundary ${ops[1]} is not a power of 2 from 2 to 4096`);
+  return { kind: 'ORG', value: ops[0] ? parseExpression(ops[0]) : null, boundary, offset: optional(ops[2]) };
+}
+
+function using(st) {
+  const ops = splitOperands(st.field || '');
+  if (ops.length < 2) throw new HlasmSyntax('USING needs a base and a register or address');
+  const range = /^\(([\s\S]*)\)$/.exec(ops[0]);
+  const parts = range ? splitOperands(range[1]) : null;
+  if (parts && parts.length !== 2) throw new HlasmSyntax(`USING range ${ops[0]} needs a base and an end`);
+  return {
+    kind: 'USING', label: st.name || null,
+    base: parseExpression(parts ? parts[0] : ops[0]), end: parts ? parseExpression(parts[1]) : null,
+    registers: ops.slice(1).map((o) => parseExpression(o)),
+  };
+}
+
+function names(kind, allowed) {
+  return (st) => {
+    const ops = splitOperands(st.field || '').map((o) => o.toUpperCase());
+    for (const o of ops) if (!allowed.has(o)) throw new HlasmSyntax(`${kind} does not take ${o}`);
+    if (!ops.length) throw new HlasmSyntax(`${kind} needs an operand`);
+    return { kind, what: ops };
+  };
+}
+
+export const parsers = {
+  EQU: equ,
+  ORG: org,
+  USING: using,
+  DROP: (st) => ({ kind: 'DROP', operands: splitOperands(st.field || '').map((o) => parseExpression(o)) }),
+  LTORG: (st) => { if (st.field) throw new HlasmSyntax('LTORG takes no operand'); return { kind: 'LTORG', name: st.name || null }; },
+  CNOP: (st) => {
+    const ops = splitOperands(st.field || '');
+    if (ops.length !== 2) throw new HlasmSyntax(`CNOP takes two operands, not ${ops.length}`);
+    return { kind: 'CNOP', byte: parseExpression(ops[0]), boundary: parseExpression(ops[1]) };
+  },
+  OPSYN: (st) => {
+    if (!st.name) throw new HlasmSyntax('OPSYN needs a name');
+    const ops = splitOperands(st.field || '');
+    if (ops.length > 1 || (ops[0] && !NAME.test(ops[0]))) throw new HlasmSyntax(`OPSYN takes one operation name, not ${st.field}`);
+    return { kind: 'OPSYN', name: st.name, operation: ops[0] ? ops[0].toUpperCase() : null };
+  },
+  // The second operand names the language translator, in parentheses; it is kept as written.
+  END: (st) => {
+    const ops = splitOperands(st.field || '');
+    if (ops.length > 2) throw new HlasmSyntax(`END takes at most two operands, not ${ops.length}`);
+    return { kind: 'END', entry: ops[0] ? parseExpression(ops[0]) : null, language: ops[1] || null };
+  },
+  PUSH: names('PUSH', STACKED),
+  POP: names('POP', STACKED),
+};

package/lib/hlasm/exec.mjs

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// EXEC CICS, EXEC SQL and EXEC DLI written in assembler, read by the same code that reads them in
+// COBOL: the CICS command table and option reader, and the SQL host-variable reader.
+import { HlasmSyntax } from './operands.mjs';
+import { cicsOptions, cicsCommand } from '../precompile-cics.mjs';
+import { hostVariableRoles } from '../embedded-sql.mjs';
+
+const after = (st, word) => (st.field || '').replace(new RegExp(`^${word}\\b\\s*`, 'i'), '');
+
+export const parsers = {
+  'EXEC CICS': (st) => {
+    const options = cicsOptions(after(st, 'CICS'));
+    const command = cicsCommand(options);
+    if (!command) throw new HlasmSyntax(`${options[0]?.word || 'nothing'} is not a CICS command the command table holds`);
+    return { kind: 'EXEC CICS', command, options };
+  },
+  'EXEC SQL': (st) => {
+    const sql = after(st, 'SQL');
+    if (!sql) throw new HlasmSyntax('EXEC SQL holds no statement');
+    return { kind: 'EXEC SQL', sql, hostVariables: hostVariableRoles(sql) };
+  },
+  'EXEC DLI': (st) => {
+    const options = cicsOptions(after(st, 'DLI'));
+    if (!options.length) throw new HlasmSyntax('EXEC DLI holds no command');
+    return { kind: 'EXEC DLI', command: options[0].word, options };
+  },
+};

package/lib/hlasm/expr.mjs

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// HLASM expressions, read and not evaluated: terms (symbols, *, self-defining terms, literals,
+// attribute references, variable symbols) joined by + - * / with the usual precedence. An address
+// operand is an expression with an optional parenthesised index or length and base after it.
+// https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=structure-terms-literals-expressions
+import { HlasmSyntax, ATTRIBUTES } from './operands.mjs';
+import { readDataOperand } from './asm/data.mjs';
+
+const NAME_START = /[A-Z$#@_]/i;
+const NAME_CHAR = /[A-Z0-9$#@_]/i;
+const SELF_DEFINING = new Set(['X', 'B', 'C', 'CA', 'CE', 'CU', 'G']);
+
+class Cursor {
+  constructor(text, pos = 0) { this.text = text; this.pos = pos; }
+  peek(n = 0) { return this.text[this.pos + n]; }
+  fail(what) { throw new HlasmSyntax(`${what} at column ${this.pos + 1} of '${this.text}'`); }
+  name() {
+    const start = this.pos;
+    if (!NAME_START.test(this.peek() || '')) return null;
+    while (NAME_CHAR.test(this.peek() || '')) this.pos++;
+    if (this.pos - start > 63) this.fail('a name longer than 63 characters');
+    return this.text.slice(start, this.pos).toUpperCase();
+  }
+  quoted() {
+    if (this.peek() !== "'") this.fail('expected a quote');
+    let out = '';
+    for (this.pos++; this.pos < this.text.length; this.pos++) {
+      const c = this.text[this.pos];
+      if (c === "'") {
+        if (this.peek(1) === "'") { out += "'"; this.pos++; continue; }
+        this.pos++;
+        return out;
+      }
+      if (c === '&' && this.peek(1) === '&') this.pos++;
+      out += c;
+    }
+    return this.fail('a quoted string is not closed');
+  }
+}
+
+function variable(c) {
+  const start = c.pos;
+  c.pos++;
+  if (!c.name()) c.fail('expected a variable symbol name after &');
+  if (c.peek() === '(') {
+    c.pos++;
+    expression(c);
+    while (c.peek() === ',') { c.pos++; expression(c); }
+    if (c.peek() !== ')') c.fail('expected ) after a variable symbol subscript');
+    c.pos++;
+  }
+  return { t: 'var', text: c.text.slice(start, c.pos).toUpperCase() };
+}
+
+function term(c) {
+  const ch = c.peek();
+  if (ch === undefined) c.fail('expected a term');
+  if (ch === '(') {
+    c.pos++;
+    const inner = expression(c);
+    if (c.peek() !== ')') c.fail('expected )');
+    c.pos++;
+    return { t: 'paren', e: inner };
+  }
+  if (ch === '*') { c.pos++; return { t: 'loc' }; }
+  if (ch === '=') {
+    const { operand, end } = readDataOperand(c.text, c.pos + 1, { literal: true });
+    c.pos = end;
+    return { t: 'lit', dc: operand };
+  }
+  if (ch === '&') return variable(c);
+  if (/[0-9]/.test(ch)) {
+    const start = c.pos;
+    while (/[0-9]/.test(c.peek() || '')) c.pos++;
+    return { t: 'num', v: Number(c.text.slice(start, c.pos)) };
+  }
+  const start = c.pos;
+  const name = c.name();
+  if (!name) c.fail(`unexpected '${ch}'`);
+  if (c.peek() === "'") {
+    if (name.length === 1 && ATTRIBUTES.includes(name) && /[A-Z$#@_&*=]/i.test(c.peek(1) || '')) {
+      c.pos++;
+      const of = c.peek() === '*' ? (c.pos++, { t: 'loc' }) : c.peek() === '&' ? variable(c) : c.peek() === '=' ? term(c) : { t: 'sym', name: c.name() };
+      return { t: 'attr', attr: name, of };
+    }
+    if (SELF_DEFINING.has(name)) return { t: 'sdt', type: name, text: c.quoted() };
+    c.pos = start;
+    c.fail(`'${name}' followed by a quote is neither a self-defining term nor an attribute reference`);
+  }
+  if (c.peek() === '.' && NAME_START.test(c.peek(1) || '')) {
+    c.pos++;
+    return { t: 'sym', qualifier: name, name: c.name() };
+  }
+  return { t: 'sym', name };
+}
+
+function unary(c) {
+  if (c.peek() === '+' || c.peek() === '-') {
+    const op = c.text[c.pos++];
+    return { t: 'unary', op, e: unary(c) };
+  }
+  return term(c);
+}
+
+function product(c) {
+  let left = unary(c);
+  while (c.peek() === '*' || c.peek() === '/') {
+    const op = c.text[c.pos++];
+    left = { t: 'bin', op, l: left, r: unary(c) };
+  }
+  return left;
+}
+
+function expression(c) {
+  let left = product(c);
+  while (c.peek() === '+' || c.peek() === '-') {
+    const op = c.text[c.pos++];
+    left = { t: 'bin', op, l: left, r: product(c) };
+  }
+  return left;
+}
+
+// An expression starting at pos: the tree, and where it ended.
+export function readExpression(text, pos = 0) {
+  const c = new Cursor(text, pos);
+  const e = expression(c);
+  return { e, end: c.pos };
+}
+
+export function parseExpression(text) {
+  const { e, end } = readExpression(text);
+  if (end !== text.length) throw new HlasmSyntax(`unexpected '${text.slice(end)}' after an expression in '${text}'`);
+  return e;
+}
+
+// D(X,B), D(,B), D(X), D(L,B) or an implicit address: the displacement or address expression, and
+// the parenthesised parts written after it, an omitted one as null.
+export function parseAddress(text) {
+  const { e, end } = readExpression(text);
+  if (end === text.length) return { disp: e, parts: null };
+  if (text[end] !== '(' || !text.endsWith(')')) throw new HlasmSyntax(`unexpected '${text.slice(end)}' in the address '${text}'`);
+  const inner = text.slice(end + 1, -1);
+  const parts = [];
+  let at = 0;
+  for (;;) {
+    if (inner[at] === ',' || at === inner.length) parts.push(null);
+    else {
+      const r = readExpression(inner, at);
+      parts.push(r.e);
+      at = r.end;
+    }
+    if (at === inner.length) break;
+    if (inner[at] !== ',') throw new HlasmSyntax(`unexpected '${inner.slice(at)}' in the address '${text}'`);
+    at++;
+  }
+  return { disp: e, parts };
+}
+
+// The symbols an expression names, unqualified, for the locator and the rules.
+export function symbolsOf(e, out = []) {
+  if (!e) return out;
+  if (e.t === 'sym') out.push(e.name);
+  else if (e.t === 'attr') symbolsOf(e.of, out);
+  else if (e.t === 'paren' || e.t === 'unary') symbolsOf(e.e, out);
+  else if (e.t === 'bin') { symbolsOf(e.l, out); symbolsOf(e.r, out); }
+  return out;
+}

package/lib/hlasm/instr.mjs

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Machine instructions, matched against the operand syntax rules/hlasm-instructions.json gives each
+// mnemonic: the operand count, and each operand an expression or an address of the written shape.
+// One matcher for every format, since IBM's operand syntax already says what each operand is.
+import { readFileSync, existsSync } from 'node:fs';
+import { HlasmSyntax, splitOperands } from './operands.mjs';
+import { parseExpression, parseAddress } from './expr.mjs';
+
+const TABLE = new URL('../../rules/hlasm-instructions.json', import.meta.url);
+const rows = existsSync(TABLE) ? JSON.parse(readFileSync(TABLE, 'utf8')).instructions : [];
+export const INSTRUCTIONS = new Map(rows.map((r) => [r.mnemonic, r]));
+
+// "R1,D2(X2,B2)[,M3]" as operand shapes: an address names how many parts its parentheses may hold.
+const shapes = new Map();
+function shapeOf(pattern) {
+  if (shapes.has(pattern)) return shapes.get(pattern);
+  const out = [];
+  let optional = false;
+  for (let part of splitOperands(pattern.replace(/\[,?/g, ',[').replace(/\]/g, '').replace(/^,/, ''))) {
+    if (part.startsWith('[')) { optional = true; part = part.slice(1); }
+    const address = /^(D\d*)\(([^)]*)\)$/.exec(part);
+    out.push({ name: part, optional, parts: address ? address[2].split(',').length : 0 });
+  }
+  shapes.set(pattern, out);
+  return out;
+}
+
+export const formatFamily = (format) => String(format || '').replace(/-[a-z]$/, '');
+
+// An explicit length is assembled into a length field: 8 bits for L, 4 bits for L1 and L2, each
+// holding the length less one, so 0 to 256 and 0 to 16 bytes. Checked when the length is a
+// constant; a symbol's value needs the symbol table.
+const LENGTH_FIELD = { L: 256, L1: 16, L2: 16 };
+function constant(e) {
+  if (!e) return null;
+  if (e.t === 'num') return e.v;
+  if (e.t === 'sdt' && e.type === 'X') return /^[0-9A-F]+$/i.test(e.text) ? parseInt(e.text, 16) : null;
+  if (e.t === 'sdt' && e.type === 'B') return /^[01]+$/.test(e.text) ? parseInt(e.text, 2) : null;
+  if (e.t === 'paren') return constant(e.e);
+  if (e.t === 'unary') { const v = constant(e.e); return v === null ? null : e.op === '-' ? -v : v; }
+  if (e.t === 'bin') {
+    const l = constant(e.l);
+    const r = constant(e.r);
+    if (l === null || r === null) return null;
+    return { '+': l + r, '-': l - r, '*': l * r, '/': r ? Math.trunc(l / r) : 0 }[e.op] ?? null;
+  }
+  return null;
+}
+
+export function parseInstruction(st, row) {
+  const shape = shapeOf(row.operands || '');
+  // An instruction with no operands takes whatever follows it as remarks: SAM24  Back to AMODE 24.
+  if (!shape.length) return { kind: 'INSTRUCTION', mnemonic: st.operation, format: row.format, length: row.length, operands: [] };
+  const given = splitOperands(st.field || '');
+  const required = shape.filter((s) => !s.optional).length;
+  if (given.length < required || given.length > shape.length) {
+    throw new HlasmSyntax(`${st.operation} takes ${required === shape.length ? required : `${required} to ${shape.length}`} operands (${row.operands}), not ${given.length}`);
+  }
+  const operands = given.map((text, i) => {
+    const s = shape[i];
+    if (!text) throw new HlasmSyntax(`operand ${i + 1} of ${st.operation} (${s.name}) is empty`);
+    if (!s.parts) return { operand: s.name, e: parseExpression(text) };
+    const a = parseAddress(text);
+    if (a.parts && a.parts.length > s.parts) throw new HlasmSyntax(`operand ${i + 1} of ${st.operation} (${s.name}) has ${a.parts.length} parts in parentheses, not at most ${s.parts}`);
+    const field = /^D\d*\((L\d?),/.exec(s.name)?.[1];
+    const length = field && a.parts ? constant(a.parts[0]) : null;
+    if (length !== null && (length < 0 || length > LENGTH_FIELD[field])) {
+      throw new HlasmSyntax(`operand ${i + 1} of ${st.operation} has length ${length}, and ${field} holds 0 to ${LENGTH_FIELD[field]}`);
+    }
+    return { operand: s.name, ...a };
+  });
+  return { kind: 'INSTRUCTION', mnemonic: st.operation, format: row.format, length: row.length, operands };
+}