@portll/cobolwork 0.5.0 → 0.7.0

package/lib/pli/stmt/preprocessor.mjs

@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parser for PL/I preprocessor statements (kind PREPROCESSOR), which begin with the op '%'.
+import { cursor } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+export const parsers = {
+  PREPROCESSOR: (c, stmt, ctx) => {
+    const node = { kind: 'PREPROCESSOR', units: [] };
+    if (!c.isOp('%')) c.fail("'%'");
+    c.next();
+
+    const labelTok = c.peek();
+    if (labelTok && labelTok.t === 'word' && c.isOp(':', 1)) {
+      c.next();
+      c.next();
+      node.label = labelTok.u;
+    }
+
+    if (c.done()) { node.directive = 'NULL'; return node; }
+    const dirTok = c.peek();
+    if (!dirTok || dirTok.t !== 'word') c.fail('a directive word');
+    // %X = expression assigns a preprocessor variable.
+    if (c.isOp('=', 1)) {
+      c.next();
+      c.next();
+      return { ...node, directive: 'ASSIGN', names: [dirTok.u], value: parseExpression(c) };
+    }
+    c.next();
+    node.directive = dirTok.u;
+
+    switch (node.directive) {
+      case 'INCLUDE':
+      case 'XINCLUDE': {
+        // A member is a name, a quoted name, or ddname(member) naming the library it is read from.
+        node.members = [];
+        for (;;) {
+          const t = c.next();
+          if (t && t.t === 'lit') node.members.push({ name: t.v, library: null });
+          else if (t && t.t === 'word' && c.isOp('(')) {
+            const s2 = cursor(c.group());
+            const m = s2.next();
+            if (!m || (m.t !== 'word' && m.t !== 'lit') || !s2.done()) c.fail('a member name in the library reference');
+            node.members.push({ name: m.u ?? m.v, library: t.u });
+          } else if (t && t.t === 'word') node.members.push({ name: t.u, library: null });
+          else c.fail('a member name');
+          if (!c.op(',')) break;
+        }
+        break;
+      }
+      case 'DCL':
+      case 'DECLARE': {
+        node.names = [];
+        while (!c.done()) {
+          if (c.isOp(',')) c.next();
+          const nameTok = c.expectWord(undefined);
+          node.names.push(nameTok.u);
+          while (!c.done()) {
+            const t = c.peek();
+            if (t.t === 'word') {
+              c.next();
+            } else if (t.t === 'op' && t.v === '(') {
+              c.group();
+            } else if (t.t === 'op' && t.v === ',') {
+              break;
+            } else {
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case 'IF': {
+        const expr = parseExpression(c, { stopOps: ['%'] });
+        node.value = expr;
+        if (c.isOp('%') && c.isWord('THEN', 1)) {
+          c.next();
+          c.next();
+          const unitToks = c.drain();
+          if (unitToks.length) {
+            const sub = ctx.subStatement(stmt, unitToks);
+            const res = ctx.parseStatement(sub);
+            node.units.push(res);
+          }
+        } else {
+          c.fail('%THEN');
+        }
+        break;
+      }
+      case 'ELSE': {
+        const unitToks = c.drain();
+        if (unitToks.length) {
+          const sub = ctx.subStatement(stmt, unitToks);
+          const res = ctx.parseStatement(sub);
+          node.units.push(res);
+        }
+        break;
+      }
+      case 'DO':
+      case 'END':
+      case 'PAGE':
+      case 'NOPRINT':
+      case 'PUSH':
+      case 'POP':
+      case 'PRINT':
+      case 'ITERATE':
+      case 'LEAVE':
+      case 'INSCAN':
+      case 'XINSCAN':
+      case 'PROCESS': {
+        if (node.directive === 'PROCESS') {
+          while (!c.done()) c.next();
+        }
+        break;
+      }
+      case 'SKIP': {
+        if (c.isOp('(')) {
+          c.group();
+        }
+        break;
+      }
+      case 'NOTE': {
+        if (c.isOp('(')) {
+          c.group();
+        }
+        break;
+      }
+      case 'ACTIVATE':
+      case 'ACT':
+      case 'DEACTIVATE':
+      case 'DEACT': {
+        node.names = [];
+        while (!c.done()) {
+          if (c.isWord()) {
+            const t = c.next();
+            if (t.u === 'RESCAN' || t.u === 'NORESCAN') {
+              node.rescan = t.u === 'RESCAN';
+            } else {
+              node.names.push(t.u);
+            }
+          } else if (c.isOp(',')) {
+            c.next();
+          } else {
+            c.fail('a name or RESCAN/NORESCAN');
+          }
+        }
+        break;
+      }
+      case 'GO':
+      case 'GOTO': {
+        if (c.isWord('TO')) c.next();
+        const label = c.expectWord(undefined);
+        node.label = label.u;
+        break;
+      }
+      case 'RETURN': {
+        if (c.isOp('(')) {
+          const inner = c.group();
+          const s = cursor(inner);
+          node.value = parseExpression(s);
+          if (!s.done()) s.fail('the end of the argument');
+        }
+        break;
+      }
+      case 'REPLACE': {
+        const name = c.expectWord(undefined);
+        node.names = [name.u];
+        if (!c.isWord('BY')) c.fail('BY');
+        c.next();
+        node.value = parseExpression(c);
+        break;
+      }
+      case 'PROCEDURE':
+      case 'PROC': {
+        if (c.isOp('(')) {
+          const params = c.items();
+          node.params = params.map(p => {
+            const s = cursor(p);
+            const ref = parseReference(s);
+            if (!s.done()) s.fail('the end of the parameter');
+            return ref;
+          });
+        }
+        while (!c.done()) {
+          const t = c.peek();
+          if (t.t === 'word') {
+            if (t.u === 'STATEMENT') {
+              c.next();
+              node.statement = true;
+            } else if (t.u === 'RETURNS') {
+              c.next();
+              c.expectOp('(');
+              const retTok = c.expectWord(undefined);
+              c.expectOp(')');
+              node.returns = retTok.u;
+            } else {
+              c.next();
+            }
+          } else if (t.t === 'op' && t.v === '(') {
+            c.group();
+          } else {
+            c.fail('STATEMENT or RETURNS');
+          }
+        }
+        break;
+      }
+      case 'SELECT':
+      case 'WHEN':
+      case 'OTHERWISE': {
+        if (node.directive === 'WHEN') {
+          if (c.isOp('(')) {
+            const inner = c.group();
+            const s = cursor(inner);
+            node.value = parseExpression(s);
+            if (!s.done()) s.fail('the end of the condition');
+          }
+          const unitToks = c.drain();
+          if (unitToks.length) {
+            const sub = ctx.subStatement(stmt, unitToks);
+            const res = ctx.parseStatement(sub);
+            node.units.push(res);
+          }
+        } else if (node.directive === 'OTHERWISE') {
+          const unitToks = c.drain();
+          if (unitToks.length) {
+            const sub = ctx.subStatement(stmt, unitToks);
+            const res = ctx.parseStatement(sub);
+            node.units.push(res);
+          }
+        }
+        break;
+      }
+      default: {
+        const rest = c.drain();
+        node.toks = rest;
+        break;
+      }
+    }
+
+    if (!c.done()) c.fail('the end of the statement');
+    return node;
+  }
+};

package/lib/pli/stmt/procedure.mjs

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for PL/I PROCEDURE, ENTRY, PACKAGE, BEGIN, and END statements.
+
+const PROC_OPTIONS = new Set([
+  'RECURSIVE', 'NONRECURSIVE', 'REORDER', 'ORDER', 'EXTERNAL', 'EXT',
+  'CHARGRAPHIC', 'NOCHARGRAPHIC', 'REDUCIBLE', 'IRREDUCIBLE'
+]);
+
+const BEGIN_OPTIONS = new Set([
+  'ORDER', 'REORDER', 'CHARGRAPHIC', 'NOCHARGRAPHIC'
+]);
+
+function parseNameList(c, failMsg) {
+  const items = c.items();
+  const names = [];
+  for (const item of items) {
+    if (item.length === 1 && item[0].t === 'op' && item[0].v === '*') {
+      names.push('*');
+    } else if (item.length === 1 && item[0].t === 'word') {
+      names.push(item[0].u);
+    } else {
+      c.fail(failMsg);
+    }
+  }
+  return names;
+}
+
+function parseOptionsList(c) {
+  const items = c.items();
+  const options = [];
+  for (const item of items) {
+    if (item.length === 0) continue;
+    const first = item[0];
+    if (first.t !== 'word') {
+      c.fail('an option name');
+    }
+    const opt = { name: first.u, args: null };
+    let i = 1;
+    if (i < item.length && item[i].t === 'op' && item[i].v === '(') {
+      const start = i;
+      let depth = 0;
+      for (; i < item.length; i++) {
+        if (item[i].t === 'op' && item[i].v === '(') depth++;
+        else if (item[i].t === 'op' && item[i].v === ')') {
+          depth--;
+          if (depth === 0) { i++; break; }
+        }
+      }
+      if (depth !== 0) {
+        c.fail("matching ')'");
+      }
+      opt.args = item.slice(start + 1, i - 1);
+    }
+    if (i < item.length) {
+      c.fail('end of option');
+    }
+    options.push(opt);
+  }
+  return options;
+}
+
+function parseProcedure(c, stmt) {
+  c.expectWord(['PROCEDURE', 'PROC']);
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'PROCEDURE',
+    name,
+    params: [],
+    options: [],
+    returns: null,
+    recursive: false,
+    external: null,
+    order: null
+  };
+
+  if (c.isOp('(')) {
+    const items = c.items();
+    for (const item of items) {
+      if (item.length === 1 && item[0].t === 'word') {
+        node.params.push(item[0].u);
+      } else {
+        c.fail('a parameter name');
+      }
+    }
+  }
+
+  while (!c.done()) {
+    if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else if (c.isWord('RETURNS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.returns = c.group();
+    } else if (c.isWord(['RECURSIVE', 'NONRECURSIVE'])) {
+      const t = c.next();
+      node.recursive = t.u === 'RECURSIVE';
+    } else if (c.isWord(['ORDER', 'REORDER'])) {
+      const t = c.next();
+      node.order = t.u;
+    } else if (c.isWord(['EXTERNAL', 'EXT'])) {
+      c.next();
+      if (c.isOp('(')) {
+        const inner = c.group();
+        if (inner.length === 1 && inner[0].t === 'lit') {
+          node.external = inner[0].v;
+        } else if (inner.length === 1 && inner[0].t === 'word') {
+          node.external = inner[0].u;
+        } else {
+          c.fail("a name or literal");
+        }
+      } else {
+        node.external = true;
+      }
+    } else if (c.isWord(['CHARGRAPHIC', 'NOCHARGRAPHIC', 'REDUCIBLE', 'IRREDUCIBLE'])) {
+      const t = c.next();
+      node.options.push({ name: t.u, args: null });
+    } else {
+      c.fail('a PROCEDURE option');
+    }
+  }
+
+  return node;
+}
+
+function parseEntry(c, stmt) {
+  c.expectWord('ENTRY');
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'ENTRY',
+    name,
+    params: [],
+    options: [],
+    returns: null,
+    recursive: false,
+    external: null,
+    order: null
+  };
+
+  if (c.isOp('(')) {
+    const items = c.items();
+    for (const item of items) {
+      if (item.length === 1 && item[0].t === 'word') {
+        node.params.push(item[0].u);
+      } else {
+        c.fail('a parameter name');
+      }
+    }
+  }
+
+  while (!c.done()) {
+    if (c.isWord('RETURNS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.returns = c.group();
+    } else if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else if (c.isWord(['EXTERNAL', 'EXT'])) {
+      c.next();
+      if (c.isOp('(')) {
+        const inner = c.group();
+        if (inner.length === 1 && inner[0].t === 'lit') {
+          node.external = inner[0].v;
+        } else if (inner.length === 1 && inner[0].t === 'word') {
+          node.external = inner[0].u;
+        } else {
+          c.fail("a name or literal");
+        }
+      } else {
+        node.external = true;
+      }
+    } else {
+      c.fail('an ENTRY option');
+    }
+  }
+
+  return node;
+}
+
+function parsePackage(c, stmt) {
+  c.expectWord('PACKAGE');
+  const name = stmt.labels.length ? stmt.labels[stmt.labels.length - 1].name : null;
+  const node = {
+    kind: 'PACKAGE',
+    name,
+    exports: null,
+    reserves: null,
+    options: []
+  };
+
+  while (!c.done()) {
+    if (c.isWord('EXPORTS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.exports = parseNameList(c, 'an export name');
+    } else if (c.isWord('RESERVES')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.reserves = parseNameList(c, 'a reserve name');
+    } else if (c.isWord('OPTIONS')) {
+      c.next();
+      if (!c.isOp('(')) c.fail("'('");
+      node.options.push(...parseOptionsList(c));
+    } else {
+      c.fail('a PACKAGE option');
+    }
+  }
+
+  return node;
+}
+
+function parseBegin(c, stmt) {
+  c.expectWord('BEGIN');
+  const node = {
+    kind: 'BEGIN',
+    options: []
+  };
+
+  while (!c.done()) {
+    if (c.isWord(['OPTIONS', 'ORDER', 'REORDER', 'CHARGRAPHIC', 'NOCHARGRAPHIC'])) {
+      const t = c.next();
+      if (t.u === 'OPTIONS') {
+        if (!c.isOp('(')) c.fail("'('");
+        node.options.push(...parseOptionsList(c));
+      } else {
+        node.options.push({ name: t.u, args: null });
+      }
+    } else {
+      c.fail('a BEGIN option');
+    }
+  }
+
+  return node;
+}
+
+function parseEnd(c, stmt) {
+  c.expectWord('END');
+  let label = null;
+  if (!c.done()) {
+    if (c.isWord()) {
+      label = c.next().u;
+    } else {
+      c.fail('a label or end of statement');
+    }
+  }
+  return { kind: 'END', label };
+}
+
+export const parsers = {
+  PROCEDURE: parseProcedure,
+  ENTRY: parseEntry,
+  PACKAGE: parsePackage,
+  BEGIN: parseBegin,
+  END: parseEnd
+};