@portll/cobolwork 0.5.0 → 0.7.0

package/lib/pli/rules/entry.mjs

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I rules on calls through entry variables and FETCH of a non-literal title.
+
+export const RULES = {
+  'pli-entry-variable-call': {
+    sev: 'info',
+    evidence: 'coverage',
+    cwe: 'CWE-470',
+    text: 'A CALL through an entry variable dispatches to a procedure chosen at run time, so the callee is not known statically',
+  },
+  'pli-fetch-title-variable': {
+    sev: 'med',
+    evidence: 'construct',
+    cwe: 'CWE-494',
+    text: 'A FETCH whose TITLE is not a literal names the module to load at run time',
+    impact: 'FETCH loads the load module whose name the TITLE value holds when the statement runs, so whatever sets that value chooses the code the program then calls, with the program\'s authority',
+    remedy: 'Give FETCH a literal TITLE where the module is fixed; where it must vary, check the name against a list of the modules the program may load before the FETCH',
+  },
+};
+
+function walkUnits(units, visit) {
+  if (!Array.isArray(units)) return;
+  for (const u of units) {
+    if (!u || typeof u !== 'object') continue;
+    visit(u);
+    if (u.node && typeof u.node === 'object') walkUnits(u.node.units, visit);
+  }
+}
+
+function eachParsed(program, visit) {
+  for (const st of program.statements) {
+    if (!st || !st.parsed || st.parsed.status !== 'parsed') continue;
+    visit(st);
+    walkUnits(st.parsed.node && st.parsed.node.units, (u) => {
+      if (u && u.status === 'parsed') visit({ line: st.line, parsed: u });
+    });
+  }
+}
+
+function isEntryVariable(item) {
+  if (!item || !Array.isArray(item.attributes)) return false;
+  const names = new Set(item.attributes.map((a) => (a && a.name ? String(a.name).toUpperCase() : '')));
+  return names.has('ENTRY') && names.has('VARIABLE');
+}
+
+function isEntryMember(item) {
+  if (!item || !Array.isArray(item.attributes)) return false;
+  const names = new Set(item.attributes.map((a) => (a && a.name ? String(a.name).toUpperCase() : '')));
+  return names.has('ENTRY') && !names.has('VARIABLE');
+}
+
+function isProcedure(name, procedures) {
+  return procedures.has(String(name || '').toUpperCase());
+}
+
+const isLiteralTitle = (title) => !!title && title.tree && title.tree.t === 'lit';
+
+export function check(program) {
+  const findings = [];
+  if (!program || !Array.isArray(program.statements)) return findings;
+
+  const entryVariables = new Map();
+  const entryMembers = new Set();
+  const procedures = new Set();
+
+  eachParsed(program, (st) => {
+    const node = st.parsed && st.parsed.node;
+    if (!node || typeof node !== 'object') return;
+    if (node.kind === 'DECLARE' && Array.isArray(node.items)) {
+      for (const item of node.items) {
+        if (!item || !item.name) continue;
+        const key = String(item.name).toUpperCase();
+        // A member of a structure is a variable whatever it declares.
+        if (isEntryVariable(item) || (item.level > 1 && isEntryMember(item))) entryVariables.set(key, item.name);
+        else if (isEntryMember(item)) entryMembers.add(key);
+      }
+    } else if (node.kind === 'PROCEDURE' && node.name) {
+      procedures.add(String(node.name).toUpperCase());
+    }
+  });
+
+  const assignedConstants = new Map();
+  eachParsed(program, (st) => {
+    const node = st.parsed && st.parsed.node;
+    if (!node || node.kind !== 'ASSIGNMENT') return;
+    const ref = node.value && node.value.tree;
+    if (!Array.isArray(node.targets) || !ref || ref.t !== 'ref' || !ref.name) return;
+    const valueName = String(ref.name).toUpperCase();
+    if (!procedures.has(valueName) && !entryMembers.has(valueName)) return;
+    for (const target of node.targets) {
+      if (!target || target.t !== 'ref' || !target.name) continue;
+      const key = String(target.name).toUpperCase();
+      if (!entryVariables.has(key)) continue;
+      if (!assignedConstants.has(key)) assignedConstants.set(key, new Set());
+      assignedConstants.get(key).add(ref.name);
+    }
+  });
+
+  eachParsed(program, (st) => {
+    const node = st.parsed && st.parsed.node;
+    if (!node || typeof node !== 'object') return;
+    if (node.kind === 'CALL') {
+      const callee = node.callee;
+      if (!callee || callee.t !== 'ref' || !callee.name) return;
+      const key = String(callee.name).toUpperCase();
+      if (entryVariables.has(key)) {
+        const varName = entryVariables.get(key);
+        const constants = assignedConstants.get(key);
+        const detail = constants && constants.size
+          ? `CALL ${callee.name} dispatches through an entry variable assigned ${[...constants].join(', ')}`
+          : `CALL ${callee.name} dispatches through an entry variable with no entry constant assigned in this program`;
+        findings.push({ rule: 'pli-entry-variable-call', path: program.path, line: st.line, detail });
+      }
+    } else if (node.kind === 'FETCH' && Array.isArray(node.entries)) {
+      for (const entry of node.entries) {
+        if (!entry || entry.title === null || entry.title === undefined) continue;
+        if (isLiteralTitle(entry.title)) continue;
+        const name = entry.name || 'FETCH';
+        findings.push({
+          rule: 'pli-fetch-title-variable',
+          path: program.path,
+          line: st.line,
+          detail: `FETCH ${name} loads a module named at run time because its TITLE is not a literal`,
+        });
+      }
+    }
+  });
+
+  return findings;
+}

