@portll/cobolwork 0.4.0 → 0.6.0

package/lib/hlasm/asm/data.mjs

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// DC and DS operands, and literals, which are DC operands after an equals sign: duplication factor,
+// type and type extension, program type, length, scale and exponent modifiers, and nominal value.
+// https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=statements-dc-instruction
+import { HlasmSyntax, splitOperands } from '../operands.mjs';
+import { readExpression } from '../expr.mjs';
+
+const EXTENSIONS = {
+  C: 'AEU', G: '', X: '', B: '', F: 'D', H: '', E: 'HBD', D: 'HBD', L: 'HBDQ', P: '', Z: '',
+  A: 'D', Y: '', S: 'Y', V: 'D', Q: 'DY', J: 'D', R: 'D',
+};
+const ADDRESS_TYPES = new Set(['A', 'Y', 'S', 'V', 'Q', 'J', 'R']);
+
+// A parenthesised expression or a decimal number, as a duplication factor or a modifier is written.
+function amount(text, pos) {
+  if (text[pos] === '(') {
+    const { e, end } = readExpression(text, pos + 1);
+    if (text[end] !== ')') throw new HlasmSyntax(`expected ) at column ${end + 1} of '${text}'`);
+    return { value: { t: 'paren', e }, end: end + 1 };
+  }
+  const m = /^\d+/.exec(text.slice(pos));
+  if (!m) return null;
+  return { value: { t: 'num', v: Number(m[0]) }, end: pos + m[0].length };
+}
+
+function quotedNominal(text, pos) {
+  let out = '';
+  for (let i = pos + 1; i < text.length; i++) {
+    if (text[i] === "'") {
+      if (text[i + 1] === "'") { out += "'"; i++; continue; }
+      return { value: out, end: i + 1 };
+    }
+    if (text[i] === '&' && text[i + 1] === '&') i++;
+    out += text[i];
+  }
+  throw new HlasmSyntax(`a nominal value is not closed in '${text}'`);
+}
+
+function addressNominal(text, pos) {
+  const items = [];
+  let at = pos + 1;
+  for (;;) {
+    const { e, end } = readExpression(text, at);
+    at = end;
+    if (text[at] === '(') {
+      const close = text.indexOf(')', at);
+      if (close < 0) throw new HlasmSyntax(`a base register is not closed in '${text}'`);
+      items.push({ t: 'address', disp: e, base: text.slice(at + 1, close) });
+      at = close + 1;
+    } else items.push(e);
+    if (text[at] === ',') { at++; continue; }
+    if (text[at] === ')') return { value: items, end: at + 1 };
+    throw new HlasmSyntax(`expected , or ) at column ${at + 1} of '${text}'`);
+  }
+}
+
+// One DC operand starting at pos: the operand, and where it ended. A literal needs a nominal value
+// and a duplication factor that is not zero.
+export function readDataOperand(text, pos = 0, { literal = false, nominalRequired = literal } = {}) {
+  const operand = { dup: null, type: null, ext: null, program: null, length: null, bitLength: false, scale: null, exponent: null, nominal: null };
+  let at = pos;
+  const dup = amount(text, at);
+  if (dup) { operand.dup = dup.value; at = dup.end; }
+  const type = (text[at] || '').toUpperCase();
+  if (!(type in EXTENSIONS)) throw new HlasmSyntax(`'${text.slice(pos)}' has no constant type a DC operand can have`);
+  operand.type = type;
+  at++;
+  const ext = (text[at] || '').toUpperCase();
+  if (ext && EXTENSIONS[type].includes(ext)) { operand.ext = ext; at++; }
+  if ((text[at] || '').toUpperCase() === 'P' && text[at + 1] === '(') {
+    const p = amount(text, at + 1);
+    operand.program = p.value;
+    at = p.end;
+  }
+  for (const [letter, key] of [['L', 'length'], ['S', 'scale'], ['E', 'exponent']]) {
+    if ((text[at] || '').toUpperCase() !== letter) continue;
+    let from = at + 1;
+    if (key === 'length' && text[from] === '.') { operand.bitLength = true; from++; }
+    const sign = key !== 'length' && (text[from] === '-' || text[from] === '+') ? text[from++] : '';
+    const m = amount(text, from);
+    if (!m) throw new HlasmSyntax(`the ${key} modifier in '${text}' has no value`);
+    operand[key] = sign === '-' ? { t: 'unary', op: '-', e: m.value } : m.value;
+    at = m.end;
+  }
+  if (text[at] === "'") {
+    if (ADDRESS_TYPES.has(type)) throw new HlasmSyntax(`a ${type}-type constant takes its value in parentheses, not quotes, in '${text}'`);
+    const n = quotedNominal(text, at);
+    operand.nominal = { quoted: n.value };
+    at = n.end;
+  } else if (text[at] === '(') {
+    if (!ADDRESS_TYPES.has(type)) throw new HlasmSyntax(`a ${type}-type constant takes its value in quotes, not parentheses, in '${text}'`);
+    const n = addressNominal(text, at);
+    operand.nominal = { expressions: n.value };
+    at = n.end;
+  }
+  // A DC operand may omit its nominal value only when its duplication factor is zero.
+  const zeroDup = operand.dup && operand.dup.t === 'num' && operand.dup.v === 0;
+  if (nominalRequired && !operand.nominal && !(zeroDup && !literal)) throw new HlasmSyntax(`'${text.slice(pos, at)}' has no nominal value`);
+  if (literal && operand.dup && operand.dup.t === 'num' && operand.dup.v === 0) throw new HlasmSyntax('a literal cannot have a duplication factor of zero');
+  return { operand, end: at };
+}
+
+function operands(st, nominalRequired) {
+  const list = splitOperands(st.field || '');
+  if (!list.length) throw new HlasmSyntax(`${st.operation} has no operand`);
+  return list.map((text) => {
+    const { operand, end } = readDataOperand(text, 0, { nominalRequired });
+    if (end !== text.length) throw new HlasmSyntax(`unexpected '${text.slice(end)}' after the operand '${text.slice(0, end)}'`);
+    return operand;
+  });
+}
+
+export const parsers = {
+  DC: (st) => ({ kind: 'DC', operands: operands(st, true) }),
+  DS: (st) => ({ kind: 'DS', operands: operands(st, false) }),
+};

