@portll/cobolwork 0.4.0 → 0.6.0

package/lib/hlasm/macro/io.mjs

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the z/OS record macros GET, PUT, READ, and WRITE in their standard forms.
+import { HlasmSyntax, NAME } from '../operands.mjs';
+import { parseExpression, parseAddress } from '../expr.mjs';
+
+const REG = /^\(\d{1,2}\)$/;
+const MF_VAL = /^(L|\((E|M),\s*[A-Z$#@_][A-Z0-9$#@_]*\))$/i;
+
+function parseAddr(text, label) {
+  const t = text.trim();
+  if (t === '') throw new HlasmSyntax(`${label} is missing`);
+  if (REG.test(t)) return t;
+  try {
+    parseAddress(t);
+  } catch (e) {
+    throw new HlasmSyntax(`${label} is not a valid address: ${e.message}`);
+  }
+  return t;
+}
+
+function parseLen(text, label) {
+  const t = text.trim();
+  if (t === '') throw new HlasmSyntax(`${label} is missing`);
+  if (t === "'S'") return t;
+  try {
+    parseExpression(t);
+  } catch (e) {
+    throw new HlasmSyntax(`${label} is not a valid length: ${e.message}`);
+  }
+  return t;
+}
+
+function parseMf(text) {
+  const t = text.trim();
+  if (!MF_VAL.test(t)) throw new HlasmSyntax(`MF= value ${t} is not L, (E,addr) or (M,addr)`);
+  return t;
+}
+
+function parseGet(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length > 2) throw new HlasmSyntax('GET takes at most 2 positional operands');
+  if (positional.length === 0) throw new HlasmSyntax('GET requires a dcb address');
+  
+  const dcb = parseAddr(positional[0], 'dcb address');
+  const area = positional.length > 1 ? parseAddr(positional[1], 'area address') : null;
+  
+  const node = { kind: 'GET', dcb, area };
+  const allowed = new Set(['TYPE', 'MF']);
+  for (const [k, v] of keywords) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k} in GET`);
+    if (k === 'TYPE') {
+      if (v.trim().toUpperCase() !== 'P') throw new HlasmSyntax('GET TYPE= must be P');
+      node.type = v;
+    } else if (k === 'MF') {
+      node.mf = parseMf(v);
+    }
+  }
+  return node;
+}
+
+function parsePut(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length > 2) throw new HlasmSyntax('PUT takes at most 2 positional operands');
+  if (positional.length === 0) throw new HlasmSyntax('PUT requires a dcb address');
+  
+  const dcb = parseAddr(positional[0], 'dcb address');
+  const area = positional.length > 1 ? parseAddr(positional[1], 'area address') : null;
+  
+  const node = { kind: 'PUT', dcb, area };
+  const allowed = new Set(['MF']);
+  for (const [k, v] of keywords) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k} in PUT`);
+    if (k === 'MF') {
+      node.mf = parseMf(v);
+    }
+  }
+  return node;
+}
+
+function parseRead(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length < 4) throw new HlasmSyntax('READ requires decb, type, dcb, and area');
+  if (positional.length > 5) throw new HlasmSyntax('READ takes at most 5 positional operands');
+  
+  const decb = positional[0].trim();
+  if (!NAME.test(decb)) throw new HlasmSyntax('READ decb name is not a valid symbol');
+  
+  const type = positional[1].trim().toUpperCase();
+  if (!['SF', 'SB', 'SF64', 'SF64P'].includes(type)) throw new HlasmSyntax(`READ type ${type} is not SF, SB, SF64, or SF64P`);
+  
+  const dcb = parseAddr(positional[2], 'dcb address');
+  const area = parseAddr(positional[3], 'area address');
+  const length = positional.length > 4 ? parseLen(positional[4], 'length') : null;
+  
+  const node = { kind: 'READ', decb, type, dcb, area, length, keywords: {} };
+  const allowed = new Set(['MF']);
+  for (const [k, v] of keywords) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k} in READ`);
+    if (k === 'MF') {
+      node.mf = parseMf(v);
+      node.keywords.MF = v;
+    }
+  }
+  return node;
+}
+
+function parseWrite(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length < 4) throw new HlasmSyntax('WRITE requires decb, type, dcb, and area');
+  if (positional.length > 5) throw new HlasmSyntax('WRITE takes at most 5 positional operands');
+  
+  const decb = positional[0].trim();
+  if (!NAME.test(decb)) throw new HlasmSyntax('WRITE decb name is not a valid symbol');
+  
+  const type = positional[1].trim().toUpperCase();
+  if (!['SF', 'SF64', 'SF64P'].includes(type)) throw new HlasmSyntax(`WRITE type ${type} is not SF, SF64, or SF64P`);
+  
+  const dcb = parseAddr(positional[2], 'dcb address');
+  const area = parseAddr(positional[3], 'area address');
+  const length = positional.length > 4 ? parseLen(positional[4], 'length') : null;
+  
+  const node = { kind: 'WRITE', decb, type, dcb, area, length, keywords: {} };
+  const allowed = new Set(['MF']);
+  for (const [k, v] of keywords) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k} in WRITE`);
+    if (k === 'MF') {
+      node.mf = parseMf(v);
+      node.keywords.MF = v;
+    }
+  }
+  return node;
+}
+
+export const parsers = {
+  GET: parseGet,
+  PUT: parsePut,
+  READ: parseRead,
+  WRITE: parseWrite
+};