package/lib/pli/rules/index.mjs

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// The PL/I rules: each module checks one parsed program and returns findings. A program is
+// { path, statements } where each statement is as readPli gives it with `parsed`, its parseStatement
+// result, attached.
+import { readPli } from '../lex.mjs';
+import { parseStatement } from '../statements.mjs';
+import * as based from './based.mjs';
+import * as entry from './entry.mjs';
+import * as preprocessor from './preprocessor.mjs';
+import * as conditions from './conditions.mjs';
+
+const MODULES = [based, entry, preprocessor, conditions];
+
+export const PLI_RULES = Object.freeze(Object.assign({}, ...MODULES.map((m) => m.RULES)));
+
+export function programOf(path, text) {
+  const statements = readPli(text, { file: path }).statements.map((st) => ({ ...st, parsed: parseStatement(st) }));
+  return { path, statements };
+}
+
+// Findings { rule, path, line, detail } for one program, in source order.
+export function checkProgram(program) {
+  return MODULES.flatMap((m) => m.check(program)).sort((a, b) => a.line - b.line || (a.rule < b.rule ? -1 : 1));
+}

package/lib/pli/rules/preprocessor.mjs

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I rules on preprocessor use.
+
+export const RULES = {
+  'pli-preprocessor-in-use': {
+    sev: 'info',
+    evidence: 'coverage',
+    cwe: 'CWE-1059',
+    text: 'A program uses PL/I preprocessor directives, so the source text is not the code that is compiled'
+  }
+};
+
+// Directives that change the text compiled; INCLUDE is read through and listing directives change nothing.
+const DIRECTIVES = new Set(['IF', 'DO', 'DCL', 'DECLARE', 'ASSIGN', 'ACT', 'ACTIVATE', 'DEACT', 'DEACTIVATE', 'PROC', 'PROCEDURE', 'SELECT', 'REPLACE', 'GO', 'GOTO']);
+
+function collectDirectives(node, set) {
+  if (!node) return;
+  if (node.kind === 'PREPROCESSOR' && typeof node.directive === 'string') {
+    const d = node.directive.toUpperCase();
+    if (DIRECTIVES.has(d)) set.add(d);
+  }
+  if (Array.isArray(node.units)) {
+    for (const u of node.units) {
+      if (u && u.node) collectDirectives(u.node, set);
+    }
+  }
+}
+
+export function check(program) {
+  const findings = [];
+  const directives = new Set();
+  let firstLine = null;
+
+  for (const st of program.statements) {
+    if (!st.parsed || st.parsed.status !== 'parsed') continue;
+    const node = st.parsed.node;
+    if (!node) continue;
+    collectDirectives(node, directives);
+    if (directives.size > 0 && firstLine === null) {
+      firstLine = st.line;
+    }
+  }
+
+  if (firstLine !== null) {
+    const list = [...directives].sort().join(', ');
+    findings.push({
+      rule: 'pli-preprocessor-in-use',
+      path: program.path,
+      line: firstLine,
+      detail: `preprocessor directives ${list} alter the source before compilation`
+    });
+  }
+
+  return findings;
+}

