@portll/cobolwork 0.6.0 → 0.7.0

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
+};

package/lib/pli/stmt/control.mjs

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I DO, IF, ELSE, SELECT, WHEN, OTHERWISE, LEAVE, ITERATE, GO TO, RETURN, STOP and EXIT statements.
+
+import { cursor } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+
+function parseUnit(c, stmt, ctx, node) {
+  const rest = c.drain();
+  if (!rest.length) {
+    node.units = [];
+    return;
+  }
+  const sub = ctx.subStatement(stmt, rest);
+  node.units = [ctx.parseStatement(sub)];
+}
+
+function parseDo(c, stmt, ctx) {
+  c.expectWord('DO');
+  const node = { kind: 'DO', form: 'group', control: null, specs: [], while: null, until: null };
+
+  if (c.done()) return node;
+
+  // LOOP, FOREVER, WHILE and UNTIL are words only where a variable of that name could not be:
+  // followed by '=', each is the control variable of an iterative DO.
+  if (c.isWord('LOOP') && !c.isOp('=', 1)) {
+    c.next();
+    node.form = 'loop';
+    if (!c.done()) c.fail('end of DO LOOP');
+    return node;
+  }
+  if (c.isWord('FOREVER') && !c.isOp('=', 1)) {
+    c.next();
+    node.form = 'loop';
+    if (!c.done()) c.fail('end of DO FOREVER');
+    return node;
+  }
+
+  if (c.isWord('WHILE') && !c.isOp('=', 1)) {
+    c.next();
+    node.form = 'while';
+    node.while = parseExpression(c, { stopWords: ['UNTIL'] });
+    if (c.isWord('UNTIL') && !c.isOp('=', 1)) {
+      c.next();
+      node.until = parseExpression(c);
+    }
+    if (!c.done()) c.fail('end of DO WHILE');
+    return node;
+  }
+
+  if (c.isWord('UNTIL') && !c.isOp('=', 1)) {
+    c.next();
+    node.form = 'while';
+    node.until = parseExpression(c, { stopWords: ['WHILE'] });
+    if (c.isWord('WHILE')) {
+      c.next();
+      node.while = parseExpression(c);
+    }
+    if (!c.done()) c.fail('end of DO UNTIL');
+    return node;
+  }
+
+  node.form = 'iterative';
+  node.control = parseReference(c);
+  c.expectOp('=');
+
+  while (!c.done()) {
+    const spec = { from: null, to: null, by: null, repeat: null, while: null, until: null };
+    node.specs.push(spec);
+
+    spec.from = parseExpression(c);
+    if (c.isWord('REPEAT')) {
+      c.next();
+      spec.repeat = parseExpression(c);
+    } else {
+      // TO and BY may come in either order, each at most once.
+      for (let k = 0; k < 2; k++) {
+        if (!spec.to && c.isWord('TO')) { c.next(); spec.to = parseExpression(c); }
+        else if (!spec.by && c.isWord('BY')) { c.next(); spec.by = parseExpression(c); }
+      }
+    }
+
+    if (c.isWord('WHILE')) {
+      c.next();
+      spec.while = parseExpression(c, { stopWords: ['UNTIL'] });
+    }
+    if (c.isWord('UNTIL') && !c.isOp('=', 1)) {
+      c.next();
+      spec.until = parseExpression(c);
+    }
+
+    if (c.isOp(',')) {
+      c.next();
+    } else if (!c.done()) {
+      c.fail('end of DO iterative');
+    }
+  }
+
+  return node;
+}
+
+function parseIf(c, stmt, ctx) {
+  c.expectWord('IF');
+  const node = { kind: 'IF', cond: parseExpression(c, { stopWords: ['THEN'] }), units: [] };
+  c.expectWord('THEN');
+  parseUnit(c, stmt, ctx, node);
+  return node;
+}
+
+function parseElse(c, stmt, ctx) {
+  c.expectWord('ELSE');
+  const node = { kind: 'ELSE', units: [] };
+  parseUnit(c, stmt, ctx, node);
+  return node;
+}
+
+function parseSelect(c, stmt, ctx) {
+  c.expectWord('SELECT');
+  const node = { kind: 'SELECT', subject: null };
+  if (c.isOp('(')) {
+    const inner = c.group();
+    const s = cursor(inner);
+    node.subject = parseExpression(s);
+    if (!s.done()) s.fail('end of SELECT subject');
+  }
+  if (!c.done()) c.fail('end of SELECT');
+  return node;
+}
+
+function parseWhen(c, stmt, ctx) {
+  c.expectWord('WHEN');
+  const node = { kind: 'WHEN', values: [], units: [] };
+  if (c.isWord(['ANY', 'ALL'])) {
+    c.next();
+  }
+  const items = c.items();
+  for (const toks of items) {
+    const s = cursor(toks);
+    node.values.push(parseExpression(s));
+    if (!s.done()) s.fail('end of WHEN value');
+  }
+  parseUnit(c, stmt, ctx, node);
+  return node;
+}
+
+function parseOtherwise(c, stmt, ctx) {
+  c.word(['OTHERWISE', 'OTHER']);
+  const node = { kind: 'OTHERWISE', units: [] };
+  parseUnit(c, stmt, ctx, node);
+  return node;
+}
+
+function parseLeave(c, stmt, ctx) {
+  c.expectWord('LEAVE');
+  const node = { kind: 'LEAVE', label: null };
+  if (!c.done()) {
+    node.label = parseReference(c);
+  }
+  if (!c.done()) c.fail('end of LEAVE');
+  return node;
+}
+
+function parseIterate(c, stmt, ctx) {
+  c.expectWord('ITERATE');
+  const node = { kind: 'ITERATE', label: null };
+  if (!c.done()) {
+    node.label = parseReference(c);
+  }
+  if (!c.done()) c.fail('end of ITERATE');
+  return node;
+}
+
+function parseGoto(c, stmt, ctx) {
+  c.word(['GO', 'GOTO']);
+  if (c.isWord('TO')) c.next();
+  const node = { kind: 'GOTO', target: parseReference(c) };
+  if (!c.done()) c.fail('end of GO TO');
+  return node;
+}
+
+function parseReturn(c, stmt, ctx) {
+  c.expectWord('RETURN');
+  const node = { kind: 'RETURN', value: null };
+  if (c.isOp('(')) {
+    const inner = c.group();
+    const s = cursor(inner);
+    node.value = parseExpression(s);
+    if (!s.done()) s.fail('end of RETURN value');
+  }
+  if (!c.done()) c.fail('end of RETURN');
+  return node;
+}
+
+function parseStop(c, stmt, ctx) {
+  c.expectWord('STOP');
+  if (!c.done()) c.fail('end of STOP');
+  return { kind: 'STOP' };
+}
+
+function parseExit(c, stmt, ctx) {
+  c.expectWord('EXIT');
+  if (!c.done()) c.fail('end of EXIT');
+  return { kind: 'EXIT' };
+}
+
+export const parsers = {
+  DO: parseDo,
+  IF: parseIf,
+  ELSE: parseElse,
+  SELECT: parseSelect,
+  WHEN: parseWhen,
+  OTHERWISE: parseOtherwise,
+  LEAVE: parseLeave,
+  ITERATE: parseIterate,
+  GOTO: parseGoto,
+  RETURN: parseReturn,
+  STOP: parseStop,
+  EXIT: parseExit,
+};