@portll/cobolwork 0.5.0 → 0.7.0

package/lib/hlasm/macro/io.mjs

@@ -0,0 +1,162 @@
+// 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';
+import { MVS38_BTAM_TYPES, MVS38_VTAM_RPL_KEYWORDS, mvs38Form } from '../mvs38.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;
+}
+
+// VSAM's GET and PUT name only a request parameter list (z/OS 3.1 DFSMS Macro Instructions for
+// Data Sets, GET and PUT for VSAM): RPL=address, register notation from 1 to 12 included.
+function vsamRequest(macro, ops) {
+  const { positional, keywords } = ops;
+  if (positional.some((p) => p.trim() !== '')) throw new HlasmSyntax(`${macro} RPL= takes no positional operands`);
+  for (const k of keywords.keys()) if (k !== 'RPL') throw new HlasmSyntax(`unknown keyword ${k} in ${macro} RPL=`);
+  return { kind: macro, rpl: parseAddr(keywords.get('RPL'), 'RPL address') };
+}
+
+function parseGet(st, ops) {
+  if (ops.keywords.has('RPL')) return vsamRequest('GET', 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) {
+  if (ops.keywords.has('RPL')) return vsamRequest('PUT', 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;
+}
+
+// READ and WRITE name a data event control block, a type, then by position the dcb, area, length,
+// key and block addresses and a next address (z/OS 3.1 DFSMS Macro Instructions for Data Sets: BSAM
+// and BPAM, BDAM, BISAM, and BSAM creating a direct data set). The standard form names the DECB and
+// needs the dcb and area; the list form (MF=L) may leave any operand after the type to the execute
+// form, and the execute form (MF=E) names an existing DECB by address and may omit them too.
+const BLOCK_TYPES = {
+  READ: /^(?:SF|SB|SF64P?|K|KU|D[IK][FX]?(?:R|RU)?)$/,
+  WRITE: /^(?:SF|SFR|SD|SZ|SF64P?|K|KN|DAF?|D[IK][FX]?)$/,
+};
+const BLOCK_FIELDS = ['dcb', 'area', 'length', 'key', 'block', 'next'];
+const REGISTER = /^\(\s*[A-Z0-9$#@_]+\s*\)$/i;
+
+function blockField(field, raw) {
+  if (raw === "'S'" || (field === 'key' && raw === '0') || REGISTER.test(raw)) return raw;
+  return field === 'length' ? parseLen(raw, 'length') : parseAddr(raw, `${field} address`);
+}
+
+// VTAM's basic-mode READ and WRITE: RPL= and the request parameter list fields, no positional operands.
+function vtamBasicRequest(macro, ops, opts) {
+  const node = { kind: macro };
+  mvs38Form(opts, node, macro, 'RPL=');
+  if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax(`${macro} RPL= takes no positional operands`);
+  for (const k of ops.keywords.keys()) if (!MVS38_VTAM_RPL_KEYWORDS.has(k)) throw new HlasmSyntax(`unknown keyword ${k} in ${macro} RPL=`);
+  return { ...node, rpl: parseAddr(ops.keywords.get('RPL'), 'RPL address'), keywords: Object.fromEntries(ops.keywords) };
+}
+
+function blockRequest(macro, st, ops, opts) {
+  const { positional, keywords } = ops;
+  if (keywords.has('RPL')) return vtamBasicRequest(macro, ops, opts);
+  for (const k of keywords.keys()) if (k !== 'MF') throw new HlasmSyntax(`unknown keyword ${k} in ${macro}`);
+  const legacy = {};
+  let mf = keywords.has('MF') ? keywords.get('MF').trim().toUpperCase() : null;
+  let list = null;
+  const remote = mf && /^\(\s*E\s*,(.+)\)$/.exec(mf);
+  if (remote) {
+    mvs38Form(opts, legacy, macro, 'MF=(E,addr)');
+    list = parseAddr(remote[1], 'MF list address');
+    mf = 'E';
+  }
+  if (mf !== null && mf !== 'L' && mf !== 'E') throw new HlasmSyntax(`${macro} MF= value ${mf} is not L or E`);
+  if (positional.length < 2) throw new HlasmSyntax(`${macro} requires a decb and a type`);
+  if (positional.length > 2 + BLOCK_FIELDS.length) throw new HlasmSyntax(`${macro} takes at most ${2 + BLOCK_FIELDS.length} positional operands`);
+  const decb = positional[0].trim();
+  if (mf === 'E' ? decb === '' || !(REGISTER.test(decb) || parseAddr(decb, 'decb address')) : !NAME.test(decb)) {
+    throw new HlasmSyntax(`${macro} decb name is not a valid symbol`);
+  }
+  const type = positional[1].trim().toUpperCase();
+  if (MVS38_BTAM_TYPES[macro].has(type) && (type !== 'T' || mf === 'E')) mvs38Form(opts, legacy, macro, `type ${type}`);
+  else if (!BLOCK_TYPES[macro].test(type)) throw new HlasmSyntax(`${macro} type ${type} is not one the access methods define`);
+  const node = { kind: macro, ...legacy, decb, type, mf, ...(list ? { list } : {}), keywords: Object.fromEntries(keywords) };
+  BLOCK_FIELDS.forEach((field, i) => {
+    const raw = (positional[i + 2] ?? '').trim();
+    if (raw === '') {
+      if (!mf && (field === 'dcb' || field === 'area')) throw new HlasmSyntax(`${field} address is missing`);
+      node[field] = null;
+    } else {
+      node[field] = blockField(field, raw);
+    }
+  });
+  return node;
+}
+
+const parseRead = (st, ops, opts) => blockRequest('READ', st, ops, opts);
+const parseWrite = (st, ops, opts) => blockRequest('WRITE', st, ops, opts);
+
+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.some((p) => p.trim() !== '')) 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.some((p) => p.trim() !== '')) 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,77 @@
+// 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';
+
+// The standard, list and execute forms, authorized keywords included (z/OS 3.1 MVS Programming:
+// Authorized Assembler Services Reference, Volume 4, WTO and WTOR).
+const WTO_KW = new Set(['TEXT', 'ROUTCDE', 'DESC', 'MCSFLAG', 'MSGTYP', 'CART', 'CONSID', 'CONSNAME', 'KEY', 'TOKEN', 'MF',
+  'AREAID', 'CONNECT', 'JOBID', 'JOBNAME', 'LINKAGE', 'SYNCH', 'SYSNAME', 'WSPARM']);
+const WTOR_KW = new Set(['TEXT', 'ROUTCDE', 'MCSFLAG', 'DESC', 'MSGTYP', 'RPLYISUR', 'CART', 'CONSID', 'CONSNAME', 'KEY', 'TOKEN', 'MF',
+  'JOBID', 'JOBNAME', 'LINKAGE', 'SYNCH', 'SYSNAME']);
+const isMessage = (text) => text.startsWith("'") || text.startsWith('(');
+
+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;
+  }
+  // A message is one quoted string, or the lines of a multiple-line message, each ('text',type);
+  // the execute form (MF=(E,addr)) may leave it to the list form.
+  const lines = positional.map((p) => p.trim());
+  const execute = /^\(\s*E\s*,/i.test(String(keywords.get('MF') || ''));
+  if (lines.length === 1 && lines[0] === '' && execute) return { kind: 'WTO', text: null, keywords: kw };
+  for (const line of lines) {
+    if (!isMessage(line)) throw new HlasmSyntax('WTO: first positional operand must be a quoted string or a parenthesised list');
+  }
+  if (lines.length > 1 && !lines.every((l) => l.startsWith('('))) {
+    throw new HlasmSyntax(`WTO: too many positional operands (${lines.length})`);
+  }
+  return { kind: 'WTO', text: lines.length ? lines.join(',') : null, keywords: kw };
+}
+
+function parseWTOR(st, ops) {
+  const { keywords } = ops;
+  const positional = [...ops.positional];
+  while (positional.length > 4 && positional.at(-1).trim() === '') positional.pop();
+  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;
+
+  // The list form (MF=L) may leave the reply, its length and the ECB to the execute form, and the
+  // execute form (MF=(E,addr)) any operand to the list form.
+  const mf = String(keywords.get('MF') || '').trim();
+  const remote = mf !== '';
+  const execute = /^\(\s*E\s*,/i.test(mf);
+  if (positional.length === 0) {
+    if (!keywords.has('TEXT') && !execute) {
+      throw new HlasmSyntax('WTOR: no positional operands and no TEXT= keyword');
+    }
+  } else if (positional.length === 4 || (remote && positional.length <= 4)) {
+    const msg = positional[0].trim();
+    if (isMessage(msg)) {
+      text = msg;
+    } else if (!(msg === '' && (execute || keywords.has('TEXT')))) {
+      throw new HlasmSyntax('WTOR: first positional operand must be a quoted string or a parenthesised list');
+    }
+    reply = positional[1] ?? null;
+    replyLength = positional[2] ?? null;
+    ecb = positional[3] ?? null;
+  } 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,184 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for z/OS program-management macros: LINK, XCTL, LOAD, ATTACH.
+import { HlasmSyntax, NAME, remoteForm, splitOperands } from '../operands.mjs';
+import { parseAddress } from '../expr.mjs';
+import { MVS38_HIARCHY, MVS38_KEYWORDS, mvs38Form } from '../mvs38.mjs';
+
+// An RX-type or A-type address, a register in parentheses, a literal or an absolute expression, as
+// the macros' operands are written: anything the address reader takes.
+const isAddress = (text) => {
+  const t = String(text).trim();
+  if (t === '') return false;
+  try { parseAddress(t); return true; } catch { return false; }
+};
+const YES_NO = /^(?:YES|NO)$/i;
+
+// STAI= and ESTAI= of ATTACH: an exit address, or (exit addr,parm addr).
+const isExit = (text) => {
+  const t = String(text).trim();
+  if (isAddress(t)) return true;
+  if (!t.startsWith('(') || !t.endsWith(')')) return false;
+  const parts = splitOperands(t.slice(1, -1));
+  return parts.length <= 2 && parts.every(isAddress);
+};
+
+// The list form (SF=L) and the execute form (MF=(E,addr), SF=(E,addr)) of LINK and XCTL (z/OS 3.1
+// MVS Programming: Assembler Services Reference, Volume 2). The list form may leave the entry point
+// to the execute form, and an execute form with SF=(E,addr) may take it from the list.
+function forms(kw, macro) {
+  const sf = kw.has('SF') ? remoteForm(kw.get('SF'), 'SF') : null;
+  const mf = kw.has('MF') ? remoteForm(kw.get('MF'), 'MF') : null;
+  if (mf && mf.form !== 'E') throw new HlasmSyntax(`${macro} takes MF only as (E,addr)`);
+  if (sf && sf.form === 'L' && (mf || kw.has('PARAM'))) throw new HlasmSyntax(`the list form of ${macro} takes no MF or PARAM`);
+  const out = {};
+  if (sf) out.sf = sf.form === 'L' ? 'L' : { form: 'E', list: sf.list };
+  if (mf) out.mf = { form: 'E', list: mf.list };
+  return { out, entryOptional: Boolean(sf) };
+}
+
+// PARAM=(addr,addr,...): an execute form may leave an entry empty, to keep the list form's.
+// A list form (SF=L) may write a keyword with no value, reserving its field for the execute form.
+function written(keywords) {
+  if (!/^L$/i.test(String(keywords.get('SF') || '').trim())) return keywords;
+  return new Map([...keywords].filter(([, v]) => String(v).trim() !== ''));
+}
+
+function parseParam(raw, execute = false) {
+  const p = raw.trim();
+  if (p.startsWith('(') && p.endsWith(')')) {
+    const inner = p.slice(1, -1).trim();
+    if (inner !== '') {
+      for (const part of splitOperands(inner).map(s => s.trim())) {
+        if (part === '' ? !execute : !isAddress(part)) throw new HlasmSyntax('invalid PARAM address');
+      }
+    }
+  } else if (!isAddress(p)) {
+    throw new HlasmSyntax('invalid PARAM address');
+  }
+  return p;
+}
+
+function parseLink(st, ops) {
+  const kw = written(ops.keywords);
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'PARAM', 'VL', 'ID', 'ERRET', 'LSEARCH', 'SF', 'MF']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax('unexpected positional operand');
+  const { out: form, entryOptional } = forms(kw, 'LINK');
+  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 && !entryOptional) 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 && !isAddress(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !isAddress(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !isAddress(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('ERRET') && !isAddress(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');
+  const param = kw.has('PARAM') ? parseParam(kw.get('PARAM'), Boolean(form.mf)) : null;
+  return { kind: 'LINK', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, param, ...form, keywords: Object.fromEntries(kw) };
+}
+
+function parseXctl(st, ops) {
+  const kw = written(ops.keywords);
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'LSEARCH', 'SF', 'MF', 'PARAM', 'VL']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  const { out: form, entryOptional } = forms(kw, 'XCTL');
+  // XCTL builds a parameter list only in its execute form, at MF=(E,addr).
+  if ((kw.has('PARAM') || kw.has('VL')) && !form.mf) throw new HlasmSyntax('XCTL takes PARAM and VL only with MF=(E,addr)');
+  if (kw.has('VL') && !/^\d+$/.test(kw.get('VL').trim())) throw new HlasmSyntax('invalid VL value');
+  // 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 && !entryOptional) 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 && !isAddress(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !isAddress(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !isAddress(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');
+  const param = kw.has('PARAM') ? parseParam(kw.get('PARAM'), true) : null;
+  return { kind: 'XCTL', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, ...(param ? { param } : {}), ...form, keywords: Object.fromEntries(kw) };
+}
+
+function parseLoad(st, ops) {
+  const kw = written(ops.keywords);
+  // The standard, list and execute forms, authorized keywords included (z/OS 3.1 MVS Programming:
+  // Authorized Assembler Services Reference, Volume 3, LOAD).
+  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'ERRET', 'LSEARCH', 'LOADPT', 'LOADPT64', 'EXTINFO', 'RELATED',
+    'ADDR', 'ADDR64', 'ADRNAPF', 'ADRNAPF64', 'ARCHLVL', 'EOM', 'FETCHOPT', 'GLOBAL', 'PLISTVER', 'RMODE', 'SF']);
+  for (const k of kw.keys()) if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax('unexpected positional operand');
+  const { out: form, entryOptional } = forms(kw, 'LOAD');
+  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 && !entryOptional) 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 && !isAddress(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !isAddress(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !isAddress(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('ERRET') && !isAddress(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') && !isAddress(kw.get('LOADPT').trim())) throw new HlasmSyntax('invalid LOADPT address');
+  if (kw.has('LOADPT64') && !isAddress(kw.get('LOADPT64').trim())) throw new HlasmSyntax('invalid LOADPT64 address');
+  if (kw.has('EXTINFO') && !isAddress(kw.get('EXTINFO').trim())) throw new HlasmSyntax('invalid EXTINFO address');
+  return { kind: 'LOAD', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, ...form, keywords: Object.fromEntries(kw) };
+}
+
+function parseAttach(st, ops, opts) {
+  const kw = written(ops.keywords);
+  // The standard, list and execute forms, authorized keywords included (z/OS 3.1 MVS Programming:
+  // Authorized Assembler Services Reference, Volume 1, ATTACH and ATTACHX).
+  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',
+    'ADDRENV', 'ASCENV', 'BYADDRESS', 'DISP', 'JSTCB', 'KEY', 'MF', 'NSHSPL', 'NSHSPV', 'PKM', 'PLIST4', 'PLIST8', 'PLIST8ARALETS', 'PLISTARALETS', 'RSAPF', 'SDWALOC31', 'SF', 'SM', 'SVAREA', 'TCB', 'TID']);
+  const legacy = {};
+  for (const k of kw.keys()) {
+    if (MVS38_KEYWORDS.ATTACH.has(k)) mvs38Form(opts, legacy, 'ATTACH', `${k}=${kw.get(k).trim()}`);
+    else if (!allowed.has(k)) throw new HlasmSyntax(`unknown keyword ${k}`);
+  }
+  if (kw.has('HIARCHY') && !MVS38_HIARCHY.test(kw.get('HIARCHY').trim())) throw new HlasmSyntax('invalid HIARCHY value');
+  if (kw.has('JSCB') && !isAddress(kw.get('JSCB').trim())) throw new HlasmSyntax('invalid JSCB address');
+  if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax('unexpected positional operand');
+  const { out: form, entryOptional } = forms(kw, 'ATTACH');
+  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 && !entryOptional) 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 && !isAddress(eploc.trim())) throw new HlasmSyntax('invalid EPLOC address');
+  if (de && !isAddress(de.trim())) throw new HlasmSyntax('invalid DE address');
+  if (kw.has('DCB') && !isAddress(kw.get('DCB').trim())) throw new HlasmSyntax('invalid DCB address');
+  if (kw.has('LPMOD') && !isAddress(kw.get('LPMOD').trim())) throw new HlasmSyntax('invalid LPMOD value');
+  if (kw.has('DPMOD') && !isAddress(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') && !isAddress(kw.get('ECB').trim())) throw new HlasmSyntax('invalid ECB address');
+  if (kw.has('ETXR') && !isAddress(kw.get('ETXR').trim())) throw new HlasmSyntax('invalid ETXR address');
+  if (kw.has('GSPV') && !isAddress(kw.get('GSPV').trim())) throw new HlasmSyntax('invalid GSPV value');
+  if (kw.has('GSPL') && !isAddress(kw.get('GSPL').trim())) throw new HlasmSyntax('invalid GSPL address');
+  if (kw.has('SHSPV') && !isAddress(kw.get('SHSPV').trim())) throw new HlasmSyntax('invalid SHSPV value');
+  if (kw.has('SHSPL') && !isAddress(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') && !isAddress(kw.get('TASKLIB').trim())) throw new HlasmSyntax('invalid TASKLIB address');
+  if (kw.has('STAI') && !isExit(kw.get('STAI'))) throw new HlasmSyntax('invalid STAI address');
+  if (kw.has('ESTAI') && !isExit(kw.get('ESTAI'))) 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');
+  const param = kw.has('PARAM') ? parseParam(kw.get('PARAM'), Boolean(form.mf)) : null;
+  return { kind: 'ATTACH', ...legacy, ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, param, ...form, keywords: Object.fromEntries(kw) };
+}
+
+export const parsers = Object.freeze({ LINK: parseLink, XCTL: parseXctl, LOAD: parseLoad, ATTACH: parseAttach });