package/lib/pli/statements.mjs

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Which kind each PL/I statement is, and its parse by that kind's parser. PL/I reserves no words, so
+// a statement is an assignment whenever it reads as references followed by '=', and a keyword
+// statement only otherwise: `IF = 1;` assigns to a variable named IF.
+import { cursor, PliSyntax } from './cursor.mjs';
+import { parsers as declare } from './stmt/declare.mjs';
+import { parsers as procedure } from './stmt/procedure.mjs';
+import { parsers as control } from './stmt/control.mjs';
+import { parsers as call } from './stmt/call.mjs';
+import { parsers as assignment } from './stmt/assignment.mjs';
+import { parsers as io } from './stmt/io.mjs';
+import { parsers as stream } from './stmt/stream.mjs';
+import { parsers as conditions } from './stmt/conditions.mjs';
+import { parsers as alloc } from './stmt/alloc.mjs';
+import { parsers as exec } from './stmt/exec.mjs';
+import { parsers as preprocessor } from './stmt/preprocessor.mjs';
+import { parsers as misc } from './stmt/misc.mjs';
+
+export const PARSERS = Object.freeze({ ...declare, ...procedure, ...control, ...call, ...assignment, ...io, ...stream, ...conditions, ...alloc, ...exec, ...preprocessor, ...misc });
+
+const KEYWORDS = new Map(Object.entries({
+  DECLARE: 'DECLARE', DCL: 'DECLARE', DEFAULT: 'DEFAULT', DFT: 'DEFAULT', DEFINE: 'DEFINE',
+  PROCEDURE: 'PROCEDURE', PROC: 'PROCEDURE', ENTRY: 'ENTRY', PACKAGE: 'PACKAGE', BEGIN: 'BEGIN', END: 'END',
+  DO: 'DO', IF: 'IF', ELSE: 'ELSE', SELECT: 'SELECT', WHEN: 'WHEN', OTHERWISE: 'OTHERWISE', OTHER: 'OTHERWISE',
+  LEAVE: 'LEAVE', ITERATE: 'ITERATE', GO: 'GOTO', GOTO: 'GOTO', RETURN: 'RETURN', STOP: 'STOP', EXIT: 'EXIT',
+  CALL: 'CALL', FETCH: 'FETCH', RELEASE: 'RELEASE',
+  OPEN: 'OPEN', CLOSE: 'CLOSE', READ: 'READ', WRITE: 'WRITE', REWRITE: 'REWRITE', DELETE: 'DELETE', LOCATE: 'LOCATE',
+  UNLOCK: 'UNLOCK', GET: 'GET', PUT: 'PUT', DISPLAY: 'DISPLAY', FORMAT: 'FORMAT', FLUSH: 'FLUSH',
+  ON: 'ON', SIGNAL: 'SIGNAL', REVERT: 'REVERT', RESIGNAL: 'RESIGNAL',
+  ALLOCATE: 'ALLOCATE', ALLOC: 'ALLOCATE', FREE: 'FREE',
+  EXEC: 'EXEC', EXECUTE: 'EXEC',
+  WAIT: 'WAIT', DELAY: 'DELAY', ATTACH: 'ATTACH', DETACH: 'DETACH', ASSERT: 'ASSERT', QUALIFY: 'QUALIFY',
+}));
+
+const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '|=', '&=', '||=', '**=']);
+
+// Where a reference starting at `i` ends: name, then any mix of (subscripts), '.' name and
+// '->' or '=>' name. -1 when `i` does not start one.
+function referenceEnd(toks, i) {
+  if (!toks[i] || toks[i].t !== 'word') return -1;
+  let k = i + 1;
+  for (;;) {
+    const t = toks[k];
+    if (t && t.t === 'op' && t.v === '(') {
+      let depth = 0;
+      for (; k < toks.length; k++) {
+        if (toks[k].t !== 'op') continue;
+        if (toks[k].v === '(') depth++;
+        else if (toks[k].v === ')' && --depth === 0) break;
+      }
+      if (k >= toks.length) return -1;
+      k++;
+      continue;
+    }
+    if (t && t.t === 'op' && (t.v === '.' || t.v === '->' || t.v === '=>') && toks[k + 1] && toks[k + 1].t === 'word') { k += 2; continue; }
+    return k;
+  }
+}
+
+export function isAssignment(toks) {
+  let i = 0;
+  for (;;) {
+    const end = referenceEnd(toks, i);
+    if (end < 0) return false;
+    const t = toks[end];
+    if (t && t.t === 'op' && ASSIGN_OPS.has(t.v)) return true;
+    if (t && t.t === 'op' && t.v === ',') { i = end + 1; continue; }
+    return false;
+  }
+}
+
+function thenFollows(toks) {
+  let depth = 0;
+  for (const t of toks.slice(1)) {
+    if (t.t === 'op' && t.v === '(') depth++;
+    else if (t.t === 'op' && t.v === ')') depth--;
+    else if (depth === 0 && t.t === 'word' && t.u === 'THEN') return true;
+  }
+  return false;
+}
+
+export function classify(stmt) {
+  const toks = stmt.toks;
+  if (!toks.length) return 'NULL';
+  if (toks[0].t === 'op' && toks[0].v === '%') return 'PREPROCESSOR';
+  // PL/I reserves no words, so IF (X) = 0 could assign to an array IF; a THEN at depth 0 makes it
+  // the IF statement, as the compiler reads it.
+  if (toks[0].t === 'word' && toks[0].u === 'IF' && thenFollows(toks)) return 'IF';
+  if (isAssignment(toks)) return 'ASSIGNMENT';
+  // An %INCLUDE member holding the middle of a structure starts at a level number.
+  if (toks[0].t === 'num' && /^\d+$/.test(toks[0].v) && toks[1] && toks[1].t === 'word') return 'DECLARE_FRAGMENT';
+  if (toks[0].t !== 'word') return 'UNKNOWN';
+  return KEYWORDS.get(toks[0].u) || 'UNKNOWN';
+}
+
+// A statement built from tokens inside another, such as the unit of an IF, ON or WHEN, with its own
+// prefixes taken off as the splitter takes them off a statement of its own.
+export function subStatement(parent, toks) {
+  const labels = [];
+  let i = 0;
+  while (toks[i] && toks[i].t === 'word' && toks[i + 1] && toks[i + 1].t === 'op' && toks[i + 1].v === ':') { labels.push({ name: toks[i].u, line: toks[i].line }); i += 2; }
+  const first = toks[i] || toks[0];
+  return { labels, conditions: [], toks: toks.slice(i), line: first ? first.line : parent.line, endLine: parent.endLine, ...(parent.file ? { file: parent.file } : {}) };
+}
+
+const RANK = { parsed: 0, unbuilt: 1, unparsed: 2, unknown: 3 };
+
+// { kind, status, node?, reason? }. status is parsed (every token accounted for, and every nested
+// unit parsed), unbuilt (the kind has no parser yet), unparsed (the parser refused it or left tokens)
+// or unknown (no kind fits). A parser receives a cursor on the statement's tokens after its prefixes
+// and returns a node; a nested statement it parses through ctx.parseStatement goes in node.units.
+export function parseStatement(stmt) {
+  const kind = classify(stmt);
+  if (kind === 'NULL') return { kind, status: 'parsed', node: { kind } };
+  if (kind === 'UNKNOWN') return { kind, status: 'unknown', reason: 'no statement kind fits' };
+  const parser = PARSERS[kind];
+  if (!parser) return { kind, status: 'unbuilt' };
+  const c = cursor(stmt.toks);
+  let node;
+  try {
+    node = parser(c, stmt, { parseStatement, subStatement });
+  } catch (e) {
+    if (e instanceof PliSyntax) return { kind, status: 'unparsed', reason: e.message, line: e.line ?? stmt.line };
+    return { kind, status: 'unparsed', reason: `parser error: ${e && e.message}`, crash: true, line: stmt.line };
+  }
+  if (!c.done()) return { kind, status: 'unparsed', reason: `tokens left at '${c.peek().v ?? c.peek().t}'`, line: c.peek().line, node };
+  let status = 'parsed';
+  for (const u of (node && node.units) || []) if (RANK[u.status] > RANK[status]) status = u.status;
+  return status === 'parsed' ? { kind, status, node } : { kind, status, node, reason: 'a nested statement is not parsed' };
+}

