@portll/cobolwork 0.6.0 → 0.7.0

package/lib/pli/stmt/declare.mjs

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I DECLARE statements.
+import { cursor, split, PliSyntax } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+const ABBREV = new Map([
+  ['CHAR', 'CHARACTER'], ['BIN', 'BINARY'], ['DEC', 'DECIMAL'], ['PIC', 'PICTURE'],
+  ['PTR', 'POINTER'], ['VAR', 'VARYING'], ['VARZ', 'VARYINGZ'], ['NONVAR', 'NONVARYING'],
+  ['INIT', 'INITIAL'], ['EXT', 'EXTERNAL'], ['INT', 'INTERNAL'], ['AUTO', 'AUTOMATIC'],
+  ['CTL', 'CONTROLLED'], ['DEF', 'DEFINED'], ['POS', 'POSITION'], ['ENV', 'ENVIRONMENT'],
+  ['WCHAR', 'WIDECHAR'], ['COND', 'CONDITION'], ['PARM', 'PARAMETER'],
+]);
+
+const KNOWN = new Set([
+  'CHARACTER', 'BIT', 'GRAPHIC', 'WIDECHAR', 'VARYING', 'VARYINGZ', 'NONVARYING',
+  'FIXED', 'FLOAT', 'BINARY', 'DECIMAL', 'PRECISION', 'SIGNED', 'UNSIGNED', 'REAL',
+  'COMPLEX', 'PICTURE', 'POINTER', 'OFFSET', 'HANDLE', 'AREA', 'ENTRY', 'RETURNS',
+  'OPTIONS', 'FILE', 'STREAM', 'RECORD', 'INPUT', 'OUTPUT', 'UPDATE', 'SEQUENTIAL',
+  'DIRECT', 'KEYED', 'ENVIRONMENT', 'PRINT', 'LABEL', 'FORMAT', 'CONDITION', 'BUILTIN',
+  'GENERIC', 'EXTERNAL', 'INTERNAL', 'STATIC', 'AUTOMATIC', 'BASED', 'CONTROLLED',
+  'DEFINED', 'POSITION', 'PARAMETER', 'ALIGNED', 'UNALIGNED', 'INITIAL', 'VALUE',
+  'LIKE', 'UNION', 'CONNECTED', 'NONCONNECTED', 'ASSIGNABLE', 'NONASSIGNABLE',
+  'NORMAL', 'ABNORMAL', 'BYADDR', 'BYVALUE', 'OPTIONAL', 'ORDINAL', 'TYPE', 'DIMACROSS',
+  'BIGENDIAN', 'LITTLEENDIAN', 'HEXADEC', 'IEEE', 'NATIVE', 'NONNATIVE', 'LIMITED',
+  'VARIABLE', 'IRREDUCIBLE', 'REDUCIBLE', 'RESERVED', 'INONLY', 'OUTONLY', 'INOUT',
+  'TASK', 'EVENT', 'BACKWARDS', 'BUFFERED', 'UNBUFFERED', 'TRANSIENT', 'EXCLUSIVE',
+]);
+
+function expandAttr(u) {
+  return ABBREV.get(u) || u;
+}
+
+function parseAttribute(c, unknown) {
+  const w = c.peek();
+  if (!w || w.t !== 'word') c.fail('an attribute');
+  c.next();
+  const name = expandAttr(w.u);
+  let args = null;
+  let picture;
+  if (name === 'PICTURE' && c.peek() && c.peek().t === 'lit') return { name, args, picture: c.next().v };
+  if (c.isOp('(')) {
+    const inner = c.group();
+    if (name === 'PICTURE' && inner.length === 1 && inner[0].t === 'lit') {
+      picture = inner[0].v;
+    } else {
+      args = inner;
+    }
+  }
+  if (!KNOWN.has(name)) unknown.push(name);
+  return { name, args, picture };
+}
+
+function parseDims(c) {
+  const dims = [];
+  while (c.isOp('(')) {
+    dims.push(...c.items());
+  }
+  return dims;
+}
+
+function parseItem(c, unknown, line) {
+  let level = null;
+  if (c.peek() && c.peek().t === 'num' && /^\d+$/.test(c.peek().v)) {
+    level = parseInt(c.next().v, 10);
+  }
+
+  let name = null;
+  let factored = null;
+  let dims = [];
+
+  if (c.isOp('(')) {
+    const inner = c.group();
+    const parts = split(inner, ',');
+    factored = [];
+    for (const p of parts) {
+      const sc = cursor(p);
+      const sub = parseItem(sc, unknown, line);
+      if (!sc.done()) sc.fail('end of factored member');
+      factored.push(sub);
+    }
+  } else if (c.isOp('*')) {
+    c.next();
+    name = '*';
+  } else {
+    const w = c.peek();
+    if (!w || w.t !== 'word') c.fail('a name');
+    c.next();
+    name = w.u;
+    dims = parseDims(c);
+  }
+
+  const attributes = [];
+  while (!c.done()) {
+    const t = c.peek();
+    if (t.t === 'word') {
+      attributes.push(parseAttribute(c, unknown));
+    } else {
+      break;
+    }
+  }
+
+  return { level, name, factored, dims, attributes, line };
+}
+
+// A factored list gives one item per member, each with its own attributes and the shared ones.
+function flatten(item, names) {
+  if (!item.factored) return [{ ...item, factored: names }];
+  const all = item.factored.flatMap((m) => (m.factored ? m.factored.map((x) => x.name) : [m.name]));
+  return item.factored.flatMap((m) => flatten({ ...m, level: m.level ?? item.level, attributes: [...m.attributes, ...item.attributes] }, all));
+}
+
+const isInclude = (p) => p.length === 3 && p[0].t === 'op' && p[0].v === '%' && p[1].t === 'word' && p[1].u === 'INCLUDE' && p[2].t === 'word';
+
+// A %INCLUDE where an item belongs supplies the rest of the declaration from a member, which an
+// unexpanded read records by name; a member that is itself the middle of a structure ends at the
+// comma its includer continues from.
+function parseItems(c, unknown, line, { fragment = false } = {}) {
+  const items = [];
+  const includes = [];
+  const parts = split(c.drain(), ',');
+  parts.forEach((p, k) => {
+    const last = k === parts.length - 1;
+    if (isInclude(p) && last) { includes.push(p[2].u); return; }
+    if (!p.length && last && fragment && k > 0) return;
+    const sc = cursor(p);
+    const item = parseItem(sc, unknown, line);
+    if (!sc.done()) sc.fail('end of item');
+    items.push(...flatten(item, null));
+  });
+  return { items, includes };
+}
+
+function parseDeclare(c, stmt, ctx) {
+  c.word(['DECLARE', 'DCL']);
+  const unknown = [];
+  const { items, includes } = parseItems(c, unknown, stmt.line);
+  return { kind: 'DECLARE', items, includes, unknownAttributes: unknown };
+}
+
+function parseDeclareFragment(c, stmt, ctx) {
+  const unknown = [];
+  const { items, includes } = parseItems(c, unknown, stmt.line, { fragment: true });
+  return { kind: 'DECLARE_FRAGMENT', items, includes, unknownAttributes: unknown };
+}
+
+export const parsers = {
+  DECLARE: parseDeclare,
+  DECLARE_FRAGMENT: parseDeclareFragment,
+};