package/lib/hlasm/macro/le.mjs

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the Language Environment prolog, epilog and mapping macros.
+
+import { HlasmSyntax } from '../operands.mjs';
+
+const CEEENTRY_KW = new Set(['PPA', 'AUTO', 'NAB', 'MAIN', 'ENCLAVE', 'EXECOPS', 'PARMREG', 'EXPORT', 'BASE', 'PLIST', 'RMODE', 'AMODE', 'STKPROT']);
+const CEETERM_KW = new Set(['RC', 'MODIFIER', 'MF']);
+const CEEPPA_KW = new Set(['LIBRARY', 'PPA2', 'EXTPROC', 'TSTAMP', 'PEP', 'INSTOP', 'EXITDSA', 'OWNEXM', 'EPNAME', 'VER', 'REL', 'MOD', 'DSA', 'SERVICE', 'VRSMASK', 'VRSLOCR', 'STKPROT']);
+
+function checkKeywords(ops, allowed, op) {
+  const keywords = {};
+  for (const [k, v] of ops.keywords) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`${op} does not take keyword ${k}`);
+    keywords[k] = v;
+  }
+  return keywords;
+}
+
+function parseCEEENTRY(st, ops) {
+  if (ops.positional.length > 0) throw new HlasmSyntax('CEEENTRY takes no positional operands');
+  const keywords = checkKeywords(ops, CEEENTRY_KW, 'CEEENTRY');
+  return { kind: 'CEEENTRY', name: st.name, main: keywords.MAIN || null, ppa: keywords.PPA || null, keywords };
+}
+
+function parseCEETERM(st, ops) {
+  if (ops.positional.length > 0) throw new HlasmSyntax('CEETERM takes no positional operands');
+  const keywords = checkKeywords(ops, CEETERM_KW, 'CEETERM');
+  return { kind: 'CEETERM', rc: keywords.RC || null, keywords };
+}
+
+function parseCEEPPA(st, ops) {
+  if (ops.positional.length > 1) throw new HlasmSyntax('CEEPPA takes no positional operands');
+  const keywords = checkKeywords(ops, CEEPPA_KW, 'CEEPPA');
+  return { kind: 'CEEPPA', name: st.name, keywords };
+}
+
+function parseCEECAA(st, ops) {
+  if (ops.positional.length > 1 || ops.keywords.size > 0) throw new HlasmSyntax('CEECAA takes no operands');
+  return { kind: 'CEECAA', keywords: {} };
+}
+
+function parseCEEDSA(st, ops) {
+  if (ops.positional.length > 1 || ops.keywords.size > 0) throw new HlasmSyntax('CEEDSA takes no operands');
+  return { kind: 'CEEDSA', keywords: {} };
+}
+
+export const parsers = {
+  CEEENTRY: parseCEEENTRY,
+  CEETERM: parseCEETERM,
+  CEEPPA: parseCEEPPA,
+  CEECAA: parseCEECAA,
+  CEEDSA: parseCEEDSA
+};

