@portll/cobolwork 0.6.0 → 0.7.0

package/lib/hlasm/macro/datasets.mjs

@@ -1,23 +1,28 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Parser for z/OS data-set macros: OPEN, CLOSE, and DCB.
-import { HlasmSyntax, NAME, splitOperands } from '../operands.mjs';
+import { HlasmSyntax, NAME, remoteForm, splitOperands } from '../operands.mjs';
 import { parseAddress } from '../expr.mjs';
+import { MVS38_KEYWORDS, mvs38Form } from '../mvs38.mjs';
 
 const OPEN_OPTS = new Set(['INPUT', 'OUTPUT', 'UPDAT', 'EXTEND', 'OUTIN', 'OUTINX', 'INOUT', 'RDBACK', 'DISP', 'LEAVE', 'REREAD']);
 const CLOSE_OPTS = new Set(['REREAD', 'LEAVE', 'REWIND', 'FREE', 'DISP']);
-const DCB_KEYWORDS = new Set(['BFALN', 'BFTEK', 'BLKSIZE', 'BUFCB', 'BUFL', 'BUFNO', 'BUFOFF', 'DCBE', 'DDNAME', 'DEVD', 'DSORG', 'EODAD', 'EROPT', 'EXLST', 'LRECL', 'MACRF', 'NCP', 'OPTCD', 'RECFM', 'SYNAD', 'KEYLEN', 'LIMCT', 'RKP', 'DEN', 'TRTCH', 'PRTSP', 'STACK', 'FUNC', 'MODE', 'CODE']);
+const DCB_KEYWORDS = new Set(['BFALN', 'BFTEK', 'BLKSIZE', 'BUFCB', 'BUFL', 'BUFNO', 'BUFOFF', 'DCBE', 'DDNAME', 'DEVD', 'DSORG', 'EODAD', 'EROPT', 'EXLST', 'LRECL', 'MACRF', 'NCP', 'OPTCD', 'RECFM', 'SYNAD', 'KEYLEN', 'LIMCT', 'RKP', 'DEN', 'TRTCH', 'PRTSP', 'STACK', 'FUNC', 'MODE', 'CODE',
+  // EXCP (z/OS 3.1 DFSMSdfp Advanced Services, Data Control Block (DCB) Fields).
+  'REPOS', 'EOEA', 'PCIA', 'SIOA', 'CENDA', 'XENDA', 'IMSK', 'PGFIX', 'IOBAD']);
 
 // (dcb,(options),dcb,(options),...): each DCB address followed by its options, written in parentheses,
