@portll/cobolwork 0.6.0 → 0.7.0

package/lib/hlasm/macro/program.mjs

@@ -1,142 +1,184 @@
 // 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';
+import { HlasmSyntax, NAME, remoteForm, splitOperands } from '../operands.mjs';
+import { parseAddress } from '../expr.mjs';
+import { MVS38_HIARCHY, MVS38_KEYWORDS, mvs38Form } from '../mvs38.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;
+// 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 = ops.keywords;
-  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'PARAM', 'VL', 'ID', 'ERRET', 'LSEARCH']);
+  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.length > 0) throw new HlasmSyntax('unexpected positional operand');
+  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) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  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 && !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 (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');
-  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) };
+  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 = ops.keywords;
-  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'LSEARCH']);
+  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) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  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 && !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 (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');
-  return { kind: 'XCTL', ep, eploc, de, dcb: kw.has('DCB') ? kw.get('DCB') : null, keywords: Object.fromEntries(kw) };
+  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 = ops.keywords;
-  const allowed = new Set(['EP', 'EPLOC', 'DE', 'DCB', 'ERRET', 'LSEARCH', 'LOADPT', 'LOADPT64', 'EXTINFO', 'RELATED']);
+  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.length > 0) throw new HlasmSyntax('unexpected positional operand');
+  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) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  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 && !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 (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') && !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) };
+  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) {
-  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');
+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) throw new HlasmSyntax('missing EP, EPLOC, or DE');
+  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 && !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 (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') && !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('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') && !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('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');
-  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) };
+  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 });

package/lib/hlasm/macro/recovery.mjs

@@ -2,7 +2,10 @@
 // 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']);
+// The standard, list and execute forms, authorized keywords included (z/OS 3.1 MVS Programming:
+// Authorized Assembler Services Reference, Volume 2, ESTAE and ESTAEX).
+const ESTAE_KW = new Set(['PARAM', 'XCTL', 'PURGE', 'ASYNCH', 'TERM', 'ASCENV', 'RECORD', 'RELATED', 'MF',
+  'AMODE64', 'BRANCH', 'CANCEL', 'KEY', 'SDWALOC31', 'SPIEOVERRIDE', 'SVEAREA', 'TKNPASS', 'TOKEN']);
 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']);