package/lib/hlasm/macro/linkage.mjs

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the z/OS linkage macros CALL, SAVE, and RETURN.
+import { HlasmSyntax, NAME } from '../operands.mjs';
+
+const CALL_KW = new Set(['ID', 'LINKINST', 'PLIST4', 'PLIST8', 'PLIST8ARALETS', 'PARAM64', 'MF']);
+const RETURN_KW = new Set(['RC', 'RETREGS']);
+
+function parseCall(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length < 1 || positional.length > 3) {
+    throw new HlasmSyntax(`CALL expects 1 to 3 positional operands, got ${positional.length}`);
+  }
+  const entryRaw = positional[0].trim();
+  let entry = null;
+  let register = null;
+  const regMatch = /^\((\d+)\)$/.exec(entryRaw);
+  // The list form (MF=L) builds only the parameter list, so it names no entry.
+  const listForm = /^L$/i.test(String(keywords.get('MF') || '').trim());
+  if (regMatch) {
+    register = entryRaw;
+  } else if (NAME.test(entryRaw)) {
+    entry = entryRaw;
+  } else if (!(entryRaw === '' && listForm)) {
+    throw new HlasmSyntax(`CALL entry operand '${entryRaw}' is not a valid name or register`);
+  }
+
+  let params = [];
+  if (positional.length >= 2) {
+    const paramsRaw = positional[1].trim();
+    if (paramsRaw.startsWith('(') && paramsRaw.endsWith(')')) {
+      const inner = paramsRaw.slice(1, -1).trim();
+      if (inner) {
+        params = inner.split(',').map(s => s.trim());
+      }
+    }
+  }
+
+  const node = { kind: 'CALL', entry, register, params, vl: false, keywords: {} };
+  if (positional.length === 3) {
+    const vlRaw = positional[2].trim().toUpperCase();
+    if (vlRaw !== 'VL') {
+      throw new HlasmSyntax('CALL third positional operand must be VL');
+    }
+    node.vl = true;
+    node.keywords.VL = positional[2];
+  }
+  for (const [k, v] of keywords) {
+    if (k === 'VL') {
+      node.vl = true;
+      node.keywords[k] = v;
+    } else if (CALL_KW.has(k)) {
+      node.keywords[k] = v;
+    } else {
+      throw new HlasmSyntax(`CALL does not accept keyword ${k}`);
+    }
+  }
+  return node;
+}
+
+function parseSave(st, ops) {
+  const { positional, keywords } = ops;
+  if (keywords.size > 0) {
+    throw new HlasmSyntax('SAVE does not accept keywords');
+  }
+  if (positional.length < 1 || positional.length > 3) {
+    throw new HlasmSyntax(`SAVE expects 1 to 3 positional operands, got ${positional.length}`);
+  }
+
+  const regRaw = positional[0].trim();
+  if (!regRaw.startsWith('(') || !regRaw.endsWith(')')) {
+    throw new HlasmSyntax('SAVE first operand must be a parenthesized register list');
+  }
+  const inner = regRaw.slice(1, -1).trim();
+  const registers = inner ? inner.split(',').map(s => s.trim()) : [];
+
+  let t = false;
+  let id = null;
+  let idx = 1;
+  // The second slot is T or empty: SAVE (14,12),,* omits T and names the identifier.
+  if (idx < positional.length) {
+    const next = positional[idx].trim().toUpperCase();
+    if (next === 'T' || next === '') {
+      t = next === 'T';
+      idx++;
+    }
+  }
+  if (idx < positional.length) {
+    id = positional[idx].trim();
+    idx++;
+  }
+  if (idx < positional.length) {
+    throw new HlasmSyntax(`SAVE has too many positional operands`);
+  }
+
+  return { kind: 'SAVE', registers, t, id };
+}
+
+function parseReturn(st, ops) {
+  const { positional, keywords } = ops;
+  if (positional.length > 2) {
+    throw new HlasmSyntax(`RETURN expects at most 2 positional operands, got ${positional.length}`);
+  }
+
+  let registers = [];
+  let t = false;
+  if (positional.length > 0) {
+    const regRaw = positional[0].trim();
+    if (regRaw.startsWith('(') && regRaw.endsWith(')')) {
+      const inner = regRaw.slice(1, -1).trim();
+      if (inner) {
+        registers = inner.split(',').map(s => s.trim());
+      }
+    } else {
+      throw new HlasmSyntax('RETURN first operand must be a parenthesized register list');
+    }
+  }
+  if (positional.length > 1) {
+    const next = positional[1].trim().toUpperCase();
+    if (next === 'T') {
+      t = true;
+    } else if (next !== '') {
+      throw new HlasmSyntax('RETURN second positional operand must be T or empty');
+    }
+  }
+
+  const node = { kind: 'RETURN', registers, t, rc: null, keywords: {} };
+  for (const [k, v] of keywords) {
+    if (!RETURN_KW.has(k)) {
+      throw new HlasmSyntax(`RETURN does not accept keyword ${k}`);
+    }
+    if (k === 'RC') {
+      node.rc = v;
+    }
+    node.keywords[k] = v;
+  }
+  return node;
+}
+
+export const parsers = {
+  CALL: parseCall,
+  SAVE: parseSave,
+  RETURN: parseReturn
+};