-// as one bare word or omitted. A single DCB may be written without the outer parentheses.
-function parseDcbList(raw, validOpts) {
+// as one bare word or omitted. A single DCB may be written without the outer parentheses. The list
+// form (MF=L) and the execute form (MF=(E,addr)) may leave a DCB address empty, to be filled in by
+// the other (z/OS 3.1 DFSMS Macro Instructions for Data Sets, OPEN and CLOSE list and execute forms).
+function parseDcbList(raw, validOpts, emptyAllowed = false) {
   const text = raw.trim();
   const items = text.startsWith('(') && text.endsWith(')') ? splitOperands(text.slice(1, -1)) : [text];
   const dcbs = [];
   for (let i = 0; i < items.length; i++) {
     const dcbRaw = items[i].trim();
-    if (!dcbRaw) throw new HlasmSyntax('empty dcb address in list');
-    let dcb;
-    try { dcb = parseAddress(dcbRaw); } catch { throw new HlasmSyntax(`invalid dcb address: ${dcbRaw}`); }
+    if (!dcbRaw && !emptyAllowed) throw new HlasmSyntax('empty dcb address in list');
+    let dcb = null;
+    if (dcbRaw) try { dcb = parseAddress(dcbRaw); } catch { throw new HlasmSyntax(`invalid dcb address: ${dcbRaw}`); }
     const next = (items[i + 1] ?? '').trim();
     const word = next.toUpperCase();
     let options = [];
@@ -31,10 +36,17 @@ function parseDcbList(raw, validOpts) {
   return dcbs;
 }
 
+// The DCB list of OPEN or CLOSE and the form MF= gives it; the execute form may omit the list.
+function dcbOperand(macro, ops, validOpts) {
+  const mf = ops.keywords.has('MF') ? remoteForm(ops.keywords.get('MF'), 'MF') : null;
+  if (ops.positional.length === 0 && mf?.form === 'E') return { dcbs: [], mf };
+  if (ops.positional.length !== 1) throw new HlasmSyntax(`${macro} requires exactly one positional operand`);
+  return { dcbs: parseDcbList(ops.positional[0], validOpts, Boolean(mf)), mf };
+}
+
 export const parsers = {
   OPEN(st, ops) {
-    if (ops.positional.length !== 1) throw new HlasmSyntax('OPEN requires exactly one positional operand');
-    const dcbs = parseDcbList(ops.positional[0], OPEN_OPTS);
+    const { dcbs, mf } = dcbOperand('OPEN', ops, OPEN_OPTS);
     const keywords = {};
     for (const [k, v] of ops.keywords) {
       if (k === 'TYPE') {
@@ -49,11 +61,10 @@ export const parsers = {
         throw new HlasmSyntax(`unknown keyword for OPEN: ${k}`);
       }
     }
-    return { kind: 'OPEN', dcbs, keywords };
+    return { kind: 'OPEN', dcbs, ...(mf ? { mf: mf.form === 'L' ? 'L' : { form: 'E', list: mf.list } } : {}), keywords };
   },
   CLOSE(st, ops) {
-    if (ops.positional.length !== 1) throw new HlasmSyntax('CLOSE requires exactly one positional operand');
-    const dcbs = parseDcbList(ops.positional[0], CLOSE_OPTS);
+    const { dcbs, mf } = dcbOperand('CLOSE', ops, CLOSE_OPTS);
     const keywords = {};
     for (const [k, v] of ops.keywords) {
       if (k === 'TYPE') {
@@ -68,10 +79,10 @@ export const parsers = {
         throw new HlasmSyntax(`unknown keyword for CLOSE: ${k}`);
       }
     }
-    return { kind: 'CLOSE', dcbs, keywords };
+    return { kind: 'CLOSE', dcbs, ...(mf ? { mf: mf.form === 'L' ? 'L' : { form: 'E', list: mf.list } } : {}), keywords };
   },
-  DCB(st, ops) {
-    if (ops.positional.length > 0) throw new HlasmSyntax('DCB takes no positional operands');
+  DCB(st, ops, opts) {
+    if (ops.positional.some((p) => p.trim() !== '')) throw new HlasmSyntax('DCB takes no positional operands');
     const keywords = {};
     let ddname = null;
     let dsorg = null;
@@ -79,8 +90,10 @@ export const parsers = {
     let recfm = null;
     let lrecl = null;
     let blksize = null;
+    const legacy = {};
     for (const [k, v] of ops.keywords) {
-      if (!DCB_KEYWORDS.has(k)) throw new HlasmSyntax(`unknown keyword for DCB: ${k}`);
+      if (MVS38_KEYWORDS.DCB.has(k)) mvs38Form(opts, legacy, 'DCB', `${k}=${String(v).trim()}`);
+      else if (!DCB_KEYWORDS.has(k)) throw new HlasmSyntax(`unknown keyword for DCB: ${k}`);
       keywords[k] = v;
       if (k === 'DDNAME') ddname = v.toUpperCase();
       else if (k === 'DSORG') dsorg = v;
@@ -89,6 +102,6 @@ export const parsers = {
       else if (k === 'LRECL') lrecl = v;
       else if (k === 'BLKSIZE') blksize = v;
     }
-    return { kind: 'DCB', name: st.name, ddname, dsorg, macrf, recfm, lrecl, blksize, keywords };
+    return { kind: 'DCB', ...legacy, name: st.name, ddname, dsorg, macrf, recfm, lrecl, blksize, keywords };
   }
 };

package/lib/hlasm/macro/io.mjs

@@ -2,6 +2,7 @@
 // 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;
@@ -36,7 +37,17 @@ function parseMf(text) {
   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');
@@ -59,6 +70,7 @@ function parseGet(st, ops) {
 }
 
 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');
@@ -77,60 +89,71 @@ function parsePut(st, ops) {
   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;
+// 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 parseWrite(st, ops) {
+function blockRequest(macro, st, ops, opts) {
   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');
-  
+  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 (!NAME.test(decb)) throw new HlasmSyntax('WRITE decb name is not a valid symbol');
-  
+  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 (!['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;
+  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,

package/lib/hlasm/macro/le.mjs

@@ -17,13 +17,13 @@ function checkKeywords(ops, allowed, op) {
 }
 
 function parseCEEENTRY(st, ops) {
-  if (ops.positional.length > 0) throw new HlasmSyntax('CEEENTRY takes no positional operands');
+  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.length > 0) throw new HlasmSyntax('CEETERM takes no positional operands');
+  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 };
 }

package/lib/hlasm/macro/operator.mjs

@@ -2,8 +2,13 @@
 // 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']);
+// 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;
@@ -12,23 +17,24 @@ function parseWTO(st, ops) {
     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');
-    }
+  // 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 (positional.length > 1) {
-    throw new HlasmSyntax(`WTO: too many positional operands (${positional.length})`);
+  if (lines.length > 1 && !lines.every((l) => l.startsWith('('))) {
+    throw new HlasmSyntax(`WTO: too many positional operands (${lines.length})`);
   }
-  return { kind: 'WTO', text, keywords: kw };
+  return { kind: 'WTO', text: lines.length ? lines.join(',') : null, keywords: kw };
 }
 
 function parseWTOR(st, ops) {
-  const { positional, keywords } = 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}`);
@@ -39,20 +45,25 @@ function parseWTOR(st, ops) {
   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')) {
+    if (!keywords.has('TEXT') && !execute) {
       throw new HlasmSyntax('WTOR: no positional operands and no TEXT= keyword');
     }
-  } else if (positional.length === 4) {
+  } else if (positional.length === 4 || (remote && positional.length <= 4)) {
     const msg = positional[0].trim();
-    if (msg.startsWith("'") || msg.startsWith('(')) {
+    if (isMessage(msg)) {
       text = msg;
-    } else {
+    } 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];
-    replyLength = positional[2];
-    ecb = positional[3];
+    reply = positional[1] ?? null;
+    replyLength = positional[2] ?? null;
+    ecb = positional[3] ?? null;
   } else {
     throw new HlasmSyntax(`WTOR: expected 4 positional operands, got ${positional.length}`);
   }