package/lib/pli/stmt/alloc.mjs

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I ALLOCATE and FREE: each names one or more controlled or based variables, an ALLOCATE with
+// the area it takes storage IN, the locator it SETs and any attributes it gives a controlled one.
+
+import { parseReference } from '../expr.mjs';
+
+const ALLOCATE_ATTRIBUTES = new Set(['CHARACTER', 'CHAR', 'BIT', 'GRAPHIC', 'WIDECHAR', 'AREA', 'INITIAL', 'INIT', 'DIMENSION', 'DIM']);
+
+function readParenthesised(c, read) {
+  c.expectOp('(');
+  const value = read(c);
+  c.expectOp(')');
+  return value;
+}
+
+function readAllocateItem(c) {
+  const level = c.peek() && c.peek().t === 'num' ? Number(c.next().v) : null;
+  const item = { level, variable: parseReference(c), in: null, set: null, attributes: [] };
+  while (!c.done() && !c.isOp(',')) {
+    if (c.isWord('IN')) { c.next(); item.in = readParenthesised(c, parseReference); }
+    else if (c.isWord('SET')) { c.next(); item.set = readParenthesised(c, parseReference); }
+    else if (c.isWord([...ALLOCATE_ATTRIBUTES])) {
+      const name = c.next().u;
+      item.attributes.push({ name, args: c.isOp('(') ? c.group() : null });
+    } else c.fail('IN, SET, an attribute or a comma');
+  }
+  return item;
+}
+
+function readFreeItem(c) {
+  const item = { variable: parseReference(c), in: null };
+  if (c.isWord('IN')) { c.next(); item.in = readParenthesised(c, parseReference); }
+  return item;
+}
+
+function readList(c, read) {
+  const items = [read(c)];
+  while (c.isOp(',')) { c.next(); items.push(read(c)); }
+  return items;
+}
+
+export const parsers = {
+  ALLOCATE: (c) => { c.expectWord(['ALLOCATE', 'ALLOC']); return { kind: 'ALLOCATE', items: readList(c, readAllocateItem) }; },
+  FREE: (c) => { c.expectWord('FREE'); return { kind: 'FREE', items: readList(c, readFreeItem) }; },
+};