package/lib/pli/stmt/exec.mjs

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I EXEC SQL, EXEC CICS and EXEC DLI statements.
+import { hostVariablesIn } from '../../embedded-sql.mjs';
+import { CICS_COMMANDS, CICS_EVERY_COMMAND } from '../../cics-commands.mjs';
+import { cicsCommand } from '../../precompile-cics.mjs';
+
+function toSqlTok(t) {
+  if (t.t === 'word') return { t: 'word', u: t.u };
+  if (t.t === 'op' && t.v === ':') return { t: 'op', v: ':' };
+  if (t.t === 'op' && t.v === '.') return { t: 'period', joined: true };
+  if (t.t === 'lit') return { t: 'lit', v: t.v };
+  if (t.t === 'num') return { t: 'word', u: t.v };
+  return { t: 'word', u: t.v };
+}
+
+function parseSql(c) {
+  const rest = c.drain();
+  const sqlToks = rest.map(toSqlTok);
+  const verb = sqlToks.find((t) => t.t === 'word')?.u;
+  const hostVars = hostVariablesIn(sqlToks).map((h) => ({ host: h.host, written: h.written }));
+  return { verb, hostVars };
+}
+
+// The options of an EXEC CICS command as words with their argument tokens, the command resolved by
+// the same table the COBOL translator uses, and each option's direction from it.
+function parseCics(c) {
+  const options = [];
+  while (!c.done()) {
+    const w = c.expectWord();
+    options.push({ name: w.u, args: c.isOp('(') ? c.group() : null });
+  }
+  const name = cicsCommand(options.map((o) => ({ word: o.name })));
+  const table = name ? CICS_COMMANDS[name].options : {};
+  for (const o of options.slice(1)) o.direction = table[o.name] || CICS_EVERY_COMMAND[o.name] || null;
+  return { command: name ? name.split(' ') : options.slice(0, 1).map((o) => o.name), known: !!name, options: options.slice(1) };
+}
+
+export const parsers = {
+  EXEC(c, stmt, ctx) {
+    c.expectWord('EXEC');
+    const procTok = c.peek();
+    if (!procTok || procTok.t !== 'word') c.fail('a processor word after EXEC');
+    const processor = procTok.u;
+    c.next();
+    const node = { kind: 'EXEC', processor, toks: [] };
+    if (processor === 'SQL') {
+      node.sql = parseSql(c);
+    } else if (processor === 'CICS') {
+      node.cics = parseCics(c);
+    } else {
+      node.toks = c.drain();
+    }
+    return node;
+  },
+};