package/lib/hlasm/asm/listing.mjs

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for HLASM listing instructions: PRINT, TITLE, EJECT, SPACE, CEJECT.
+
+import { HlasmSyntax, splitOperands } from '../operands.mjs';
+import { parseExpression } from '../expr.mjs';
+
+const PRINT_OPTS = new Set(['ON', 'OFF', 'GEN', 'NOGEN', 'DATA', 'NODATA', 'MCALL', 'NOMCALL', 'MSOURCE', 'NOMSOURCE', 'UHEAD', 'NOUHEAD', 'NOPRINT']);
+
+export const parsers = {
+  PRINT(st) {
+    const ops = splitOperands(st.field);
+    if (ops.length === 0) throw new HlasmSyntax('PRINT requires at least one option');
+    const options = ops.map(o => o.trim().toUpperCase());
+    for (const opt of options) {
+      if (!PRINT_OPTS.has(opt)) throw new HlasmSyntax(`unknown PRINT option: ${opt}`);
+    }
+    return { kind: 'PRINT', options };
+  },
+  TITLE(st) {
+    const ops = splitOperands(st.field);
+    if (ops.length !== 1) throw new HlasmSyntax('TITLE requires exactly one operand');
+    const raw = ops[0].trim();
+    if (!raw.startsWith("'") || !raw.endsWith("'") || raw.length < 2) throw new HlasmSyntax('TITLE operand must be a quoted string');
+    const text = raw.slice(1, -1).replace(/''/g, "'").replace(/&&/g, "&");
+    return { kind: 'TITLE', name: st.name, text };
+  },
+  EJECT(st) {
+    if (st.field.trim() !== '') throw new HlasmSyntax('EJECT takes no operand');
+    return { kind: 'EJECT', value: null };
+  },
+  SPACE(st) {
+    const ops = splitOperands(st.field);
+    if (ops.length === 0) return { kind: 'SPACE', value: null };
+    if (ops.length > 1) throw new HlasmSyntax('SPACE takes at most one operand');
+    return { kind: 'SPACE', value: parseExpression(ops[0].trim()) };
+  },
+  CEJECT(st) {
+    const ops = splitOperands(st.field);
+    if (ops.length === 0) return { kind: 'CEJECT', value: null };
+    if (ops.length > 1) throw new HlasmSyntax('CEJECT takes at most one operand');
+    return { kind: 'CEJECT', value: parseExpression(ops[0].trim()) };
+  }
+};

