@portll/cobolwork 0.5.0 → 0.7.0

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

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 = {};