@@ -16,13 +19,15 @@ function checkKw(kw, allowed, op) {
 function parseEstae(st, ops) {
   const { positional, keywords } = ops;
   checkKw(keywords, ESTAE_KW, 'ESTAE');
-  if (positional.length < 1 || positional.length > 3) {
+  // The list and execute forms (MF=) may leave the exit and the CT or OV to the other form.
+  const remote = keywords.has('MF');
+  if ((positional.length < 1 && !remote) || positional.length > 3) {
     throw new HlasmSyntax('ESTAE: expected 1 to 3 positional operands');
   }
-  const exit = positional[0];
+  const exit = positional[0] ?? '';
   for (let i = 1; i < positional.length; i++) {
-    const p = positional[i].toUpperCase();
-    if (p !== 'CT' && p !== 'OV') {
+    const p = positional[i].trim().toUpperCase();
+    if (p !== 'CT' && p !== 'OV' && !(remote && p === '')) {
       throw new HlasmSyntax(`ESTAE: unexpected positional operand ${positional[i]}`);
     }
   }

package/lib/hlasm/macro/storage.mjs

@@ -1,9 +1,41 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Parser for z/OS virtual storage macros: STORAGE, GETMAIN, and FREEMAIN.
-import { HlasmSyntax } from '../operands.mjs';
+import { HlasmSyntax, remoteForm } from '../operands.mjs';
+import { MVS38_HIARCHY, MVS38_KEYWORDS, MVS38_STORAGE_MODES, mvs38Form } from '../mvs38.mjs';
 
 const GETMAIN_MODES = new Set(['R', 'RU', 'RC', 'VU', 'VC', 'EU', 'EC', 'LU', 'LC', 'VRC', 'VRU']);
 const FREEMAIN_MODES = new Set(['R', 'RU', 'RC', 'VU', 'VC', 'V', 'EU', 'EC', 'E', 'LU', 'LC', 'L']);
+// The request types that have list and execute forms (MF=L, MF=(E,addr)), and those that take
+// BRANCH=(YES,GLOBAL) (z/OS 3.1 MVS Programming: Assembler Services Reference, Volume 1, and
+// Authorized Assembler Services Reference, Volume 2, GETMAIN and FREEMAIN). The request type is
+// optional in both forms: the execute form takes it from the list it names.
+const GETMAIN_LIST_MODES = new Set(['LC', 'LU', 'VC', 'VU', 'EC', 'EU']);
+const FREEMAIN_LIST_MODES = new Set(['LC', 'LU', 'L', 'VC', 'VU', 'V', 'EC', 'EU', 'E']);
+const GETMAIN_GLOBAL_MODES = new Set(['RC', 'RU', 'VRC', 'VRU']);
+const FREEMAIN_GLOBAL_MODES = new Set(['RC', 'RU']);
+const OWNERS = new Set(['HOME', 'PRIMARY', 'SECONDARY', 'SYSTEM']);
+
+// MF=L or MF=(E,addr), and BRANCH=YES or (YES,GLOBAL), each checked against the request type.
+function remoteAndBranch(macro, mode, keywords, listModes, globalModes) {
+  const out = {};
+  if (keywords.has('MF')) {
+    const { form, list } = remoteForm(keywords.get('MF'), 'MF');
+    if (mode && !listModes.has(mode)) throw new HlasmSyntax(`${macro} ${mode} has no list or execute form`);
+    out.mf = form === 'L' ? 'L' : { form: 'E', list };
+  }
+  if (keywords.has('BRANCH')) {
+    const v = keywords.get('BRANCH').replace(/\s+/g, '').toUpperCase();
+    if (v === '(YES,GLOBAL)') {
+      if (!globalModes.has(mode)) throw new HlasmSyntax(`${macro} takes BRANCH=(YES,GLOBAL) only with ${[...globalModes].join(', ')}`);
+      out.branch = 'GLOBAL';
+    } else if (v === 'YES' || v === '(YES)') {
+      out.branch = 'YES';
+    } else {
+      throw new HlasmSyntax(`${macro} BRANCH= value ${keywords.get('BRANCH')} is not YES or (YES,GLOBAL)`);
+    }
+  }
+  return out;
+}
 
 function getKeyword(keywords, key) {
   const val = keywords.get(key);
@@ -42,25 +74,35 @@ function parseStorage(st, ops) {
   };
 }
 
-function parseGetmain(st, ops) {
+function parseGetmain(st, ops, opts) {
   const { positional, keywords } = ops;
-  if (positional.length < 1) {
+  const mode = (positional[0] ?? '').trim().toUpperCase() || null;
+  if (!mode && !keywords.has('MF')) {
     throw new HlasmSyntax('GETMAIN requires a request type');
   }
-  const mode = positional[0].trim().toUpperCase();
-  if (!GETMAIN_MODES.has(mode)) {
+  const legacy = {};
+  if (mode && MVS38_STORAGE_MODES.has(mode)) {
+    mvs38Form(opts, legacy, 'GETMAIN', mode);
+  } else if (mode && !GETMAIN_MODES.has(mode)) {
     throw new HlasmSyntax(`GETMAIN request type must be one of ${[...GETMAIN_MODES].join(', ')}, got ${positional[0]}`);
   }
-  if (positional.length > 1) {
+  if (positional.slice(1).some((p) => p.trim() !== '')) {
     throw new HlasmSyntax(`GETMAIN does not accept extra positional operands: ${positional[1]}`);
   }
 
-  const allowed = new Set(['LA', 'LV', 'A', 'SP', 'BNDRY', 'CONTBDY', 'STARTBDY', 'KEY', 'LOC', 'INADDR', 'CHECKZERO', 'RELATED']);
+  const allowed = new Set(['LA', 'LV', 'A', 'SP', 'BNDRY', 'CONTBDY', 'STARTBDY', 'KEY', 'LOC', 'INADDR', 'CHECKZERO', 'RELATED', 'MF', 'BRANCH', 'OWNER']);
   for (const key of keywords.keys()) {
-    if (!allowed.has(key)) {
+    if (MVS38_KEYWORDS.GETMAIN.has(key)) {
+      mvs38Form(opts, legacy, 'GETMAIN', `${key}=${keywords.get(key).trim()}`);
+      if (!MVS38_HIARCHY.test(keywords.get(key).trim())) throw new HlasmSyntax('GETMAIN HIARCHY must be 0 or 1');
+    } else if (!allowed.has(key)) {
       throw new HlasmSyntax(`GETMAIN does not accept keyword ${key}`);
     }
   }
+  if (keywords.has('OWNER') && !OWNERS.has(keywords.get('OWNER').trim().toUpperCase())) {
+    throw new HlasmSyntax(`GETMAIN OWNER must be one of ${[...OWNERS].join(', ')}`);
+  }
+  const extra = remoteAndBranch('GETMAIN', mode, keywords, GETMAIN_LIST_MODES, GETMAIN_GLOBAL_MODES);
 
   const length = getKeyword(keywords, 'LV') ?? getKeyword(keywords, 'LA');
   const address = getKeyword(keywords, 'A');
@@ -68,33 +110,39 @@ function parseGetmain(st, ops) {
 
   return {
     kind: 'GETMAIN',
+    ...legacy,
     mode,
     length,
     address,
     subpool,
+    ...extra,
     keywords: Object.fromEntries(keywords)
   };
 }
 
-function parseFreemain(st, ops) {
+function parseFreemain(st, ops, opts) {
   const { positional, keywords } = ops;
-  if (positional.length < 1) {
+  const mode = (positional[0] ?? '').trim().toUpperCase() || null;
+  if (!mode && !keywords.has('MF')) {
     throw new HlasmSyntax('FREEMAIN requires a request type');
   }
-  const mode = positional[0].trim().toUpperCase();
-  if (!FREEMAIN_MODES.has(mode)) {
+  const legacy = {};
+  if (mode && MVS38_STORAGE_MODES.has(mode)) {
+    mvs38Form(opts, legacy, 'FREEMAIN', mode);
+  } else if (mode && !FREEMAIN_MODES.has(mode)) {
     throw new HlasmSyntax(`FREEMAIN request type must be one of ${[...FREEMAIN_MODES].join(', ')}, got ${positional[0]}`);
   }
-  if (positional.length > 1) {
+  if (positional.slice(1).some((p) => p.trim() !== '')) {
     throw new HlasmSyntax(`FREEMAIN does not accept extra positional operands: ${positional[1]}`);
   }
 
-  const allowed = new Set(['LA', 'LV', 'A', 'SP', 'KEY', 'RELATED']);
+  const allowed = new Set(['LA', 'LV', 'A', 'SP', 'KEY', 'RELATED', 'MF', 'BRANCH']);
   for (const key of keywords.keys()) {
     if (!allowed.has(key)) {
       throw new HlasmSyntax(`FREEMAIN does not accept keyword ${key}`);
     }
   }
+  const extra = remoteAndBranch('FREEMAIN', mode, keywords, FREEMAIN_LIST_MODES, FREEMAIN_GLOBAL_MODES);
 
   const length = getKeyword(keywords, 'LV') ?? getKeyword(keywords, 'LA');
   const address = getKeyword(keywords, 'A');
@@ -102,10 +150,12 @@ function parseFreemain(st, ops) {
 
   return {
     kind: 'FREEMAIN',
+    ...legacy,
     mode,
     length,
     address,
     subpool,
+    ...extra,
     keywords: Object.fromEntries(keywords)
   };
 }

package/lib/hlasm/macro/structured.mjs

@@ -110,7 +110,7 @@ function parseWHEN(st, ops) {
 }
 
 function parseNoOperand(st, ops) {
-  if (ops.positional.length > 0) throw new HlasmSyntax(`${st.operation} does not accept positional operands`);
+  if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax(`${st.operation} does not accept positional operands`);
   return { kind: st.operation, keywords: Object.fromEntries(ops.keywords) };
 }
 

package/lib/hlasm/model.mjs

@@ -14,7 +14,8 @@ const FIXED_LENGTH = { '&SYSDATE': 8, '&SYSDATC': 8, '&SYSTIME': 5 };
 // &NAME, with an optional subscript (&A(1), &A(&I+1)) and an optional period that joins it to what
 // follows. && is one ampersand, not a variable symbol. Inside a quoted string a variable becomes as
 // many X as its value has characters when that is fixed, and one X otherwise, counted as unsized.
-function substitute(text) {
+// Outside one it becomes what `standIn` gives for the nth such variable.
+function substitute(text, standIn = (n) => `VAR${n}`) {
   let out = '';
   let quoted = false;
   let n = 0;
@@ -35,20 +36,44 @@ function substitute(text) {
     i--;
     const fixed = FIXED_LENGTH[m[0].toUpperCase()];
     if (quoted && !fixed) unsized++;
-    out += quoted ? 'X'.repeat(fixed || 1) : `VAR${++n}`;
+    out += quoted ? 'X'.repeat(fixed || 1) : standIn(++n);
   }
-  return { text: out, unsized };
+  return { text: out, unsized, variables: n };
+}
+
+// A variable outside quotes stands in for a symbol. When no statement reads that way, one variable
+// at a time stands in for a quoted string (DC C&MSG, LA &R,=C&LIST), a number (DC &T.F'0') or an
+// option (PRINT &GEN, AMODE &MODE), as a caller's value may be, and then all of them do; past
+// eight variables only the uniform readings are tried.
+const SYMBOL = (n) => `VAR${n}`;
+const VALUES = ["'X'", '1', 'ON', 'ANY'];
+function* standIns(variables) {
+  yield SYMBOL;
+  if (variables <= 8) {
+    for (let j = 1; j <= variables; j++) for (const value of VALUES) yield (n) => (n === j ? value : SYMBOL(n));
+  }
+  for (const value of VALUES) yield () => value;
 }
 
 function read(kind, st) {
   if (/&[A-Z$#@_]/i.test(st.operation)) throw new HlasmSyntax(`the operation ${st.operation} is decided when the macro is expanded`);
-  const name = st.name && !st.name.startsWith('&') && !st.name.startsWith('.') ? st.name : null;
-  const { text, unsized } = substitute(st.field || '');
-  const res = parseHlasmStatement({ ...st, name, field: text, inMacro: false, prototype: false });
-  // exact: no quoted string holds a variable of unknown length, so the node's lengths are the source's.
-  if (res.status === 'parsed') return { kind, as: res.kind, node: res.node, exact: unsized === 0 };
-  if (res.status === 'unbuilt') throw new HlasmSyntax(`no parser yet for ${res.kind}`);
-  throw new HlasmSyntax(res.reason || `${res.kind} ${res.status}`);
+  // A name built from variable symbols (&NAME, KFBR&SYSNDX) stands in as an ordinary symbol, as the
+  // operands do; one still holding an ampersand would send the statement back here.
+  const named = st.name && !st.name.startsWith('.') ? substitute(st.name).text : null;
+  const name = named && !named.includes('&') ? named : null;
+  const { variables } = substitute(st.field || '');
+  let first = null;
+  for (const standIn of standIns(variables)) {
+    const { text, unsized } = substitute(st.field || '', standIn);
+    const res = parseHlasmStatement({ ...st, name, field: text, inMacro: false, prototype: false });
+    // exact: the symbol reading, with no quoted string holding a variable of unknown length, so the
+    // node's lengths are the source's.
+    if (res.status === 'parsed') return { kind, as: res.kind, node: res.node, exact: standIn === SYMBOL && unsized === 0 };
+    first ||= res;
+    if (!variables) break;
+  }
+  if (first.status === 'unbuilt') throw new HlasmSyntax(`no parser yet for ${first.kind}`);
+  throw new HlasmSyntax(first.reason || `${first.kind} ${first.status}`);
 }
 
 function prototype(st) {

package/lib/hlasm/mvs38.mjs

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Operands the MVS 3.8 system macros take that z/OS 3.1's documentation does not list, with the
+// meaning those macros give them (MVS 3.8j SYS1.MACLIB, public domain: MODESET, GETMAIN, FREEMAIN,
+// ATTACH, DCB). Read by default; parseHlasmStatement(st, { mvs38: false }) refuses them.
+import { HlasmSyntax } from './operands.mjs';
+
+// MODESET EXTKEY= names and the PSW key each sets.
+export const MVS38_EXTKEYS = new Map([
+  ['SUPR', 0], ['RSM', 0], ['VSM', 0], ['SRM', 0],
+  ['SCHED', 1], ['JES', 1], ['HASP', 1],
+  ['DATAMGT', 5],
+  ['TCAM', 6], ['VTAM', 6],
+]);
+
+// GETMAIN and FREEMAIN P: a request for a subpool, register 0 holding its number in the high byte.
+export const MVS38_STORAGE_MODES = new Set(['P']);
+
+// HIARCHY= chose a storage hierarchy (0 or 1); MVS/XA removed hierarchies.
+export const MVS38_HIARCHY = /^[01]$/;
+
+export const MVS38_KEYWORDS = {
+  GETMAIN: new Set(['HIARCHY']),
+  ATTACH: new Set(['HIARCHY', 'JSCB']),
+  DCB: new Set(['PGFX', 'AERR']),
+};
+
+export const mvs38Enabled = (opts) => opts?.mvs38 !== false;
+
+export const systemKeyExtkeys = (opts) => (mvs38Enabled(opts) ? [...MVS38_EXTKEYS].filter(([, key]) => key > 0) : []);
+
+export const keyZeroExtkeys = (opts) => (mvs38Enabled(opts) ? [...MVS38_EXTKEYS].filter(([, key]) => key === 0).map(([name]) => name) : []);
+
+// Marks an MVS 3.8 form on the node it is read into, or refuses it when the option is off.
+export function mvs38Form(opts, node, macro, form) {
+  if (!mvs38Enabled(opts)) throw new HlasmSyntax(`${macro}: ${form} is an MVS 3.8 form`);
+  (node.mvs38 ||= []).push(form);
+}
+
+// BTAM's READ and WRITE types (IHBRDWRT); BTAM is not in z/OS. READ T alone is its execute form.
+export const MVS38_BTAM_TYPES = {
+  READ: new Set(['T', 'TB', 'TI', 'TT', 'TV', 'TP', 'TS', 'TQ', 'TC', 'TE', 'TM', 'TIR', 'TTR', 'TVR', 'TPR', 'TTA', 'TTL', 'TPL', 'TIQ', 'TRV', 'TCW', 'TBR', 'TMP', 'TBP', 'TQM']),
+  WRITE: new Set(['TB', 'TI', 'TT', 'TV', 'TA', 'TS', 'TN', 'TR', 'TL', 'TD', 'TQ', 'TW', 'TC', 'TIR', 'TTR', 'TVR', 'TLR', 'TIO', 'TIV', 'TCO', 'TTV', 'TUS', 'TIX', 'TVO', 'TTX', 'TSR', 'TIE', 'TTE', 'TRM', 'TSA', 'TSF', 'TIVX', 'TTVX', 'TIXR', 'TTXR']),
+};
+
+// VTAM's basic-mode READ and WRITE, given RPL=, and the RPL fields they may set; z/OS
+// Communications Server keeps SEND and RECEIVE and has no READ or WRITE.
+export const MVS38_VTAM_RPL_KEYWORDS = new Set(['RPL', 'ACB', 'AREA', 'AREALEN', 'RECLEN', 'AAREA', 'AAREALN', 'ARECLEN', 'ECB', 'EXIT', 'OPTCD', 'ARG', 'BRANCH']);

package/lib/hlasm/operands.mjs

@@ -47,3 +47,13 @@ export function macroOperands(field) {
   }
   return { positional, keywords };
 }
+
+// A macro's list form (MF=L, SF=L) builds only its parameter list; its execute form ((E,addr))
+// runs the service on a list built elsewhere, at addr.
+export function remoteForm(value, keyword) {
+  const t = String(value).trim();
+  if (/^L$/i.test(t)) return { form: 'L', list: null };
+  const m = /^\(\s*E\s*,\s*(\S.*?)\s*\)$/i.exec(t);
+  if (m) return { form: 'E', list: m[1] };
+  throw new HlasmSyntax(`${keyword}= value ${t} is not L or (E,addr)`);
+}