package/lib/hlasm/asm/output.mjs

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Assembler instructions that write messages, copy source in or shape the input records: MNOTE,
+// COPY, PUNCH, REPRO, AINSERT, ICTL and ISEQ.
+// https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=instructions-mnote-instruction
+import { HlasmSyntax, NAME, splitOperands } from '../operands.mjs';
+import { parseExpression } from '../expr.mjs';
+
+// A quoted string's text, '' read as one quote and && as one ampersand.
+function quoted(text, what) {
+  const m = /^'((?:[^']|'')*)'$/.exec(text.trim());
+  if (!m) throw new HlasmSyntax(`${what} needs a quoted string, not ${text}`);
+  return m[1].replace(/''/g, "'").replace(/&&/g, '&');
+}
+
+const numbers = (st, min, max) => {
+  const ops = splitOperands(st.field || '');
+  if (ops.length < min || ops.length > max || ops.some((o) => !/^\d+$/.test(o.trim()))) throw new HlasmSyntax(`${st.operation} takes ${min} to ${max} decimal numbers, not ${st.field || 'none'}`);
+  return { kind: st.operation, values: ops.map(Number) };
+};
+
+export const parsers = {
+  // [severity,]'message': severity is an absolute expression, *, or empty before the comma.
+  MNOTE: (st) => {
+    const ops = splitOperands(st.field || '');
+    if (ops.length < 1 || ops.length > 2) throw new HlasmSyntax(`MNOTE takes a message and an optional severity, not ${ops.length} operands`);
+    const [sev, msg] = ops.length === 2 ? ops : [null, ops[0]];
+    const severity = sev === null || sev.trim() === '' ? null : sev.trim() === '*' ? '*' : parseExpression(sev.trim());
+    return { kind: 'MNOTE', severity, text: quoted(msg, 'MNOTE') };
+  },
+  COPY: (st) => {
+    const member = (st.field || '').trim();
+    if (!NAME.test(member)) throw new HlasmSyntax(`COPY names a member, not ${member || 'nothing'}`);
+    return { kind: 'COPY', member: member.toUpperCase() };
+  },
+  PUNCH: (st) => ({ kind: 'PUNCH', text: quoted(st.field || '', 'PUNCH') }),
+  REPRO: () => ({ kind: 'REPRO' }),
+  // 'record'[,FRONT|BACK]: a record put into the assembler's input stream.
+  AINSERT: (st) => {
+    const ops = splitOperands(st.field || '');
+    if (ops.length !== 2 || !/^(FRONT|BACK)$/i.test(ops[1].trim())) throw new HlasmSyntax('AINSERT takes a quoted record and FRONT or BACK');
+    return { kind: 'AINSERT', text: quoted(ops[0], 'AINSERT'), where: ops[1].trim().toUpperCase() };
+  },
+  ICTL: (st) => numbers(st, 1, 3),
+  ISEQ: (st) => (st.field ? numbers(st, 2, 2) : { kind: 'ISEQ', values: [] }),
+};

package/lib/hlasm/asm/sections.mjs

@@ -0,0 +1,159 @@
+// 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),
+  DSECT: (st) => noOperand('DSECT', st, true),
+  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;
+}