package/lib/pli/stmt/io.mjs

@@ -0,0 +1,239 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Parsers for PL/I OPEN, CLOSE, READ, WRITE, REWRITE, DELETE, LOCATE and UNLOCK statements.
+
+import { cursor } from '../cursor.mjs';
+import { parseExpression, parseReference } from '../expr.mjs';
+
+const OPEN_OPTS = new Set([
+  'STREAM', 'RECORD', 'INPUT', 'OUTPUT', 'UPDATE', 'SEQUENTIAL', 'DIRECT', 'TRANSIENT',
+  'BUFFERED', 'UNBUFFERED', 'KEYED', 'PRINT', 'BACKWARDS', 'EXCLUSIVE',
+  'TITLE', 'LINESIZE', 'PAGESIZE', 'ENVIRONMENT', 'ENV'
+]);
+
+const REF_OPTS = new Set(['INTO', 'FROM', 'SET', 'KEYTO', 'EVENT']);
+const EXPR_OPTS = new Set(['KEY', 'KEYFROM', 'IGNORE', 'TITLE', 'LINESIZE', 'PAGESIZE']);
+
+function parseFileRef(c) {
+  c.expectWord('FILE');
+  c.expectOp('(');
+  const ref = parseReference(c);
+  c.expectOp(')');
+  return ref;
+}
+
+function parseOpenFile(c) {
+  const file = parseFileRef(c);
+  const options = {};
+
+  while (!c.done()) {
+    if (c.isOp(',')) {
+      break;
+    }
+
+    if (c.isWord()) {
+      const word = c.next();
+      const u = word.u;
+
+      if (OPEN_OPTS.has(u)) {
+        if (c.isOp('(')) {
+          const inner = c.group();
+          const s = cursor(inner);
+          if (u === 'ENVIRONMENT' || u === 'ENV') {
+            options[u] = inner;
+          } else {
+            const e = parseExpression(s);
+            if (!s.done()) s.fail('the end of the option argument');
+            options[u] = e;
+          }
+        } else {
+          options[u] = true;
+        }
+      } else {
+        if (c.isOp('(')) {
+          const inner = c.group();
+          options[u] = inner;
+        } else {
+          options[u] = true;
+        }
+      }
+    } else {
+      c.fail('an OPEN option');
+    }
+  }
+
+  return { file, options };
+}
+
+function parseOpen(c, stmt, ctx) {
+  c.expectWord('OPEN');
+  const files = [];
+  files.push(parseOpenFile(c));
+
+  while (c.isOp(',')) {
+    c.next();
+    files.push(parseOpenFile(c));
+  }
+
+  return { kind: 'OPEN', files };
+}
+
+function parseCloseFile(c) {
+  const file = parseFileRef(c);
+  const options = {};
+
+  while (!c.done()) {
+    if (c.isOp(',')) {
+      break;
+    }
+
+    if (c.isWord('ENVIRONMENT') || c.isWord('ENV')) {
+      const u = c.next().u;
+      if (c.isOp('(')) {
+        const inner = c.group();
+        options[u] = inner;
+      } else {
+        options[u] = true;
+      }
+    } else {
+      c.fail('a CLOSE option');
+    }
+  }
+
+  return { file, options };
+}
+
+function parseClose(c, stmt, ctx) {
+  c.expectWord('CLOSE');
+  const files = [];
+
+  if (c.isWord('FILE') && c.isOp('(', 1)) {
+    c.next(); 
+    c.next(); 
+    if (c.isOp('*')) {
+      c.next();
+      c.expectOp(')');
+      files.push({ file: { t: 'star', toks: [] }, options: {} });
+    } else {
+      const ref = parseReference(c);
+      c.expectOp(')');
+      files.push({ file: ref, options: {} });
+    }
+  } else {
+    files.push(parseCloseFile(c));
+  }
+
+  while (c.isOp(',')) {
+    c.next();
+    files.push(parseCloseFile(c));
+  }
+
+  return { kind: 'CLOSE', files };
+}
+
+function parseRecordIO(c, stmt, ctx, kind) {
+  c.expectWord(kind);
+
+  const file = parseFileRef(c);
+  const options = {};
+  let target = null;
+
+  while (!c.done()) {
+    if (c.isWord()) {
+      const word = c.next();
+      const u = word.u;
+
+      if (REF_OPTS.has(u)) {
+        c.expectOp('(');
+        const ref = parseReference(c);
+        c.expectOp(')');
+        options[u] = ref;
+        if (u === 'INTO' || u === 'FROM') target = ref;
+      } else if (EXPR_OPTS.has(u)) {
+        const inner = c.group();
+        const s = cursor(inner);
+        const e = parseExpression(s);
+        if (!s.done()) s.fail('the end of the option argument');
+        options[u] = e;
+      } else if (u === 'NOLOCK') {
+        options[u] = true;
+      } else {
+        if (c.isOp('(')) {
+          const inner = c.group();
+          options[u] = inner;
+        } else {
+          options[u] = true;
+        }
+      }
+    } else {
+      c.fail(`an ${kind} option`);
+    }
+  }
+
+  return { kind, file, target, options };
+}
+
+function parseLocate(c, stmt, ctx) {
+  c.expectWord('LOCATE');
+  const target = parseReference(c);
+  const file = parseFileRef(c);
+  const options = {};
+
+  while (!c.done()) {
+    if (c.isWord()) {
+      const word = c.next();
+      const u = word.u;
+
+      if (u === 'SET') {
+        c.expectOp('(');
+        const ref = parseReference(c);
+        c.expectOp(')');
+        options[u] = ref;
+      } else if (u === 'KEYFROM') {
+        const inner = c.group();
+        const s = cursor(inner);
+        const e = parseExpression(s);
+        if (!s.done()) s.fail('the end of the option argument');
+        options[u] = e;
+      } else {
+        if (c.isOp('(')) {
+          const inner = c.group();
+          options[u] = inner;
+        } else {
+          options[u] = true;
+        }
+      }
+    } else {
+      c.fail('a LOCATE option');
+    }
+  }
+
+  return { kind: 'LOCATE', file, target, options };
+}
+
+function parseUnlock(c, stmt, ctx) {
+  c.expectWord('UNLOCK');
+  const file = parseFileRef(c);
+  const options = {};
+
+  if (c.isWord('KEY')) {
+    c.next();
+    const inner = c.group();
+    const s = cursor(inner);
+    const e = parseExpression(s);
+    if (!s.done()) s.fail('the end of the option argument');
+    options['KEY'] = e;
+  }
+
+  return { kind: 'UNLOCK', file, target: null, options };
+}
+
+export const parsers = {
+  OPEN: parseOpen,
+  CLOSE: parseClose,
+  READ: (c, s, ctx) => parseRecordIO(c, s, ctx, 'READ'),
+  WRITE: (c, s, ctx) => parseRecordIO(c, s, ctx, 'WRITE'),
+  REWRITE: (c, s, ctx) => parseRecordIO(c, s, ctx, 'REWRITE'),
+  DELETE: (c, s, ctx) => parseRecordIO(c, s, ctx, 'DELETE'),
+  LOCATE: parseLocate,
+  UNLOCK: parseUnlock
+};

package/lib/pli/stmt/misc.mjs

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// PL/I DEFAULT, DEFINE, WAIT, DELAY, ATTACH, DETACH, ASSERT and QUALIFY statements.
+
+export const parsers = {};

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