package/lib/pli/stmt/assignment.mjs

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I assignment statements.
+
+import { parseExpression, parseReference } from '../expr.mjs';
+
+const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '|=', '&=', '||=', '**=']);
+
+function parseAssignment(c, stmt, ctx) {
+  const targets = [];
+  for (;;) {
+    const ref = parseReference(c);
+    targets.push(ref);
+    if (!c.isOp(',')) break;
+    c.next();
+  }
+
+  const opTok = c.peek();
+  if (!opTok || opTok.t !== 'op' || !ASSIGN_OPS.has(opTok.v)) {
+    c.fail('an assignment operator');
+  }
+  const op = c.next().v;
+
+  const value = parseExpression(c);
+
+  let byName = false;
+  if (c.isOp(',')) {
+    c.next();
+    if (c.isWord('BY')) {
+      c.next();
+      if (c.isWord('NAME')) {
+        c.next();
+        byName = true;
+      } else {
+        c.fail("'NAME'");
+      }
+    } else {
+      c.fail("'BY'");
+    }
+  }
+
+  if (!c.done()) {
+    c.fail('the end of the statement');
+  }
+
+  return {
+    kind: 'ASSIGNMENT',
+    targets,
+    op,
+    value,
+    byName,
+  };
+}
+
+export const parsers = {
+  ASSIGNMENT: parseAssignment,
+};

