@portll/cobolwork 0.5.0 → 0.7.0

package/lib/hlasm/read.mjs

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// HLASM source read statement by statement: the cards fold as the assembler folds them (lib/bms.mjs),
+// and each statement goes to the parser for what its operation is. A machine instruction is matched
+// against IBM's operand syntax, an assembler instruction and a system macro each have their own
+// parser, and any other macro call is split into its operands. Conditional assembly and macro
+// definitions are counted and not evaluated: nothing here expands a macro.
+import { foldStatements } from '../bms.mjs';
+import { HlasmSyntax, NAME, macroOperands } from './operands.mjs';
+import { INSTRUCTIONS, parseInstruction, formatFamily } from './instr.mjs';
+import { inOptable } from './optable.mjs';
+import { parsers as data } from './asm/data.mjs';
+import { parsers as sections } from './asm/sections.mjs';
+import { parsers as symbols } from './asm/symbols.mjs';
+import { parsers as listing } from './asm/listing.mjs';
+import { parsers as output } from './asm/output.mjs';
+import { parsers as program } from './macro/program.mjs';
+import { parsers as linkage } from './macro/linkage.mjs';
+import { parsers as storage } from './macro/storage.mjs';
+import { parsers as authorization } from './macro/authorization.mjs';
+import { parsers as operator } from './macro/operator.mjs';
+import { parsers as datasets } from './macro/datasets.mjs';
+import { parsers as io } from './macro/io.mjs';
+import { parsers as recovery } from './macro/recovery.mjs';
+import { parsers as le } from './macro/le.mjs';
+import { parsers as structured } from './macro/structured.mjs';
+import { parsers as exec } from './exec.mjs';
+import { parsers as model } from './model.mjs';
+
+// The assembler instructions of HLASM V1R6 (Language Reference SC26-4940-09, chapters 5 and 9).
+export const ASSEMBLER = new Set(['ACONTROL', 'ADATA', 'AINSERT', 'ALIAS', 'AMODE', 'CATTR', 'CCW', 'CCW0', 'CCW1',
+  'CEJECT', 'CNOP', 'COM', 'COPY', 'CSECT', 'CXD', 'DC', 'DROP', 'DS', 'DSECT', 'DXD', 'EJECT', 'END', 'ENTRY', 'EQU',
+  'EXITCTL', 'EXTRN', 'ICTL', 'ISEQ', 'LOCTR', 'LTORG', 'MNOTE', 'OPSYN', 'ORG', 'POP', 'PRINT', 'PUNCH', 'PUSH',
+  'REPRO', 'RMODE', 'RSECT', 'SPACE', 'START', 'TITLE', 'USING', 'WXTRN', 'XATTR']);
+export const CONDITIONAL = new Set(['ACTR', 'AEJECT', 'AGO', 'AGOB', 'AIF', 'AIFB', 'ANOP', 'AREAD', 'ASPACE',
+  'GBLA', 'GBLB', 'GBLC', 'LCLA', 'LCLB', 'LCLC', 'MEXIT', 'MHELP', 'SETA', 'SETAF', 'SETB', 'SETC', 'SETCF']);
+// The z/OS macros the rules read, each parsed against the keywords IBM lists for it.
+export const SYSTEM_MACROS = new Set(['LINK', 'XCTL', 'LOAD', 'ATTACH', 'CALL', 'SAVE', 'RETURN', 'MODESET',
+  'STORAGE', 'GETMAIN', 'FREEMAIN', 'RACROUTE', 'TESTAUTH', 'WTO', 'WTOR', 'OPEN', 'CLOSE', 'DCB', 'GET', 'PUT',
+  'READ', 'WRITE', 'ESTAE', 'ESPIE', 'ABEND', 'SNAP']);
+// Language Environment's prolog, epilog and mapping macros, and the HLASM Toolkit's structured
+// programming macros, each with its own parser.
+export const LE_MACROS = new Set(['CEEENTRY', 'CEETERM', 'CEEPPA', 'CEECAA', 'CEEDSA']);
+export const TOOLKIT_MACROS = new Set(['IF', 'ELSE', 'ELSEIF', 'ENDIF', 'DO', 'ENDDO', 'DOEXIT', 'ASMLEAVE', 'ITERATE',
+  'SELECT', 'WHEN', 'NEXTWHEN', 'OTHRWISE', 'ENDSEL', 'STRTSRCH', 'EXITIF', 'ORELSE', 'ENDLOOP', 'ENDSRCH',
+  'CASENTRY', 'CASE', 'ENDCASE', 'ASMMREL']);
+export const NAMED_MACROS = new Set([...SYSTEM_MACROS, ...LE_MACROS, ...TOOLKIT_MACROS]);
+
+const NO_OPERANDS = new Set(['CSECT', 'DSECT', 'RSECT', 'COM', 'LOCTR', 'LTORG', 'EJECT', 'REPRO', 'CXD']);
+
+export const PARSERS = Object.freeze({ ...data, ...sections, ...symbols, ...listing, ...output });
+export const MACRO_PARSERS = Object.freeze({ ...program, ...linkage, ...storage, ...authorization, ...operator, ...datasets, ...io, ...recovery, ...le, ...structured });
+
+// Statements other than comments, each marked inMacro when it is part of a macro definition, the
+// prototype (the statement after MACRO) marked as such, and sourceMacro when its operation names a
+// macro the file has already defined: a source macro with the name of an instruction or a library
+// macro overrides it (https://www.ibm.com/docs/en/hla-and-tf/1.6.0?topic=definitions-macro-instruction-prototype).
+// EXEC CICS and EXEC SQL are written for their translators, with blanks between the words: their
+// field is the cards' text after EXEC, columns 16 to 71 of each continuation, not the operands up
+// to the first blank as an assembler statement's are.
+function execField(phys, st) {
+  return st.lines.map((n, i) => (i === 0 ? phys[n - 1].slice(0, 71).replace(/^\S*\s+EXEC\b/i, '') : phys[n - 1].slice(15, 71))).join(' ').replace(/\s+/g, ' ').trim();
+}
+
+// libraryMacros: the macros the repository's own library defines. One with the name of a macro this
+// reader knows is the repository's, found ahead of the system's on the macro search; an instruction
+// is never looked for in a library.
+export function readHlasmStatements(text, { libraryMacros = null } = {}) {
+  const { statements, diags } = foldStatements(text, { batch: true });
+  const phys = String(text).replace(/\r\n?/g, '\n').split('\n');
+  const out = [];
+  let depth = 0;
+  let prototypeNext = false;
+  const defined = new Set();
+  for (const s of statements) {
+    if (s.kind === 'comment' || s.kind === 'not-assembler') continue;
+    const st = { ...s, inMacro: depth > 0, prototype: false };
+    if (s.kind === 'statement' && s.operation === 'EXEC') st.field = execField(phys, s);
+    if (s.kind === 'statement') {
+      if (s.operation === 'MACRO') { depth++; prototypeNext = true; st.inMacro = true; }
+      else if (prototypeNext) { st.prototype = true; prototypeNext = false; if (s.operation) defined.add(s.operation.toUpperCase()); }
+      else if (s.operation && defined.has(s.operation.toUpperCase())) st.sourceMacro = true;
+      else if (s.operation && libraryMacros?.has(s.operation.toUpperCase()) && NAMED_MACROS.has(s.operation.toUpperCase())) st.libraryMacro = true;
+      if (s.operation === 'MEND') depth = Math.max(0, depth - 1);
+      // Each program of a batch is its own assembly: its source macros are its own.
+      if (s.operation === 'END' && depth === 0) defined.clear();
+    }
+    out.push(st);
+  }
+  return { statements: out, diags };
+}
+
+function run(kind, parser, st, ...args) {
+  if (!parser) return { kind, status: 'unbuilt' };
+  try {
+    return { kind, status: 'parsed', node: parser(st, ...args) };
+  } catch (e) {
+    if (e instanceof HlasmSyntax) return { kind, status: 'unparsed', reason: e.message };
+    return { kind, status: 'unparsed', reason: `parser error: ${e && e.message}`, crash: true };
+  }
+}
+
+// { kind, status, node?, reason?, crash? }: parsed, unbuilt (no parser for the kind yet), unparsed
+// (the parser refused it) or unknown (not an operation HLASM has).
+export function parseHlasmStatement(st, opts = {}) {
+  if (st.kind !== 'statement') return { kind: 'UNREADABLE', status: 'unknown', reason: 'no operation field' };
+  if (st.continues === 'comment') return { kind: 'CONTINUED', status: 'unparsed', reason: 'the comment above runs into column 72, so the assembler reads this line as part of it' };
+  if (st.continues === 'statement') return { kind: 'CONTINUED', status: 'unparsed', reason: 'the statement above runs into column 72 and this line does not leave columns 1 to 15 blank' };
+  const op = st.operation;
+  if (op === 'MACRO' || op === 'MEND') return { kind: 'MACRO DEFINITION', status: 'parsed', node: { kind: op } };
+  if (CONDITIONAL.has(op)) return { kind: 'CONDITIONAL', status: 'unbuilt' };
+  if (st.prototype) return run('PROTOTYPE', model.PROTOTYPE, st);
+  if (st.inMacro) return run('MODEL', model.MODEL, st);
+  if (/&[A-Z$#@_]/i.test(`${st.name || ''} ${op} ${st.field || ''}`.replace(/&&/g, ''))) return run('SUBSTITUTED', model.SUBSTITUTED, st);
+  if (st.sourceMacro || st.libraryMacro) return run('MACRO CALL', (s) => ({ kind: 'MACRO CALL', macro: op, ...(st.sourceMacro ? { source: true } : { library: true }), ...macroOperands(s.field || '') }), st);
+  // A lone comma is the convention for no operands with remarks after it (CSECT , remark); an
+  // instruction that takes no operands reads whatever follows it as remarks.
+  if (ASSEMBLER.has(op)) return run(op, PARSERS[op], st.field === ',' || NO_OPERANDS.has(op) ? { ...st, field: '' } : st);
+  const row = INSTRUCTIONS.get(op);
+  if (row && inOptable(op, opts.optable)) return run(formatFamily(row.format), parseInstruction, st, row);
+  if (op === 'EXEC') {
+    const kind = `EXEC ${(/^\S+/.exec(st.field || '') || ['?'])[0].toUpperCase()}`;
+    return run(kind, exec[kind], st);
+  }
+  if (!NAME.test(op)) return { kind: 'UNKNOWN', status: 'unknown', reason: `${op} is not an operation name` };
+  if (NAMED_MACROS.has(op)) {
+    const parser = MACRO_PARSERS[op];
+    return run(op, parser && ((s) => parser(s, macroOperands(s.field === ',' ? '' : s.field || ''), opts)), st);
+  }
+  return run('MACRO CALL', (s) => ({ kind: 'MACRO CALL', macro: op, ...macroOperands(s.field || '') }), st);
+}

package/lib/hlasm.mjs

@@ -7,6 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { foldStatements } from './bms.mjs';
 import { parseOperands, splitOperands } from './cards.mjs';
+import { keyZeroExtkeys, systemKeyExtkeys } from './hlasm/mvs38.mjs';
 
 const TABLE = JSON.parse(readFileSync(new URL('../rules/hlasm-operations.json', import.meta.url), 'utf8'));
 export const OPERATIONS = new Map(TABLE.operations.map((o) => [o.name, o]));
@@ -31,31 +32,64 @@ const IMS = new Set(['DBD', 'DBDGEN', 'SEGM', 'PSBGEN', 'PCB', 'SENSEG']);
 
 // MODESET changes the PSW key or the state; these operand values make it key zero or supervisor
 // state, and the opposite values (KEY=NZERO, MODE=PROB) return from it. EXTKEY is the inline form,
-// which sets only the PSW key.
+// which sets only the PSW key; MVS 3.8's names for key zero count when its forms are read.
 const STATE_CHANGE = { KEY: ['ZERO'], MODE: ['SUP'], EXTKEY: ['ZERO'] };
 
 const nameList = (field) => splitOperands(field || '').map((s) => s.trim().toUpperCase()).filter((s) => /^[A-Z$#@_][A-Z0-9$#@_]*$/.test(s));
 
-function stateChange(field) {
+function stateChange(field, opts) {
   let ops;
   try { ops = parseOperands(field || ''); } catch { return null; }
-  for (const [key, values] of Object.entries(STATE_CHANGE)) {
+  for (const [key, zero] of Object.entries(STATE_CHANGE)) {
+    const values = key === 'EXTKEY' ? [...zero, ...keyZeroExtkeys(opts)] : zero;
     const v = ops.keywords.get(key);
     if (v && values.includes(String(v).trim().toUpperCase())) return `${key}=${String(v).trim().toUpperCase()}`;
   }
   return null;
 }
 
+// EXTKEY= naming a system key other than zero: z/OS's KEY2, KEY3, KEY4 and KEY7, and MVS 3.8's
+// names for keys 1 to 7 when its forms are read. TCB, RBT1 and RBT234 take a key decided at run time.
+const SYSTEM_EXTKEYS = [['KEY2', 2], ['KEY3', 3], ['KEY4', 4], ['KEY7', 7]];
+
+function systemKeyChange(field, opts) {
+  let ops;
+  try { ops = parseOperands(field || ''); } catch { return null; }
+  const v = String(ops.keywords.get('EXTKEY') || '').trim().toUpperCase();
+  const key = new Map([...SYSTEM_EXTKEYS, ...systemKeyExtkeys(opts)]).get(v);
+  return key === undefined ? null : { written: `EXTKEY=${v}`, key };
+}
+
+// A disassembler's listing: each line's object code, its characters between asterisks and its offset
+// to the right of the source, as in `BR R15   07FF   *..*   00004`.
+const DISASSEMBLED = /\s[0-9A-F]{2,16}(?: [0-9A-F]{2,16}){0,2}\s+\*.{1,16}\*\s+[0-9A-F]{5,8}\s*$/;
+
+// English function words, which no statement's name, operation or first operand holds.
+const FUNCTION_WORDS = new Set(['THE', 'OF', 'AND', 'TO', 'IS', 'IN', 'FOR', 'THIS', 'THAT', 'WITH', 'ARE', 'BE', 'IT', 'AN', 'WILL', 'CAN',
+  'YOU', 'WHICH', 'FROM', 'ON', 'AS', 'BY', 'NOT', 'IF', 'WHEN', 'HAS', 'HAVE', 'WAS', 'ALL', 'ANY', 'ONE', 'MAY', 'YOUR', 'THESE', 'THEY',
+  'THERE', 'SHOULD', 'MUST', 'ALSO', 'ONLY']);
+
+// A manual, article or README saved as assembler source: its statements, macro definitions included,
+// read as English, and the reader refuses many of those in open code. On the CBT, MVS 3.8j and GitHub
+// corpora both thresholds together held for 25 documents and no program.
+export function isDocument(statements, open, refused) {
+  if (open < 5) return false;
+  const english = statements.filter((s) => [s.name, s.operation, (s.field || '').split(/[\s,]/)[0]].some((w) => w && FUNCTION_WORDS.has(w.toUpperCase()))).length;
+  return english >= 0.15 * statements.length && refused >= 0.2 * open;
+}
+
 // What the file is, and in it: each operation the table names with where it is written; the
 // sections and entry points it defines, which a CALL or a job step can name; and the names it
 // leaves to the binder.
-export function readHlasm(text) {
-  const { statements, diags } = foldStatements(text);
+export function readHlasm(text, opts = {}) {
+  const { statements, diags } = foldStatements(text, { batch: true });
   const ops = statements.filter((s) => s.kind === 'statement');
   const has = (set) => ops.some((s) => set.has(s.operation));
   const weak = new Set(ops.filter((s) => WEAK.has(s.operation)).map((s) => s.operation)).size;
   const assembler = !GNU.test(text) && (ops.some(strong) || weak >= 2);
-  const kind = has(BMS) ? 'bms' : has(IMS) ? 'ims' : assembler ? 'hlasm' : 'unrecognised';
+  const lines = String(text).replace(/\r\n?/g, '\n').split('\n');
+  const listing = ops.length >= 5 && ops.filter((s) => DISASSEMBLED.test(lines[s.line - 1].slice(0, 80))).length * 2 >= ops.length;
+  const kind = has(BMS) ? 'bms' : has(IMS) ? 'ims' : !assembler ? 'unrecognised' : listing ? 'listing' : 'hlasm';
   const out = { kind, statements: ops.length, operations: [], defines: [], external: [], diags };
   if (kind !== 'hlasm') return out;
 
@@ -72,7 +106,10 @@ export function readHlasm(text) {
     const op = OPERATIONS.get(s.operation);
     if (!op || op.class === 'section' || op.class === 'linkage') continue;
     const use = { name: op.name, class: op.class, line: s.line, inMacro, field: s.field };
-    if (op.name === 'MODESET') use.stateChange = stateChange(s.field);
+    if (op.name === 'MODESET') {
+      use.stateChange = stateChange(s.field, opts);
+      if (!use.stateChange) use.systemKey = systemKeyChange(s.field, opts);
+    }
     out.operations.push(use);
   }
   return out;

package/lib/ims/dli.mjs

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// The DL/I call interface as a program issues it: CALL 'CBLTDLI' or 'AIBTDLI' USING [count,] function,
+// PCB or AIB, I/O area [, SSA ...], and EXEC DLI. Each database function needs a processing option on
+// the PCB it runs against, the PROCOPT of its PSBGEN PCB or SENSEG: a get needs G, ISRT I, REPL R
+// and DLET D. A get call fills the I/O area with the segment it retrieves.
+
+export const DLI_ROUTINE = /^(CBLTDLI|AIBTDLI)$/i;
+
+export const DLI_FUNCTIONS = Object.freeze({
+  GU: 'G', GN: 'G', GNP: 'G', GHU: 'G', GHN: 'G', GHNP: 'G',
+  ISRT: 'I', REPL: 'R', DLET: 'D',
+});
+
+export const isGet = (fn) => DLI_FUNCTIONS[fn] === 'G';
+
+// Calls that are not database calls: scheduling, termination, checkpoint, restart, rollback, sync,
+// logging, statistics and the system service calls. They need no processing option.
+export const DLI_SERVICES = new Set(['PCB', 'TERM', 'CHKP', 'XRST', 'ROLB', 'ROLL', 'ROLS', 'SETS', 'SETU', 'SYNC', 'INIT',
+  'INQY', 'GSCD', 'LOG', 'STAT', 'APSB', 'DPSB', 'GMSG', 'ICMD', 'RCMD', 'SCHD', 'AUTH', 'CHNG', 'PURG', 'CMD', 'GCMD', 'ICAL']);
+
+// The PSB a DFSRRC00 step's PARM names: region type, program, then PSB, which defaults to the program.
+export function psbOfParm(parm) {
+  const [, program, psb] = String(parm || '').replace(/^[('\s]+|[)'\s]+$/g, '').split(',').map((x) => x.trim().toUpperCase());
+  return program ? { program, psb: psb || program } : null;
+}
+
+// The function code of a CALL to a DL/I routine and the argument that holds it: the first argument,
+// or the second when the first is a parameter count. `valueOf(arg)` gives the literal or the VALUE
+// of the item an argument names.
+export function dliFunction(using, valueOf) {
+  for (let index = 0; index < Math.min(2, using.length); index++) {
+    const v = valueOf(using[index]);
+    const fn = v == null ? null : String(v).trim().toUpperCase();
+    if (fn && Object.hasOwn(DLI_FUNCTIONS, fn)) return { fn, index };
+  }
+  return null;
+}

package/lib/ims/macro/dbd.mjs

@@ -0,0 +1,299 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the IMS DBD macros: DBD, DATASET, AREA, SEGM, FIELD, LCHILD, XDFLD, DBDGEN.
+import { ImsSyntax, sublist, integer, onlyKeywords } from '../operands.mjs';
+
+const ACCESS_TYPES = new Set(['HDAM', 'HIDAM', 'HISAM', 'HSAM', 'SHISAM', 'SHSAM', 'PHDAM', 'PHIDAM', 'PSINDEX', 'INDEX', 'LOGICAL', 'DEDB', 'MSDB', 'GSAM']);
+const ACCESS_METHODS = new Set(['VSAM', 'OSAM', 'BSAM']);
+const FIELD_TYPES = new Set(['C', 'X', 'P', 'Z', 'H', 'F', 'G']);
+
+function parseDBD(st, ops) {
+  const name = ops.keywords.get('NAME');
+  if (!name) throw new ImsSyntax('DBD requires NAME');
+  const accessRaw = ops.keywords.get('ACCESS');
+  let access = null;
+  if (accessRaw) {
+    const items = sublist(accessRaw);
+    if (!items || items.length < 1 || items.length > 3) throw new ImsSyntax('DBD ACCESS must be a type or (type, method[,prot])');
+    const type = items[0].toUpperCase();
+    if (!ACCESS_TYPES.has(type)) throw new ImsSyntax(`DBD ACCESS type ${type} is not recognised`);
+    let method = null;
+    if (items.length >= 2) {
+      method = items[1].toUpperCase();
+      if (!ACCESS_METHODS.has(method)) throw new ImsSyntax(`DBD ACCESS method ${method} is not recognised`);
+    }
+    access = { type, method };
+  }
+
+  let passwd = null;
+  const passwdRaw = ops.keywords.get('PASSWD');
+  if (passwdRaw) {
+    const p = passwdRaw.toUpperCase();
+    if (p !== 'YES' && p !== 'NO') throw new ImsSyntax('DBD PASSWD must be YES or NO');
+    passwd = p;
+  }
+
+  let rmname = null;
+  const rmnameRaw = ops.keywords.get('RMNAME');
+  if (rmnameRaw) {
+    const items = sublist(rmnameRaw);
+    if (!items || items.length < 1 || items.length > 4) throw new ImsSyntax('DBD RMNAME must be (module[,anchors[,rbn[,bytes]]])');
+    rmname = items;
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'DBD',
+    name,
+    access,
+    passwd,
+    rmname,
+    keywords
+  };
+}
+
+function parseDATASET(st, ops) {
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  const dd1 = ops.keywords.get('DD1');
+  const dd2 = ops.keywords.get('DD2');
+  const ovflw = ops.keywords.get('OVFLW');
+  const device = ops.keywords.get('DEVICE');
+  const sizeRaw = ops.keywords.get('SIZE');
+  let size = null;
+  if (sizeRaw) {
+    const items = sublist(sizeRaw);
+    if (items) size = items;
+    else size = [sizeRaw];
+  }
+
+  return {
+    kind: 'DATASET',
+    label: st.name,
+    dd1,
+    dd2,
+    ovflw,
+    device,
+    size,
+    keywords
+  };
+}
+
+function parseAREA(st, ops) {
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'AREA',
+    keywords
+  };
+}
+
+function parseSEGM(st, ops) {
+  const name = ops.keywords.get('NAME');
+  if (!name) throw new ImsSyntax('SEGM requires NAME');
+
+  const parentRaw = ops.keywords.get('PARENT');
+  let parent = null;
+  if (parentRaw) {
+    const p = parentRaw.trim();
+    if (p === '0') {
+      parent = null;
+    } else {
+      const items = sublist(p);
+      if (items && items.length === 1) {
+        parent = items[0];
+      } else {
+        parent = p;
+      }
+    }
+  }
+
+  const bytesRaw = ops.keywords.get('BYTES');
+  let bytes = null;
+  if (bytesRaw) {
+    const items = sublist(bytesRaw);
+    if (items) {
+      if (items.length === 1) {
+        const n = integer(items[0]);
+        if (n === null) throw new ImsSyntax('SEGM BYTES must be an integer or (max,min)');
+        bytes = { max: n, min: n };
+      } else if (items.length === 2) {
+        const max = integer(items[0]);
+        const min = integer(items[1]);
+        if (max === null || min === null) throw new ImsSyntax('SEGM BYTES (max,min) must be integers');
+        bytes = { max, min };
+      } else {
+        throw new ImsSyntax('SEGM BYTES must be an integer or (max,min)');
+      }
+    } else {
+      const n = integer(bytesRaw);
+      if (n === null) throw new ImsSyntax('SEGM BYTES must be an integer or (max,min)');
+      bytes = { max: n, min: n };
+    }
+  }
+
+  const rulesRaw = ops.keywords.get('RULES');
+  let rules = null;
+  if (rulesRaw) {
+    rules = sublist(rulesRaw);
+  }
+
+  const pointerRaw = ops.keywords.get('POINTER');
+  let pointer = null;
+  if (pointerRaw) {
+    const items = sublist(pointerRaw);
+    if (items) pointer = items;
+    else pointer = pointerRaw;
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'SEGM',
+    name,
+    parent,
+    bytes,
+    rules,
+    pointer,
+    keywords
+  };
+}
+
+function parseFIELD(st, ops) {
+  const nameRaw = ops.keywords.get('NAME');
+  if (!nameRaw) throw new ImsSyntax('FIELD requires NAME');
+
+  const items = sublist(nameRaw);
+  let name, seq = false, unique = null;
+  if (items) {
+    name = items[0];
+    if (items.length >= 2) {
+      const seqFlag = items[1].toUpperCase();
+      if (seqFlag === 'SEQ') seq = true;
+      else throw new ImsSyntax('FIELD NAME sublist second element must be SEQ');
+    }
+    if (items.length >= 3) {
+      const uFlag = items[2].toUpperCase();
+      if (uFlag === 'U') unique = true;
+      else if (uFlag === 'M') unique = false;
+      else throw new ImsSyntax('FIELD NAME sublist third element must be U or M');
+    }
+  } else {
+    name = nameRaw;
+  }
+
+  const bytesRaw = ops.keywords.get('BYTES');
+  let bytes = null;
+  if (bytesRaw) {
+    const n = integer(bytesRaw);
+    if (n === null) throw new ImsSyntax('FIELD BYTES must be an integer');
+    bytes = n;
+  }
+
+  const startRaw = ops.keywords.get('START');
+  let start = null;
+  if (startRaw) {
+    const n = integer(startRaw);
+    if (n === null) throw new ImsSyntax('FIELD START must be an integer');
+    start = n;
+  }
+
+  const typeRaw = ops.keywords.get('TYPE');
+  let type = 'C';
+  if (typeRaw) {
+    const t = typeRaw.toUpperCase();
+    if (!FIELD_TYPES.has(t)) throw new ImsSyntax(`FIELD TYPE ${t} is not recognised`);
+    type = t;
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'FIELD',
+    name,
+    seq,
+    unique,
+    bytes,
+    start,
+    type,
+    keywords
+  };
+}
+
+function parseLCHILD(st, ops) {
+  const nameRaw = ops.keywords.get('NAME');
+  if (!nameRaw) throw new ImsSyntax('LCHILD requires NAME');
+
+  const items = sublist(nameRaw);
+  let name, dbd = null;
+  if (items) {
+    name = items[0];
+    if (items.length >= 2) dbd = items[1];
+  } else {
+    name = nameRaw;
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'LCHILD',
+    name,
+    dbd,
+    keywords
+  };
+}
+
+function parseXDFLD(st, ops) {
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'XDFLD',
+    keywords
+  };
+}
+
+function parseDBDGEN(st, ops) {
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+
+  return {
+    kind: 'DBDGEN',
+    keywords
+  };
+}
+
+const KEYWORDS = {
+  DBD: ['NAME', 'ACCESS', 'RMNAME', 'PASSWD', 'VERSION', 'DATXEXIT', 'EXIT', 'PSNAME', 'GSROOT', 'ENCODING', 'FPINDEX'],
+  DATASET: ['DD1', 'DD2', 'OVFLW', 'DEVICE', 'BLOCK', 'SIZE', 'SCAN', 'FRSPC', 'RECORD', 'RECFM', 'MODEL', 'SEARCHA', 'REL'],
+  AREA: ['DD1', 'MODEL', 'SIZE', 'UOW', 'ROOT', 'REMOTE'],
+  SEGM: ['NAME', 'PARENT', 'BYTES', 'FREQ', 'POINTER', 'PTR', 'RULES', 'COMPRTN', 'EXIT', 'SOURCE', 'SSPTR', 'TYPE', 'DSGROUP'],
+  FIELD: ['NAME', 'BYTES', 'START', 'TYPE'],
+  LCHILD: ['NAME', 'POINTER', 'PTR', 'PAIR', 'RULES', 'INDEX', 'RKSIZE'],
+  XDFLD: ['NAME', 'SEGMENT', 'SRCH', 'SUBSEQ', 'DDATA', 'NULLVAL', 'CONST', 'EXTRTN'],
+  DBDGEN: [],
+};
+// Operands that end in a comma were meant to go on, but the next card was not read as their
+// continuation (no column-72 mark), so the operands that follow never reached the parser.
+const checked = (macro, parse) => (st, ops) => {
+  if (/,\s*$/.test(st.field)) throw new ImsSyntax(`${macro} operands end in a comma: the operands meant to follow were not read as a continuation`);
+  onlyKeywords(ops, macro, KEYWORDS[macro]);
+  return parse(st, ops);
+};
+
+export const parsers = Object.freeze({
+  DBD: checked('DBD', parseDBD),
+  DATASET: checked('DATASET', parseDATASET),
+  AREA: checked('AREA', parseAREA),
+  SEGM: checked('SEGM', parseSEGM),
+  FIELD: checked('FIELD', parseFIELD),
+  LCHILD: checked('LCHILD', parseLCHILD),
+  XDFLD: checked('XDFLD', parseXDFLD),
+  DBDGEN: checked('DBDGEN', parseDBDGEN)
+});