@portll/cobolwork 0.6.0 → 0.7.0

package/lib/ims/macro/psb.mjs

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for the IMS PSB macros: PCB (TYPE=TP, DB or GSAM), SENSEG, SENFLD and PSBGEN, after IMS 15.6
+// System Utilities, "Program Specification Block (PSB) Generation utility", and its PSBGEN messages.
+import { ImsSyntax, sublist, integer, onlyKeywords } from '../operands.mjs';
+
+const DB_PROCOPT = new Set('AGIRDPONTELSH');
+const SENSEG_PROCOPT = new Set('GIRDAEPK');
+const GSAM_PROCOPT = ['G', 'GS', 'L', 'LS'];
+// O, N and T are written only in these forms (the PCB syntax diagram; the O, N, T and H rules).
+const READ_WITHOUT_INTEGRITY = ['GO', 'GOP', 'GON', 'GONP', 'GOT', 'GOTP'];
+// PGEN110 adds PLI and PL1 to the statement page's list.
+const LANGS = ['COBOL', 'PL/I', 'PLI', 'PL1', 'ASSEM', 'PASCAL', 'JAVA', ''];
+const POSITIONS = { SINGLE: 'SINGLE', S: 'SINGLE', MULTIPLE: 'MULTIPLE', M: 'MULTIPLE' };
+
+const upper = (v) => (v == null ? null : String(v).trim().toUpperCase());
+const value = (ops, key) => ops.keywords.get(key) || null;
+
+function oneOf(macro, ops, key, allowed) {
+  const v = upper(ops.keywords.get(key));
+  if (v == null) return null;
+  if (!allowed.includes(v)) throw new ImsSyntax(`${macro} ${key} must be ${allowed.join(' or ')}`);
+  return v;
+}
+
+// YES or NO as a boolean, and the reference's default when the operand is absent.
+const yesNo = (macro, ops, key, absent) => { const v = oneOf(macro, ops, key, ['YES', 'NO']); return v == null ? absent : v === 'YES'; };
+
+function number(macro, ops, key, min, max) {
+  const raw = ops.keywords.get(key);
+  if (raw == null) return null;
+  const n = integer(raw);
+  if (n === null || n < min || n > max) throw new ImsSyntax(`${macro} ${key} must be an integer from ${min} to ${max}`);
+  return n;
+}
+
+function short(macro, what, v, most = 8) {
+  if (v != null && v.length > most) throw new ImsSyntax(`${macro} ${what} ${v} is longer than ${most} characters`);
+  return v;
+}
+
+// A PCB's own name, from its label or PCBNAME: at most 8 characters, and DFS is IMS's prefix.
+function pcbName(macro, what, v) {
+  short(macro, what, v);
+  if (v && v.startsWith('DFS')) throw new ImsSyntax(`${macro} ${what} ${v} begins with DFS, which is reserved for IMS`);
+  return v;
+}
+
+// The letters as written; each must be a processing option the statement takes, at most four (the
+// catalog holds PROCOPT in four bytes for a PCB and for a SENSEG).
+function procopt(macro, ops, letters) {
+  const v = upper(ops.keywords.get('PROCOPT'));
+  if (v == null) return null;
+  if (!v) throw new ImsSyntax(`${macro} PROCOPT is empty`);
+  for (const c of v) if (!letters.has(c)) throw new ImsSyntax(`${macro} PROCOPT ${v}: ${c} is not a processing option it takes`);
+  if (v.length > 4) throw new ImsSyntax(`${macro} PROCOPT ${v} has more than 4 options`);
+  return v;
+}
+
+const PCB_KEYWORDS = {
+  TP: ['TYPE', 'LTERM', 'NAME', 'ALTRESP', 'SAMETRM', 'MODIFY', 'EXPRESS', 'PCBNAME', 'EXTERNALNAME', 'LIST', 'REMARKS'],
+  DB: ['TYPE', 'DBDNAME', 'NAME', 'DBVER', 'PCBNAME', 'EXTERNALNAME', 'PROCOPT', 'SB', 'KEYLEN', 'PROCSEQ', 'PROCSEQD', 'PSELOPT', 'ACCESS', 'VIEW', 'LIST', 'REMARKS', 'POS'],
+  GSAM: ['TYPE', 'DBDNAME', 'NAME', 'PROCOPT', 'PCBNAME', 'EXTERNALNAME', 'LIST', 'REMARKS'],
+};
+
+function parsePCB(st, ops) {
+  const type = upper(ops.keywords.get('TYPE'));
+  if (!type) throw new ImsSyntax('PCB requires TYPE');
+  if (!PCB_KEYWORDS[type]) throw new ImsSyntax(`PCB TYPE ${type} is not TP, DB or GSAM`);
+  const macro = `PCB TYPE=${type}`;
+  onlyKeywords(ops, macro, PCB_KEYWORDS[type]);
+
+  const label = pcbName(macro, 'label', st.name || null);
+  const pcbname = pcbName(macro, 'PCBNAME', value(ops, 'PCBNAME'));
+  if (label && pcbname) {
+    if (type !== 'DB') throw new ImsSyntax(`${macro} takes a label or PCBNAME, not both`);
+    if (label !== pcbname) throw new ImsSyntax(`${macro} label ${label} and PCBNAME ${pcbname} must be the same name`);
+  }
+  const name = label || pcbname;
+  const list = yesNo(macro, ops, 'LIST', true);
+  if (!list && !name) throw new ImsSyntax(`${macro} LIST=NO needs the PCB named by a label or PCBNAME`);
+
+  const named = ['LTERM', 'DBDNAME', 'NAME'].filter((k) => ops.keywords.has(k));
+  if (named.length > 1) throw new ImsSyntax(`${macro} takes one of ${named.join(' and ')}`);
+  for (const k of named) short(macro, k, value(ops, k));
+
+  const externalname = value(ops, 'EXTERNALNAME');
+  short(macro, 'EXTERNALNAME', externalname, 128);
+  if (externalname && externalname.startsWith('DFS')) throw new ImsSyntax(`${macro} EXTERNALNAME ${externalname} begins with DFS`);
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+  const common = { kind: 'PCB', type, name, label, pcbname, externalname, list };
+
+  if (type === 'TP') {
+    const modify = yesNo(macro, ops, 'MODIFY', false);
+    const lterm = value(ops, 'LTERM');
+    const transaction = value(ops, 'NAME');
+    if (modify && (lterm || transaction)) throw new ImsSyntax(`${macro} MODIFY=YES takes no LTERM or NAME`);
+    if (!lterm && !transaction && !modify) throw new ImsSyntax(`${macro} requires LTERM or NAME unless MODIFY=YES`);
+    const destination = lterm ? { kind: 'LTERM', name: lterm } : transaction ? { kind: 'TRANSACTION', name: transaction } : null;
+    return {
+      ...common,
+      destination,
+      altresp: yesNo(macro, ops, 'ALTRESP', false),
+      sametrm: yesNo(macro, ops, 'SAMETRM', false),
+      modify,
+      express: yesNo(macro, ops, 'EXPRESS', false),
+      keywords
+    };
+  }
+
+  const dbd = value(ops, 'DBDNAME') || value(ops, 'NAME');
+  if (!dbd) throw new ImsSyntax(`${macro} requires DBDNAME or NAME`);
+
+  if (type === 'GSAM') {
+    if (!ops.keywords.has('PROCOPT')) throw new ImsSyntax(`${macro} requires PROCOPT`);
+    return { ...common, dbd, procopt: oneOf(macro, ops, 'PROCOPT', GSAM_PROCOPT), keywords };
+  }
+
+  const procseqd = value(ops, 'PROCSEQD');
+  for (const k of ['PSELOPT', 'ACCESS']) if (ops.keywords.has(k) && !procseqd) throw new ImsSyntax(`${macro} ${k} is valid only with PROCSEQD`);
+  const posRaw = upper(ops.keywords.get('POS'));
+  if (posRaw != null && !POSITIONS[posRaw]) throw new ImsSyntax(`${macro} POS must be SINGLE, S, MULTIPLE or M`);
+  if (!ops.keywords.has('KEYLEN')) throw new ImsSyntax(`${macro} requires KEYLEN`);
+  const letters = procopt(macro, ops, DB_PROCOPT);
+  if (letters && /[ONT]/.test(letters) && !READ_WITHOUT_INTEGRITY.includes(letters)) throw new ImsSyntax(`${macro} PROCOPT ${letters}: O, N and T are written only as ${READ_WITHOUT_INTEGRITY.join(', ')}`);
+
+  return {
+    ...common,
+    dbd,
+    dbver: number(macro, ops, 'DBVER', 0, 2147483647),
+    procopt: letters,
+    keylen: number(macro, ops, 'KEYLEN', 0, 32767),
+    pos: posRaw == null ? null : POSITIONS[posRaw],
+    procseq: short(macro, 'PROCSEQ', value(ops, 'PROCSEQ')),
+    procseqd,
+    pselopt: oneOf(macro, ops, 'PSELOPT', ['MULT', 'SNGL']),
+    access: pcbAccess(macro, ops),
+    sb: oneOf(macro, ops, 'SB', ['NO', 'COND']),
+    view: oneOf(macro, ops, 'VIEW', ['MSDB', 'MSDBL']),
+    keywords
+  };
+}
+
+// ACCESS=DB or ACCESS=INDEX (PCB237), INDEX also written (INDEX,VSAM) or (INDEX,SHISAM) on the statement page.
+function pcbAccess(macro, ops) {
+  const raw = ops.keywords.get('ACCESS');
+  if (raw == null) return null;
+  const items = sublist(raw).map((x) => x.toUpperCase());
+  const bare = !raw.trim().startsWith('(');
+  if (bare && items.length === 1 && (items[0] === 'DB' || items[0] === 'INDEX')) return { type: items[0], method: null };
+  if (!bare && items.length === 2 && items[0] === 'INDEX' && (items[1] === 'VSAM' || items[1] === 'SHISAM')) return { type: 'INDEX', method: items[1] };
+  throw new ImsSyntax(`${macro} ACCESS must be DB, INDEX, (INDEX,VSAM) or (INDEX,SHISAM)`);
+}
+
+function parseSENSEG(st, ops) {
+  const name = short('SENSEG', 'NAME', value(ops, 'NAME'));
+  if (!name) throw new ImsSyntax('SENSEG requires NAME');
+  const parentRaw = ops.keywords.get('PARENT');
+  if (parentRaw != null && !parentRaw.trim()) throw new ImsSyntax('SENSEG PARENT must be 0 or a segment name');
+  const parent = parentRaw == null || parentRaw.trim() === '0' ? null : short('SENSEG', 'PARENT', parentRaw.trim());
+
+  let indices = null;
+  const indicesRaw = ops.keywords.get('INDICES');
+  if (indicesRaw != null) {
+    indices = sublist(indicesRaw);
+    if (indices.some((x) => !x)) throw new ImsSyntax('SENSEG INDICES must be a secondary index name or a list of them');
+    if (indices.length > 32) throw new ImsSyntax('SENSEG INDICES names more than 32 secondary indexes');
+    for (const x of indices) short('SENSEG', 'INDICES name', x);
+  }
+
+  const letters = procopt('SENSEG', ops, SENSEG_PROCOPT);
+  const ssptr = subsetPointers(ops.keywords.get('SSPTR'));
+  if (ssptr && !parent) throw new ImsSyntax('SENSEG SSPTR is not supported on a root segment');
+  if (ssptr && letters && !/[ARID]/.test(letters)) {
+    const u = ssptr.find((p) => p.sensitivity === 'U');
+    if (u) throw new ImsSyntax(`SENSEG SSPTR pointer ${u.pointer} is update-sensitive, which PROCOPT ${letters} does not allow`);
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+  return { kind: 'SENSEG', name, parent, procopt: letters, ssptr, indices, keywords };
+}
+
+// SSPTR=((n[,R|U]),...): up to eight subset pointers numbered 1 to 8, read-sensitive unless U is given.
+function subsetPointers(raw) {
+  if (raw == null) return null;
+  const shape = 'SENSEG SSPTR must be ((n[,R|U]),...)';
+  if (!raw.trim().startsWith('(')) throw new ImsSyntax(shape);
+  const entries = sublist(raw);
+  if (entries.length > 8) throw new ImsSyntax('SENSEG SSPTR defines more than 8 subset pointers');
+  return entries.map((e) => {
+    if (!e.startsWith('(')) throw new ImsSyntax(shape);
+    const [n, sensitivity = 'R', ...rest] = sublist(e).map((x) => x.toUpperCase());
+    const pointer = integer(n);
+    if (rest.length || pointer === null || pointer < 1 || pointer > 8) throw new ImsSyntax('SENSEG SSPTR pointer number must be 1 to 8');
+    if (sensitivity !== 'R' && sensitivity !== 'U') throw new ImsSyntax('SENSEG SSPTR sensitivity must be R or U');
+    return { pointer, sensitivity };
+  });
+}
+
+function parseSENFLD(st, ops) {
+  const name = short('SENFLD', 'NAME', value(ops, 'NAME'));
+  if (!name) throw new ImsSyntax('SENFLD requires NAME');
+  if (!ops.keywords.has('START')) throw new ImsSyntax('SENFLD requires START');
+  if (ops.keywords.has('REPLACE') && ops.keywords.has('REPL')) throw new ImsSyntax('SENFLD takes REPLACE or REPL, not both');
+  const key = ops.keywords.has('REPL') ? 'REPL' : 'REPLACE';
+  const replace = oneOf('SENFLD', ops, key, ['YES', 'Y', 'NO', 'N']);
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+  return {
+    kind: 'SENFLD',
+    name,
+    start: number('SENFLD', ops, 'START', 1, 32767),
+    replace: replace == null || replace.startsWith('Y'),
+    keywords
+  };
+}
+
+function parsePSBGEN(st, ops) {
+  const psbname = short('PSBGEN', 'PSBNAME', value(ops, 'PSBNAME'));
+  if (!psbname) throw new ImsSyntax('PSBGEN requires PSBNAME');
+  const langRaw = upper(ops.keywords.get('LANG'));
+  if (langRaw != null && !LANGS.includes(langRaw)) throw new ImsSyntax('PSBGEN LANG must be COBOL, PL/I, PLI, PL1, ASSEM, PASCAL, JAVA or blank');
+
+  let ioeropn = null;
+  const ioeropnRaw = ops.keywords.get('IOEROPN');
+  if (ioeropnRaw != null) {
+    const parened = ioeropnRaw.trim().startsWith('(');
+    const items = sublist(ioeropnRaw).map((x) => x.toUpperCase());
+    const code = integer(items[0]);
+    const wtor = parened && items.length === 2 && items[1] === 'WTOR';
+    if (code === null || code > 4095 || (parened ? !wtor : items.length !== 1)) throw new ImsSyntax('PSBGEN IOEROPN must be n or (n,WTOR), n from 0 to 4095');
+    ioeropn = { code, wtor };
+  }
+
+  const keywords = {};
+  for (const [k, v] of ops.keywords) keywords[k] = v;
+  return {
+    kind: 'PSBGEN',
+    psbname,
+    dblevel: oneOf('PSBGEN', ops, 'DBLEVEL', ['CURR', 'BASE']),
+    lang: langRaw,
+    maxq: number('PSBGEN', ops, 'MAXQ', 0, 32767),
+    cmpat: yesNo('PSBGEN', ops, 'CMPAT', false),
+    ioasize: number('PSBGEN', ops, 'IOASIZE', 0, 256000),
+    ssasize: number('PSBGEN', ops, 'SSASIZE', 0, 256000),
+    ioeropn,
+    olic: yesNo('PSBGEN', ops, 'OLIC', false),
+    gsrolbok: yesNo('PSBGEN', ops, 'GSROLBOK', false),
+    lockmax: number('PSBGEN', ops, 'LOCKMAX', 0, 255),
+    keywords
+  };
+}
+
+// REMARKS is 1 to 256 characters inside its quotes, with no double quote, <, > or &.
+function remarks(macro, ops) {
+  const raw = ops.keywords.get('REMARKS');
+  if (raw == null) return;
+  const text = /^'([\s\S]*)'$/.exec(raw.trim())?.[1] ?? raw.trim();
+  if (!text || text.length > 256) throw new ImsSyntax(`${macro} REMARKS must be 1 to 256 characters`);
+  if (/["<>&]/.test(text)) throw new ImsSyntax(`${macro} REMARKS cannot contain a double quote, <, > or &`);
+}
+
+const KEYWORDS = {
+  SENSEG: ['NAME', 'PARENT', 'PROCOPT', 'SSPTR', 'INDICES', 'REMARKS'],
+  SENFLD: ['NAME', 'START', 'REPLACE', 'REPL', 'REMARKS'],
+  PSBGEN: ['PSBNAME', 'DBLEVEL', 'LANG', 'MAXQ', 'CMPAT', 'IOASIZE', 'SSASIZE', 'IOEROPN', 'OLIC', 'GSROLBOK', 'LOCKMAX', 'REMARKS'],
+};
+
+// An operand field that ends in a comma was meant to go on, but the next card was not read as its
+// continuation (no column-72 mark), so operands such as PROCOPT never reached the parser.
+const read = (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`);
+  if (KEYWORDS[macro]) onlyKeywords(ops, macro, KEYWORDS[macro]);
+  remarks(macro, ops);
+  return parse(st, ops);
+};
+
+export const parsers = Object.freeze({
+  PCB: read('PCB', parsePCB),
+  SENSEG: read('SENSEG', parseSENSEG),
+  SENFLD: read('SENFLD', parseSENFLD),
+  PSBGEN: read('PSBGEN', parsePSBGEN)
+});

package/lib/ims/model.mjs

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// A DBD or PSB as its generation utility builds it: segments with their fields, or PCBs with their
+// sensitive segments, and what DBDGEN or PSBGEN refuses in it, each under its message number in IMS
+// 15.6 Messages and Codes, Volume 2. A statement the reader could not read may hide a segment, so the
+// checks that need every segment named run only while none has been missed.
+import { readIms, parseImsStatement, IMS_MACROS } from './read.mjs';
+import { sublist } from './operands.mjs';
+
+const DBD_MACROS = new Set(['DBD', 'DATASET', 'AREA', 'SEGM', 'FIELD', 'LCHILD', 'XDFLD', 'DBDGEN']);
+const PSB_MACROS = new Set(['PCB', 'SENSEG', 'SENFLD', 'PSBGEN']);
+
+export function modelOf(text) {
+  const read = readIms(text).statements.map((st) => ({ st, r: parseImsStatement(st) }));
+  const first = read.find(({ st }) => DBD_MACROS.has(st.operation) || PSB_MACROS.has(st.operation));
+  if (!first) return null;
+  return DBD_MACROS.has(first.st.operation) ? dbdModel(read) : psbModel(read);
+}
+
+// PARENT=name, PARENT=((name,SNGL|DBLE),(lparent,VIRTUAL|PHYSICAL,dbname)) or PARENT=0.
+function parents(raw) {
+  if (raw == null) return { physical: null, logical: null };
+  const [first, second] = sublist(raw);
+  const physical = first.startsWith('(') ? sublist(first)[0] : first;
+  const logical = second ? sublist(second)[0] : null;
+  return { physical: physical === '0' ? null : physical, logical };
+}
+
+const unreadOf = (st, r) => ({ line: st.line, operation: st.operation ?? null, reason: r.reason ?? r.status });
+
+// A statement that is not an IMS macro (a macro call, COPY) or a SEGM the reader refused may define a
+// segment the model never saw.
+const mayHideSegment = (st) => st.operation === 'SEGM' || !IMS_MACROS.has(st.operation);
+
+function dbdModel(read) {
+  const model = { kind: 'DBD', name: null, access: null, segments: [], unread: [], problems: [], complete: true };
+  const problem = (line, message, text) => model.problems.push({ line, message, text });
+  const segments = new Map();
+  let segment;                  // the SEGM the next FIELD belongs to: undefined before any, null after an unread one
+
+  for (const { st, r } of read) {
+    if (r.status !== 'parsed') {
+      model.unread.push(unreadOf(st, r));
+      if (mayHideSegment(st)) model.complete = false;
+      if (st.operation === 'SEGM') segment = null;
+      else if (segment && (st.operation === 'FIELD' || st.operation === 'XDFLD')) segment.fieldStatements++;
+      continue;
+    }
+    const n = r.node;
+    if (n.kind === 'DBD') {
+      model.name = n.name;
+      model.access = n.access;
+    } else if (n.kind === 'SEGM') {
+      const { physical, logical } = parents(n.keywords.PARENT);
+      segment = { name: n.name, parent: physical, logicalParent: logical, bytes: n.bytes, line: st.line, fields: [], fieldStatements: 0 };
+      if (segments.has(n.name)) problem(st.line, 'SEGM140', `segment ${n.name} is defined twice`);
+      else if (physical && !segments.has(physical) && model.complete) problem(st.line, 'SEGM170', `segment ${n.name} names parent ${physical}, which no earlier SEGM defines`);
+      segments.set(n.name, segment);
+      model.segments.push(segment);
+    } else if (n.kind === 'FIELD' || n.kind === 'XDFLD') {
+      if (segment === undefined) { problem(st.line, 'FLD100', `${n.kind} ${n.name ?? n.keywords.NAME} comes before any SEGM`); continue; }
+      if (segment === null) continue;
+      field(segment, n, st.line, problem);
+    }
+  }
+  for (const s of model.segments) {
+    const seq = s.fields.filter((f) => f.seq);
+    if (seq.length > 1 && !s.logicalParent) problem(seq[1].line, 'FLD120', `segment ${s.name} has ${seq.length} sequence fields`);
+  }
+  return model;
+}
+
+function field(segment, n, line, problem) {
+  const position = segment.fieldStatements++;
+  const name = n.kind === 'FIELD' ? n.name : n.keywords.NAME;
+  if (segment.fields.some((f) => f.name === name)) problem(line, 'FLD190', `field ${name} is defined twice in segment ${segment.name}`);
+  if (n.kind === 'XDFLD') { segment.fields.push({ name, kind: 'XDFLD', seq: false, line }); return; }
+
+  const f = { name, kind: 'FIELD', seq: n.seq, unique: n.unique, bytes: n.bytes, start: n.start, type: n.type, line };
+  if (f.seq && position > 0 && !segment.fields.some((x) => x.seq)) problem(line, 'FLD230', `sequence field ${name} is not the first field of segment ${segment.name}`);
+  // System-related fields (/SX, /CK) take START relative to the concatenated key, not the segment.
+  const systemRelated = name.startsWith('/');
+  if (!systemRelated && segment.bytes && f.start != null && f.bytes != null && f.start + f.bytes - 1 > segment.bytes.max) {
+    problem(line, 'FLD170', `field ${name} ends at byte ${f.start + f.bytes - 1}, past segment ${segment.name}'s ${segment.bytes.max} bytes`);
+  }
+  segment.fields.push(f);
+}
+
+function psbModel(read) {
+  const model = { kind: 'PSB', name: null, lang: null, pcbs: [], unread: [], problems: [] };
+  const problem = (line, message, text) => model.problems.push({ line, message, text });
+  let pcb;                      // the PCB the next SENSEG belongs to: undefined before any, null after an unread one
+
+  for (const { st, r } of read) {
+    if (r.status !== 'parsed') {
+      model.unread.push(unreadOf(st, r));
+      if (st.operation === 'PCB') pcb = null;
+      else if (pcb && (st.operation === 'SENSEG' || !IMS_MACROS.has(st.operation))) pcb.complete = false;
+      continue;
+    }
+    const n = r.node;
+    if (n.kind === 'PSBGEN') {
+      model.name = n.psbname;
+      model.lang = n.lang;
+    } else if (n.kind === 'PCB') {
+      pcb = {
+        name: n.name ?? `PCB ${model.pcbs.length + 1}`,
+        type: n.type,
+        dbd: n.dbd ?? null,
+        // PROCOPT=A is the default (Full-function or Fast Path database PCB statement).
+        procopt: n.type === 'DB' ? n.procopt ?? 'A' : n.procopt ?? null,
+        procoptWritten: n.procopt ?? null,
+        keylen: n.keylen ?? null,
+        procseq: n.procseq ?? n.procseqd ?? null,
+        line: st.line,
+        sensegs: [],
+        complete: true,
+      };
+      model.pcbs.push(pcb);
+    } else if (n.kind === 'SENSEG') {
+      if (pcb === undefined) { problem(st.line, 'SEG110', `SENSEG ${n.name} comes before any PCB`); continue; }
+      if (pcb === null) continue;
+      senseg(pcb, n, st.line, problem);
+    }
+  }
+  return model;
+}
+
+function senseg(pcb, n, line, problem) {
+  if (pcb.type !== 'DB') { problem(line, 'SEG140', `SENSEG ${n.name} follows ${pcb.type} PCB ${pcb.name}`); return; }
+  if (pcb.sensegs.some((s) => s.name === n.name)) problem(line, 'SEG150', `SENSEG ${n.name} appears twice in PCB ${pcb.name}`);
+  else if (n.parent && pcb.complete && !pcb.sensegs.some((s) => s.name === n.parent)) problem(line, 'SEG160', `SENSEG ${n.name} names parent ${n.parent}, which no earlier SENSEG of PCB ${pcb.name} defines`);
+  // A SENSEG without PROCOPT takes the PCB's (SENSEG statement).
+  pcb.sensegs.push({ name: n.name, parent: n.parent, procopt: n.procopt ?? pcb.procopt, procoptWritten: n.procopt ?? null, line });
+}
+
+// The bytes of the concatenated key of a segment: the first sequence field of each segment from the
+// root down, along the DBD's physical parents. A segment with no sequence field adds nothing here, so
+// the figure is never more than IMS's. Null when the path leaves the segments the model holds.
+export function concatenatedKey(dbd, name) {
+  const byName = new Map(dbd.segments.map((s) => [s.name, s]));
+  const seen = new Set();
+  let total = 0;
+  for (let at = name; at; at = byName.get(at).parent) {
+    if (!byName.has(at) || seen.has(at)) return null;
+    seen.add(at);
+    total += byName.get(at).fields.find((f) => f.seq)?.bytes ?? 0;
+  }
+  return total;
+}

package/lib/ims/operands.mjs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// What an IMS macro parser needs to read operands: the refusal it throws, and sublists and integers.
+import { splitOperands } from '../cards.mjs';
+
+export class ImsSyntax extends Error {
+  constructor(message) { super(message); this.name = 'ImsSyntax'; }
+}
+
+// (A,B) and A both as a list of trimmed entries; null when absent.
+export const sublist = (v) => {
+  if (v == null) return null;
+  const inner = /^\(([\s\S]*)\)$/.exec(String(v).trim());
+  return (inner ? splitOperands(inner[1]) : [String(v)]).map((x) => x.trim());
+};
+
+export const integer = (v) => (/^\d+$/.test(String(v ?? '').trim()) ? Number(String(v).trim()) : null);
+
+// IMS macro operands are keywords: a positional operand, or a keyword the macro does not take, is
+// refused so that a statement counts as read only when every operand on it was understood.
+export function onlyKeywords(ops, macro, allowed) {
+  if (ops.positional.length) throw new ImsSyntax(`${macro} takes no positional operand: ${ops.positional[0]}`);
+  for (const k of ops.keywords.keys()) if (!allowed.includes(k)) throw new ImsSyntax(`${macro} has no ${k} operand`);
+}

package/lib/ims/read.mjs

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// IMS DBD and PSB source, read as the assembler reads its macro cards (lib/bms.mjs folds them), and
+// each statement parsed by its macro's parser: DBD, DATASET, SEGM, FIELD, LCHILD, XDFLD and DBDGEN
+// for a database, PCB, SENSEG, SENFLD and PSBGEN for a program's view of it.
+import { foldStatements } from '../bms.mjs';
+import { parseOperands } from '../cards.mjs';
+import { ImsSyntax } from './operands.mjs';
+import { parsers as dbd } from './macro/dbd.mjs';
+import { parsers as psb } from './macro/psb.mjs';
+
+export const PARSERS = Object.freeze({ ...dbd, ...psb });
+
+// Assembler instructions around the macros, which carry nothing for IMS.
+const ASSEMBLER = new Set(['TITLE', 'PRINT', 'EJECT', 'SPACE', 'END', 'FINISH', 'ICTL', 'ISEQ', 'PUNCH']);
+export const IMS_MACROS = new Set(['DBD', 'DATASET', 'AREA', 'SEGM', 'FIELD', 'LCHILD', 'XDFLD', 'DBDGEN', 'PCB', 'SENSEG', 'SENFLD', 'PSBGEN']);
+
+export function readIms(text) {
+  const { statements, diags } = foldStatements(text);
+  return { statements: statements.filter((s) => s.kind !== 'comment'), diags };
+}
+
+// { kind, status, node?, reason? } as the PL/I reader gives them: parsed, unbuilt (no parser for the
+// macro yet), unparsed (the parser refused an operand) or unknown (not an IMS macro).
+export function parseImsStatement(st) {
+  if (st.kind !== 'statement') return { kind: 'UNREADABLE', status: 'unknown', reason: 'no operation field' };
+  const kind = st.operation;
+  if (ASSEMBLER.has(kind)) return { kind: 'ASSEMBLER', status: 'parsed', node: { kind, operation: kind } };
+  if (!IMS_MACROS.has(kind)) return { kind: 'UNKNOWN', status: 'unknown', reason: `${kind} is not an IMS DBD or PSB macro` };
+  const parser = PARSERS[kind];
+  if (!parser) return { kind, status: 'unbuilt' };
+  try {
+    return { kind, status: 'parsed', node: parser(st, parseOperands(st.field)) };
+  } catch (e) {
+    if (e instanceof ImsSyntax) return { kind, status: 'unparsed', reason: e.message };
+    return { kind, status: 'unparsed', reason: `parser error: ${e && e.message}`, crash: true };
+  }
+}

package/lib/ims/rules.mjs

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Rules over IMS DBD and PSB source alone: what a database PCB lets a program change, SENSEGs naming
+// segments their DBD does not define, and what DBDGEN, PSBGEN or ACBGEN refuses.
+import { modelOf, concatenatedKey } from './model.mjs';
+import { DLI_FUNCTIONS } from './dli.mjs';
+
+export const IMS_RULES = Object.freeze({
+  'ims-pcb-procopt-all': { sev: 'info', evidence: 'context', cwe: 'CWE-250', text: 'A database PCB lets the program get, insert, replace and delete its sensitive segments' },
+  'ims-senseg-unknown-segment': {
+    sev: 'low', evidence: 'construct', cwe: 'CWE-1076',
+    text: "A SENSEG names a segment its PCB's DBD does not define, which ends the program with abend U0914",
+    impact: 'The PSB cannot be scheduled against the DBD in this tree: the program abends before it runs, or the DBD here is not the one production uses',
+    remedy: 'Correct the SENSEG name, or bring the DBD in the tree up to the one the PSB was generated against',
+  },
+  'ims-procopt-broader-than-used': {
+    sev: 'high', evidence: 'construct', cwe: 'CWE-250',
+    text: "A PSB grants a processing option that no DL/I call of the program it is named for uses",
+    impact: 'The program can insert, replace or delete segments it never needs to change, so a flaw in it, or input that steers it, can alter the database beyond what its own calls show',
+    remedy: "Set the PCB's PROCOPT, or each SENSEG's, to the options the program's calls use, and regenerate the PSB and its ACB",
+  },
+  'ims-definition-inconsistent': {
+    sev: 'low', evidence: 'construct', cwe: 'CWE-1076',
+    text: 'A DBD or PSB holds what DBDGEN, PSBGEN or ACBGEN refuses',
+    impact: 'The generation step refuses the definition, or the program abends when it is scheduled (U0919 for a KEYLEN too short), so the source in the tree does not describe what runs',
+    remedy: 'Correct the statement the message names and regenerate; where production runs a different definition, keep that one in the tree',
+  },
+});
+
+const OPTION_NAME = { G: 'get', I: 'insert', R: 'replace', D: 'delete' };
+
+// The database options a PROCOPT grants: A is all four, and R and D each imply G.
+function granted(procopt) {
+  const p = String(procopt || '');
+  const out = new Set(p.includes('A') ? ['G', 'I', 'R', 'D'] : [...p].filter((c) => OPTION_NAME[c]));
+  if (out.has('R') || out.has('D')) out.add('G');
+  return out;
+}
+
+// Each PSB a program is known to run with, against the DL/I calls of every such program. A program
+// is linked to a PSB by a DFSRRC00 step's PARM or by its own scheduling call, [{ program, psb, at }],
+// and a PSB nothing links to is taken as its program's when PSBGEN PSBNAME, or else its file name,
+// names one. `programs` holds [{ id, path, line, functions }], functions null when a program's calls
+// cannot all be told. A call is not tied to its PCB, so only an option no call of any of the PSB's
+// programs uses is reported, on each database PCB that grants it.
+export function checkProcoptAgainstCalls(models, programs, links = []) {
+  const byId = new Map();
+  for (const p of programs) byId.set(p.id.toUpperCase(), byId.has(p.id.toUpperCase()) ? null : p);
+  const users = new Map();
+  for (const l of links) {
+    if (!users.has(l.psb)) users.set(l.psb, new Map());
+    users.get(l.psb).set(l.program, l.at);
+  }
+  const findings = [];
+  for (const { path, model } of models) {
+    if (model.kind !== 'PSB') continue;
+    const fileName = path.split('/').pop().replace(/\.[^.]*$/, '').toUpperCase();
+    const name = String(model.name || fileName).toUpperCase();
+    let linked = users.get(name);
+    if (!linked) {
+      const own = byId.has(name) ? name : byId.has(fileName) ? fileName : null;
+      if (!own) continue;
+      linked = new Map([[own, null]]);
+    }
+    const progs = [...linked.keys()].map((id) => byId.get(id));
+    if (progs.some((p) => !p || !p.functions)) continue;
+    const functions = new Set(progs.flatMap((p) => [...p.functions]));
+    const used = new Set([...functions].map((fn) => DLI_FUNCTIONS[fn]));
+    if (used.has('R') || used.has('D')) used.add('G');
+    const who = progs.map((p) => `${p.id} (${p.path}:${p.line}${linked.get(p.id.toUpperCase()) ? `, run with it at ${linked.get(p.id.toUpperCase())}` : ''})`).join(', ');
+    for (const pcb of model.pcbs.filter((x) => x.type === 'DB')) {
+      const grants = new Set([...granted(pcb.procopt), ...pcb.sensegs.flatMap((s) => [...granted(s.procopt)])]);
+      const unused = ['G', 'I', 'R', 'D'].filter((c) => grants.has(c) && !used.has(c));
+      if (!unused.length) continue;
+      const written = pcb.procoptWritten ? `PROCOPT=${pcb.procoptWritten}` : 'PROCOPT omitted, so A,';
+      findings.push({ rule: 'ims-procopt-broader-than-used', path, line: pcb.line, sev: IMS_RULES['ims-procopt-broader-than-used'].sev,
+        detail: `PSB ${model.name ?? fileName} PCB ${pcb.name} on DBD ${pcb.dbd}: ${written} grants ${unused.map((c) => OPTION_NAME[c]).join(', ')}, which no DL/I call of ${who} uses; ${progs.length > 1 ? 'they issue' : 'it issues'} ${[...functions].sort().join(', ')}` });
+    }
+  }
+  return findings;
+}
+
+// A holds G, I, R and D; R and D each imply G, so I, R and D together are all four.
+const changesEverything = (procopt) => !!procopt && (procopt.includes('A') || ['I', 'R', 'D'].every((c) => procopt.includes(c)));
+
+export const checkIms = (files) => checkModels(files.map(({ path, text }) => ({ path, model: modelOf(text) })).filter((m) => m.model));
+
+// Findings over models already read, [{ path, model }], DBDs and PSBs together so a PCB can be
+// checked against its DBD.
+export function checkModels(models) {
+  const dbds = new Map();
+  for (const { model } of models.filter((m) => m.model.kind === 'DBD' && m.model.name)) {
+    dbds.set(model.name, dbds.has(model.name) ? null : model);
+  }
+
+  const findings = [];
+  for (const { path, model } of models) {
+    const at = (rule, line, detail) => findings.push({ rule, path, line, sev: IMS_RULES[rule].sev, detail });
+    for (const p of model.problems) at('ims-definition-inconsistent', p.line, `${p.message}: ${p.text}`);
+    if (model.kind !== 'PSB') continue;
+    for (const pcb of model.pcbs.filter((x) => x.type === 'DB')) {
+      const where = `PSB ${model.name ?? '(no PSBGEN)'} PCB ${pcb.name} on DBD ${pcb.dbd}`;
+      procoptAll(pcb, where, at);
+      const dbd = dbds.get(pcb.dbd);
+      if (dbd) againstDbd(pcb, dbd, where, at);
+    }
+  }
+  return findings;
+}
+
+function procoptAll(pcb, where, at) {
+  const full = pcb.sensegs.filter((s) => changesEverything(s.procopt));
+  if (pcb.sensegs.length ? !full.length : !changesEverything(pcb.procopt)) return;
+  const written = pcb.procoptWritten ? `PROCOPT=${pcb.procoptWritten}` : 'PROCOPT omitted, so A,';
+  const segments = pcb.sensegs.length ? `segments ${full.map((s) => s.name).join(', ')}` : 'every sensitive segment';
+  at('ims-pcb-procopt-all', pcb.line, `${where}: ${written} gives get, insert, replace and delete on ${segments}`);
+}
+
+// Checks that need the PCB's DBD: SENSEGs it does not define (abend U0914), and a KEYLEN shorter than
+// the longest concatenated key (DFS0919I at ACBGEN). A secondary processing sequence or a logical DBD
+// builds keys from other segments, so KEYLEN is checked only on the physical path of a physical DBD.
+function againstDbd(pcb, dbd, where, at) {
+  const defined = new Set(dbd.segments.map((s) => s.name));
+  if (dbd.complete) {
+    for (const s of pcb.sensegs.filter((x) => !defined.has(x.name))) at('ims-senseg-unknown-segment', s.line, `${where}: SENSEG ${s.name} is not a segment of DBD ${dbd.name}`);
+  }
+  if (pcb.keylen == null || pcb.procseq || dbd.access?.type === 'LOGICAL') return;
+  let longest = null;
+  for (const s of pcb.sensegs) {
+    const key = concatenatedKey(dbd, s.name);
+    if (key != null && (!longest || key > longest.key)) longest = { key, name: s.name };
+  }
+  if (longest && longest.key > pcb.keylen) {
+    at('ims-definition-inconsistent', pcb.line, `DFS0919I: ${where} has KEYLEN=${pcb.keylen}, shorter than the ${longest.key}-byte concatenated key of ${longest.name}`);
+  }
+}