package/lib/hlasm/macro/operator.mjs

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parser for the z/OS operator-communication macros WTO and WTOR in their standard form.
+import { HlasmSyntax } from '../operands.mjs';
+
+const WTO_KW = new Set(['TEXT', 'ROUTCDE', 'DESC', 'MCSFLAG', 'MSGTYP', 'CART', 'CONSID', 'CONSNAME', 'KEY', 'TOKEN', 'MF']);
+const WTOR_KW = new Set(['TEXT', 'ROUTCDE', 'MCSFLAG', 'DESC', 'MSGTYP', 'RPLYISUR', 'CART', 'CONSID', 'CONSNAME', 'KEY', 'TOKEN', 'MF']);
+
+function parseWTO(st, ops) {
+  const { positional, keywords } = ops;
+  const kw = {};
+  for (const [k, v] of keywords) {
+    if (!WTO_KW.has(k)) throw new HlasmSyntax(`WTO: unknown keyword ${k}`);
+    kw[k] = v;
+  }
+  let text = null;
+  if (positional.length > 0) {
+    const first = positional[0].trim();
+    if (first.startsWith("'") || first.startsWith('(')) {
+      text = first;
+    } else {
+      throw new HlasmSyntax('WTO: first positional operand must be a quoted string or a parenthesised list');
+    }
+  }
+  if (positional.length > 1) {
+    throw new HlasmSyntax(`WTO: too many positional operands (${positional.length})`);
+  }
+  return { kind: 'WTO', text, keywords: kw };
+}
+
+function parseWTOR(st, ops) {
+  const { positional, keywords } = ops;
+  const kw = {};
+  for (const [k, v] of keywords) {
+    if (!WTOR_KW.has(k)) throw new HlasmSyntax(`WTOR: unknown keyword ${k}`);
+    kw[k] = v;
+  }
+  let text = null;
+  let reply = null;
+  let replyLength = null;
+  let ecb = null;
+
+  if (positional.length === 0) {
+    if (!keywords.has('TEXT')) {
+      throw new HlasmSyntax('WTOR: no positional operands and no TEXT= keyword');
+    }
+  } else if (positional.length === 4) {
+    const msg = positional[0].trim();
+    if (msg.startsWith("'") || msg.startsWith('(')) {
+      text = msg;
+    } else {
+      throw new HlasmSyntax('WTOR: first positional operand must be a quoted string or a parenthesised list');
+    }
+    reply = positional[1];
+    replyLength = positional[2];
+    ecb = positional[3];
+  } else {
+    throw new HlasmSyntax(`WTOR: expected 4 positional operands, got ${positional.length}`);
+  }
+
+  return { kind: 'WTOR', text, reply, replyLength, ecb, keywords: kw };
+}
+
+export const parsers = {
+  WTO: parseWTO,
+  WTOR: parseWTOR
+};