package/lib/pli/stmt/call.mjs

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I CALL, FETCH and RELEASE statements.
+
+import { cursor } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+function parseCall(c, stmt, ctx) {
+  c.expectWord('CALL');
+  const callee = parseReference(c);
+  const args = callee.args.length ? callee.args[callee.args.length - 1] : [];
+  const options = [];
+
+  while (!c.done()) {
+    if (c.isWord('TASK')) {
+      c.next();
+      const inner = c.group();
+      const s = cursor(inner);
+      const e = parseExpression(s);
+      if (!s.done()) s.fail('the end of the argument');
+      options.push({ name: 'TASK', args: [e] });
+    } else if (c.isWord('EVENT')) {
+      c.next();
+      const inner = c.group();
+      const s = cursor(inner);
+      const e = parseExpression(s);
+      if (!s.done()) s.fail('the end of the argument');
+      options.push({ name: 'EVENT', args: [e] });
+    } else if (c.isWord('PRIORITY')) {
+      c.next();
+      const inner = c.group();
+      const s = cursor(inner);
+      const e = parseExpression(s);
+      if (!s.done()) s.fail('the end of the argument');
+      options.push({ name: 'PRIORITY', args: [e] });
+    } else {
+      c.fail('end of statement or TASK, EVENT, or PRIORITY');
+    }
+  }
+
+  return { kind: 'CALL', callee, name: callee.path.join('.'), args, options };
+}
+
+function parseFetch(c, stmt, ctx) {
+  c.expectWord('FETCH');
+  const entries = [];
+
+  while (true) {
+    const name = c.expectWord(undefined).u;
+    let set = null;
+    let title = null;
+
+    // SET and TITLE may both appear, in either order.
+    while (c.isWord(['SET', 'TITLE']) && c.isOp('(', 1)) {
+      const option = c.next().u;
+      const s = cursor(c.group());
+      if (option === 'SET') set = parseReference(s);
+      else title = parseExpression(s);
+      if (!s.done()) s.fail('the end of the argument');
+    }
+
+    entries.push({ name, set, title });
+
+    if (c.isOp(',')) {
+      c.next();
+    } else {
+      break;
+    }
+  }
+
+  if (!c.done()) c.fail('end of statement');
+
+  return { kind: 'FETCH', entries };
+}
+
+function parseRelease(c, stmt, ctx) {
+  c.expectWord('RELEASE');
+  const entries = [];
+
+  if (c.isOp('*')) {
+    c.next();
+    entries.push('*');
+  } else {
+    while (true) {
+      const name = c.expectWord(undefined).u;
+      entries.push(name);
+
+      if (c.isOp(',')) {
+        c.next();
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (!c.done()) c.fail('end of statement');
+
+  return { kind: 'RELEASE', entries };
+}
+
+export const parsers = {
+  CALL: parseCall,
+  FETCH: parseFetch,
+  RELEASE: parseRelease,
+};

package/lib/pli/stmt/conditions.mjs

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for ON, SIGNAL, REVERT and RESIGNAL statements.
+
+const CONDITION_NAMES = new Set([
+  'ENDFILE', 'ENDPAGE', 'KEY', 'RECORD', 'TRANSMIT', 'UNDEFINEDFILE', 'UNDF',
+  'NAME', 'CONDITION', 'COND',
+  'ERROR', 'FINISH', 'CONVERSION', 'CONV', 'FIXEDOVERFLOW', 'FOFL',
+  'OVERFLOW', 'OFL', 'UNDERFLOW', 'UFL', 'ZERODIVIDE', 'ZDIV',
+  'SIZE', 'STRINGRANGE', 'STRG', 'STRINGSIZE', 'STRZ',
+  'SUBSCRIPTRANGE', 'SUBRG', 'AREA', 'STORAGE', 'ATTENTION', 'ATTN',
+  'INVALIDOP', 'ANYCONDITION', 'ANYCOND'
+]);
+
+function parseCondition(c) {
+  const nameTok = c.next();
+  if (!nameTok || nameTok.t !== 'word' || !CONDITION_NAMES.has(nameTok.u)) {
+    c.fail('a condition name');
+  }
+  const name = nameTok.u;
+  let arg = null;
+  if (c.isOp('(')) {
+    const inner = c.group();
+    arg = inner;
+  }
+  return { name, arg };
+}
+
+function parseConditions(c) {
+  const conditions = [];
+  const first = parseCondition(c);
+  conditions.push(first);
+
+  while (c.isOp(',')) {
+    c.next();
+    const next = parseCondition(c);
+    conditions.push(next);
+  }
+
+  return conditions;
+}
+
+function parseOn(c, stmt, ctx) {
+  c.expectWord('ON');
+
+  const conditions = parseConditions(c);
+
+  let snap = false;
+  if (c.isWord('SNAP')) {
+    c.next();
+    snap = true;
+  }
+
+  let system = false;
+  if (c.isWord('SYSTEM')) {
+    c.next();
+    system = true;
+  }
+
+  const units = [];
+  if (!system) {
+    const rest = c.drain();
+    if (rest.length > 0) {
+      const sub = ctx.subStatement(stmt, rest);
+      const result = ctx.parseStatement(sub);
+      units.push(result);
+    }
+  }
+
+  return { kind: 'ON', conditions, snap, system, units };
+}
+
+function parseSignal(c, stmt, ctx) {
+  c.expectWord('SIGNAL');
+  const condition = parseCondition(c);
+  return { kind: 'SIGNAL', condition, units: [] };
+}
+
+function parseRevert(c, stmt, ctx) {
+  c.expectWord('REVERT');
+  const condition = parseCondition(c);
+  return { kind: 'REVERT', condition, units: [] };
+}
+
+function parseResignal(c, stmt, ctx) {
+  c.expectWord('RESIGNAL');
+  return { kind: 'RESIGNAL', units: [] };
+}
+
+export const parsers = {
+  ON: parseOn,
+  SIGNAL: parseSignal,
+  REVERT: parseRevert,
+  RESIGNAL: parseResignal
+};