package/lib/hlasm/macro/program.mjs

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for z/OS program-management macros: LINK, XCTL, LOAD, ATTACH.
+import { HlasmSyntax, NAME } from '../operands.mjs';
+
+const ADDR = /^(?:\(\d{1,2}\)|[A-Z$#@_][A-Z0-9$#@_]*|[\w$#@_]+(?:\s*[-+*/]\s*[\w$#@_]+)*)$/i;
+const NUM_OR_ADDR = /^(?:\d+|\(\d{1,2}\)|[A-Z$#@_][A-Z0-9$#@_]*|[\w$#@_]+(?:\s*[-+*/]\s*[\w$#@_]+)*)$/i;
+const YES_NO = /^(?:YES|NO)$/i;
+
+function parseLink(st, ops) {
+  const kw = ops.keywords;
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'PARAM', 'VL', 'ID', 'ERRET', 'LSEARCH']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  if (ops.positional.length > 0) throw new HlasmSyntax('unexpected positional operand');
+  const epKeys = ['EP', 'EPLOC', 'DE'].filter(k => kw.has(k));
+  if (epKeys.length > 1) throw new HlasmSyntax('EP, EPLOC, and DE are mutually exclusive');
+  if (epKeys.length === 0) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  const ep = kw.has('EP') ? kw.get('EP').trim().toUpperCase() : null;
+  const eploc = kw.has('EPLOC') ? kw.get('EPLOC') : null;
+  const de = kw.has('DE') ? kw.get('DE') : null;
+  if (ep && !NAME.test(ep)) throw new HlasmSyntax('invalid EP name');
+  if (eploc && !ADDR.test(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !ADDR.test(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !ADDR.test(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('ERRET') && !ADDR.test(kw.get('ERRET').trim())) throw new HlasmSyntax('invalid ERRET address');
+  if (kw.has('LSEARCH') && !YES_NO.test(kw.get('LSEARCH').trim())) throw new HlasmSyntax('invalid LSEARCH value');
+  if (kw.has('VL') && !/^\d+$/.test(kw.get('VL').trim())) throw new HlasmSyntax('invalid VL value');
+  if (kw.has('ID') && !/^\d+$/.test(kw.get('ID').trim())) throw new HlasmSyntax('invalid ID value');
+  let param = null;
+  if (kw.has('PARAM')) {
+    const p = kw.get('PARAM').trim();
+    if (p.startsWith('(') && p.endsWith(')')) {
+      const inner = p.slice(1, -1).trim();
+      if (inner !== '') {
+        const parts = inner.split(',').map(s => s.trim());
+        for (const part of parts) {
+          if (!ADDR.test(part)) throw new HlasmSyntax('invalid PARAM address');
+        }
+      }
+    } else if (!ADDR.test(p)) {
+      throw new HlasmSyntax('invalid PARAM address');
+    }
+    param = p;
+  }
+  return { kind: 'LINK', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, param, keywords: Object.fromEntries(kw) };
+}
+
+function parseXctl(st, ops) {
+  const kw = ops.keywords;
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'LSEARCH']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  // The registers to restore before control passes: (reg) or (reg1,reg2), numbers or EQU symbols.
+  if (ops.positional.length > 1) throw new HlasmSyntax('too many positional operands');
+  if (ops.positional.length === 1 && ops.positional[0].trim() !== '' && !/^\(\s*[A-Z0-9$#@_]+\s*(,\s*[A-Z0-9$#@_]+\s*)?\)$/i.test(ops.positional[0].trim())) throw new HlasmSyntax('invalid register list');
+  const epKeys = ['EP', 'EPLOC', 'DE'].filter(k => kw.has(k));
+  if (epKeys.length > 1) throw new HlasmSyntax('EP, EPLOC, and DE are mutually exclusive');
+  if (epKeys.length === 0) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  const ep = kw.has('EP') ? kw.get('EP').trim().toUpperCase() : null;
+  const eploc = kw.has('EPLOC') ? kw.get('EPLOC') : null;
+  const de = kw.has('DE') ? kw.get('DE') : null;
+  if (ep && !NAME.test(ep)) throw new HlasmSyntax('invalid EP name');
+  if (eploc && !ADDR.test(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !ADDR.test(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !ADDR.test(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('LSEARCH') && !YES_NO.test(kw.get('LSEARCH').trim())) throw new HlasmSyntax('invalid LSEARCH value');
+  return { kind: 'XCTL', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, keywords: Object.fromEntries(kw) };
+}
+
+function parseLoad(st, ops) {
+  const kw = ops.keywords;
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'ERRET', 'LSEARCH', 'LOADPT', 'LOADPT64', 'EXTINFO', 'RELATED']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  if (ops.positional.length > 0) throw new HlasmSyntax('unexpected positional operand');
+  const epKeys = ['EP', 'EPLOC', 'DE'].filter(k => kw.has(k));
+  if (epKeys.length > 1) throw new HlasmSyntax('EP, EPLOC, and DE are mutually exclusive');
+  if (epKeys.length === 0) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  const ep = kw.has('EP') ? kw.get('EP').trim().toUpperCase() : null;
+  const eploc = kw.has('EPLOC') ? kw.get('EPLOC') : null;
+  const de = kw.has('DE') ? kw.get('DE') : null;
+  if (ep && !NAME.test(ep)) throw new HlasmSyntax('invalid EP name');
+  if (eploc && !ADDR.test(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !ADDR.test(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !ADDR.test(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('ERRET') && !ADDR.test(kw.get('ERRET').trim())) throw new HlasmSyntax('invalid ERRET address');
+  if (kw.has('LSEARCH') && !YES_NO.test(kw.get('LSEARCH').trim())) throw new HlasmSyntax('invalid LSEARCH value');
+  if (kw.has('LOADPT') && !ADDR.test(kw.get('LOADPT').trim())) throw new HlasmSyntax('invalid LOADPT address');
+  if (kw.has('LOADPT64') && !ADDR.test(kw.get('LOADPT64').trim())) throw new HlasmSyntax('invalid LOADPT64 address');
+  if (kw.has('EXTINFO') && !ADDR.test(kw.get('EXTINFO').trim())) throw new HlasmSyntax('invalid EXTINFO address');
+  return { kind: 'LOAD', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, keywords: Object.fromEntries(kw) };
+}
+
+function parseAttach(st, ops) {
+  const kw = ops.keywords;
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'LPMOD', 'DPMOD', 'PARAM', 'VL', 'ECB', 'ETXR', 'GSPV', 'GSPL', 'SHSPV', 'SHSPL', 'SZERO', 'TASKLIB', 'STAI', 'ESTAI', 'PURGE', 'ASYNCH', 'TERM', 'ALCOPY', 'RELATED']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  if (ops.positional.length > 0) throw new HlasmSyntax('unexpected positional operand');
+  const epKeys = ['EP', 'EPLOC', 'DE'].filter(k => kw.has(k));
+  if (epKeys.length > 1) throw new HlasmSyntax('EP, EPLOC, and DE are mutually exclusive');
+  if (epKeys.length === 0) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  const ep = kw.has('EP') ? kw.get('EP').trim().toUpperCase() : null;
+  const eploc = kw.has('EPLOC') ? kw.get('EPLOC') : null;
+  const de = kw.has('DE') ? kw.get('DE') : null;
+  if (ep && !NAME.test(ep)) throw new HlasmSyntax('invalid EP name');
+  if (eploc && !ADDR.test(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !ADDR.test(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !ADDR.test(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('LPMOD') && !NUM_OR_ADDR.test(kw.get('LPMOD').trim())) throw new HlasmSyntax('invalid LPMOD value');
+  if (kw.has('DPMOD') && !NUM_OR_ADDR.test(kw.get('DPMOD').trim())) throw new HlasmSyntax('invalid DPMOD value');
+  if (kw.has('VL') && !/^\d+$/.test(kw.get('VL').trim())) throw new HlasmSyntax('invalid VL value');
+  if (kw.has('ECB') && !ADDR.test(kw.get('ECB').trim())) throw new HlasmSyntax('invalid ECB address');
+  if (kw.has('ETXR') && !ADDR.test(kw.get('ETXR').trim())) throw new HlasmSyntax('invalid ETXR address');
+  if (kw.has('GSPV') && !NUM_OR_ADDR.test(kw.get('GSPV').trim())) throw new HlasmSyntax('invalid GSPV value');
+  if (kw.has('GSPL') && !ADDR.test(kw.get('GSPL').trim())) throw new HlasmSyntax('invalid GSPL address');
+  if (kw.has('SHSPV') && !NUM_OR_ADDR.test(kw.get('SHSPV').trim())) throw new HlasmSyntax('invalid SHSPV value');
+  if (kw.has('SHSPL') && !ADDR.test(kw.get('SHSPL').trim())) throw new HlasmSyntax('invalid SHSPL address');
+  if (kw.has('SZERO') && !YES_NO.test(kw.get('SZERO').trim())) throw new HlasmSyntax('invalid SZERO value');
+  if (kw.has('TASKLIB') && !ADDR.test(kw.get('TASKLIB').trim())) throw new HlasmSyntax('invalid TASKLIB address');
+  if (kw.has('STAI') && !ADDR.test(kw.get('STAI').trim())) throw new HlasmSyntax('invalid STAI address');
+  if (kw.has('ESTAI') && !ADDR.test(kw.get('ESTAI').trim())) throw new HlasmSyntax('invalid ESTAI address');
+  if (kw.has('PURGE') && !/^(?:QUIESCE|NONE|HALT)$/i.test(kw.get('PURGE').trim())) throw new HlasmSyntax('invalid PURGE value');
+  if (kw.has('ASYNCH') && !YES_NO.test(kw.get('ASYNCH').trim())) throw new HlasmSyntax('invalid ASYNCH value');
+  if (kw.has('TERM') && !YES_NO.test(kw.get('TERM').trim())) throw new HlasmSyntax('invalid TERM value');
+  if (kw.has('ALCOPY') && !YES_NO.test(kw.get('ALCOPY').trim())) throw new HlasmSyntax('invalid ALCOPY value');
+  let param = null;
+  if (kw.has('PARAM')) {
+    const p = kw.get('PARAM').trim();
+    if (p.startsWith('(') && p.endsWith(')')) {
+      const inner = p.slice(1, -1).trim();
+      if (inner !== '') {
+        const parts = inner.split(',').map(s => s.trim());
+        for (const part of parts) {
+          if (!ADDR.test(part)) throw new HlasmSyntax('invalid PARAM address');
+        }
+      }
+    } else if (!ADDR.test(p)) {
+      throw new HlasmSyntax('invalid PARAM address');
+    }
+    param = p;
+  }
+  return { kind: 'ATTACH', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, param, keywords: Object.fromEntries(kw) };
+}
+
+export const parsers = Object.freeze({ LINK: parseLink, XCTL: parseXctl, LOAD: parseLoad, ATTACH: parseAttach });

package/lib/hlasm/macro/recovery.mjs

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the z/OS recovery and dump macros: ESTAE, ESPIE, ABEND, SNAP.
+import { HlasmSyntax } from '../operands.mjs';
+
+const ESTAE_KW = new Set(['PARAM', 'XCTL', 'PURGE', 'ASYNCH', 'TERM', 'ASCENV', 'RECORD', 'RELATED', 'MF']);
+const ESPIE_KW = new Set(['PKM', 'MF']);
+const ABEND_KW = new Set(['REASON', 'DUMPOPT', 'DUMPOPX', 'MF']);
+const SNAP_KW = new Set(['DCB', 'TCB', 'ID', 'SDATA', 'PDATA', 'STORAGE', 'LIST', 'STRHDR', 'SUBPLST', 'DSPSTOR', 'MF']);
+
+function checkKw(kw, allowed, op) {
+  for (const k of kw.keys()) {
+    if (!allowed.has(k)) throw new HlasmSyntax(`${op}: unknown keyword ${k}`);
+  }
+}
+
+function parseEstae(st, ops) {
+  const { positional, keywords } = ops;
+  checkKw(keywords, ESTAE_KW, 'ESTAE');
+  if (positional.length < 1 || positional.length > 3) {
+    throw new HlasmSyntax('ESTAE: expected 1 to 3 positional operands');
+  }
+  const exit = positional[0];
+  for (let i = 1; i < positional.length; i++) {
+    const p = positional[i].toUpperCase();
+    if (p !== 'CT' && p !== 'OV') {
+      throw new HlasmSyntax(`ESTAE: unexpected positional operand ${positional[i]}`);
+    }
+  }
+  return { kind: 'ESTAE', exit, keywords: Object.fromEntries(keywords) };
+}
+
+function parseEspie(st, ops) {
+  const { positional, keywords } = ops;
+  checkKw(keywords, ESPIE_KW, 'ESPIE');
+  if (positional.length < 1) throw new HlasmSyntax('ESPIE: missing action');
+  const action = positional[0].toUpperCase();
+  if (action !== 'SET' && action !== 'RESET' && action !== 'TEST') {
+    throw new HlasmSyntax(`ESPIE: invalid action ${positional[0]}`);
+  }
+  const rest = positional.slice(1);
+  if (action === 'SET') {
+    if (rest.length > 2) throw new HlasmSyntax('ESPIE SET: too many operands');
+  } else if (rest.length > 0) {
+    throw new HlasmSyntax(`ESPIE ${action}: no operands expected`);
+  }
+  return { kind: 'ESPIE', action, operands: rest, keywords: Object.fromEntries(keywords) };
+}
+
+function parseAbend(st, ops) {
+  const { positional, keywords } = ops;
+  checkKw(keywords, ABEND_KW, 'ABEND');
+  if (positional.length < 1 || positional.length > 4) {
+    throw new HlasmSyntax('ABEND: expected 1 to 4 positional operands');
+  }
+  const code = positional[0];
+  let dump = false, step = false;
+  for (let i = 1; i < positional.length; i++) {
+    const p = positional[i].toUpperCase();
+    if (p === '') continue;
+    if (p === 'DUMP') dump = true;
+    else if (p === 'STEP') step = true;
+    else if (p === 'USER' || p === 'SYSTEM') continue;
+    else throw new HlasmSyntax(`ABEND: unexpected positional operand ${positional[i]}`);
+  }
+  return { kind: 'ABEND', code, dump, step, keywords: Object.fromEntries(keywords) };
+}
+
+function parseSnap(st, ops) {
+  const { keywords } = ops;
+  checkKw(keywords, SNAP_KW, 'SNAP');
+  const dcb = keywords.has('DCB') ? keywords.get('DCB') : null;
+  return { kind: 'SNAP', dcb, keywords: Object.fromEntries(keywords) };
+}
+
+export const parsers = {
+  ESTAE: parseEstae,
+  ESPIE: parseEspie,
+  ABEND: parseAbend,
+  SNAP: parseSnap
+};