@portll/cobolwork 0.4.0 → 0.6.0

package/lib/control.mjs

@@ -622,10 +622,14 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
 
   // ---- checks ----
   // The storage an item lies in: its record, or the record an 01 REDEFINES lays itself over.
+  const recordOf = new Map();
   const itemsInRecord = (item) => {
-    let top = item;
+    let top = recordOf.get(item);
+    if (top) return top;
+    top = item;
     while (top.parent) top = top.parent;
     for (let hops = 0; top.redefinesItem && hops < 64; hops++) top = top.redefinesItem;
+    if (item.parent) recordOf.set(item, top);
     return top;
   };
   const fieldKey = (f) => (f.index ? `IX:${f.index}` : f);
@@ -639,6 +643,33 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const fEnd = f.offset + (f.contributes || f.size);
     return w.offset < fEnd && f.offset < wEnd;
   };
+  // Entries grouped by the storage their item lies in, so a lookup tries only what `overlaps` can
+  // accept: the same record, the same index, or a 66-level item, which overlaps any field.
+  const byStorage = (entries, itemOf) => {
+    const byRecord = new Map();
+    const byIndex = new Map();
+    const renames = [];
+    const plain = [];
+    const add = (map, k, e) => { const list = map.get(k); if (list) list.push(e); else map.set(k, [e]); };
+    for (const e of entries) {
+      const it = itemOf(e);
+      if (it.index) { add(byIndex, it.index, e); continue; }
+      plain.push(e);
+      if (it.level === 66) renames.push(e);
+      else add(byRecord, itemsInRecord(it), e);
+    }
+    return {
+      mayOverlap: (it) => {
+        if (it.index) return byIndex.get(it.index) || [];
+        if (it.level === 66) return plain;
+        const same = byRecord.get(itemsInRecord(it));
+        return same ? (renames.length ? same.concat(renames) : same) : renames;
+      },
+    };
+  };
+  // Arguments the CICS API documents as data-values, which the command reads and never fills: the
+  // program or transaction it transfers to or starts, and the system it ships the request to.
+  const CICS_READS = { LINK: ['PROGRAM', 'TRANSID', 'SYSID'], XCTL: ['PROGRAM'], START: ['TRANSID', 'SYSID'], RETURN: ['TRANSID'], LOAD: ['PROGRAM'], RELEASE: ['PROGRAM'] };
   const writtenBy = (n) => {
     const out = [];
     const add = (tok) => { const f = tok ? resolve(tok) : null; if (f) out.push(f.level === 88 && f.parent ? f.parent : f); };
@@ -667,28 +698,31 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         }
       }
     } else if (n.e) {
-      // A command may fill what any option is given directly, except what it sends FROM. A name
-      // inside that argument's own parentheses - a subscript, a reference modification - is read.
+      // A command may fill what any option is given directly, except what it sends FROM and the
+      // data-values it reads. A name inside that argument's own parentheses - a subscript, a
+      // reference modification - is read.
+      const reads = (n.e.kind === 'CICS' && CICS_READS[n.e.toks[0]?.u]) || [];
       let depth = 0;
       let option = null;
       for (let i = 0; i < n.e.toks.length; i++) {
         const t = n.e.toks[i];
         if (t.t === 'sep') { depth += t.v === '(' ? 1 : -1; continue; }
         if (depth === 0) { option = t.t === 'word' ? t.u : option; continue; }
-        if (depth === 1 && t.t === 'word' && option !== 'FROM') add(t);
+        if (depth === 1 && t.t === 'word' && option !== 'FROM' && !reads.includes(option)) add(t);
       }
     }
     return out;
   };
   // A VALUE holds for the whole run only if no statement writes storage that overlaps the item.
-  let writtenItems = null;
+  let written = null;
   const neverWritten = (it) => {
     if (it.external) return false;
-    if (!writtenItems) {
-      writtenItems = [];
-      for (const n of nodes) if (n.kind === 'stmt' || n.kind === 'exec' || n.kind === 'step' || n.kind === 'call') writtenItems.push(...writtenBy(n));
+    if (!written) {
+      const all = [];
+      for (const n of nodes) if (n.kind === 'stmt' || n.kind === 'exec' || n.kind === 'step' || n.kind === 'call') all.push(...writtenBy(n));
+      written = byStorage(all, (w) => w);
     }
-    return !writtenItems.some((w) => overlaps(w, it));
+    return !written.mayOverlap(it).some((w) => overlaps(w, it));
   };
   const constValue = (toks) => {
     if (toks.length === 3 && WORD(toks[0], 'LENGTH') && WORD(toks[1], 'OF')) {
@@ -2373,17 +2407,17 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     for (const f of [c.x, c.t, c.f, c.rt, c.rf]) if (f != null) list.push(f);
     factsOfKey.set(c.key, list);
   }
+  const checkedFields = byStorage([...factsOfKey.keys()].filter((key) => fields.get(key)), (key) => fields.get(key));
   const killCache = new Map();
   const killOf = (w) => {
     if (!w) return null;
     let bits = killCache.get(w);
     if (bits !== undefined) return bits;
     bits = null;
-    for (const [key, list] of factsOfKey) {
-      const f = fields.get(key);
-      if (!f || !overlaps(w, f)) continue;
+    for (const key of checkedFields.mayOverlap(w)) {
+      if (!overlaps(w, fields.get(key))) continue;
       bits ||= new Uint32Array(words);
-      for (const x of list) bits[x >>> 5] |= 1 << (x & 31);
+      for (const x of factsOfKey.get(key)) bits[x >>> 5] |= 1 << (x & 31);
     }
     killCache.set(w, bits);
     return bits;
@@ -2629,10 +2663,15 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // Every route from `entry` that reaches `stopAt` or the program's end, meeting at joins. A call
   // whose range never returns ends the route, as a STOP RUN does. `calls` collects the ranges the
   // routes perform, for whoever needs to know what depends on what.
+  // A run holds a bitset per node it reaches. Those of a run nobody reads any more are handed back
+  // and reused, since allocating them afresh for every run was most of the analysis's collection time.
+  const spare = [];
+  const copyOf = (bits) => { const a = spare.pop(); if (!a) return bits.slice(); a.set(bits); return a; };
+  const release = (IN) => { for (const a of IN.values()) spare.push(a); };
   function run(entry, input, stopAt, calls = null) {
     const IN = new Map();
     let exitOut = null;
-    IN.set(entry, input.slice());
+    IN.set(entry, copyOf(input));
     push(entry);
     while (heap.length) {
       const id = pop();
@@ -2643,7 +2682,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       if (id === stopAt) { if (exitOut) meetInto(exitOut, out); else exitOut = out.slice(); continue; }
       for (const s of n.succ) {
         const cur = IN.get(s);
-        if (!cur) { IN.set(s, out.slice()); push(s); } else if (meetInto(cur, out)) push(s);
+        if (!cur) { IN.set(s, copyOf(out)); push(s); } else if (meetInto(cur, out)) push(s);
       }
     }
     return { IN, exitOut };
@@ -2675,7 +2714,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       for (const d of n.derive || []) if (d.needs.every((x) => has(bits, x))) approved.add(d);
       for (const entry of n.implies || []) if (entry[2] && has(bits, entry[0])) approved.add(entry);
     }
-    const top = run(r.entry, ONES, r.end, calls).exitOut;
+    release(fromNone.IN);
+    const fromAll = run(r.entry, ONES, r.end, calls);
+    const top = fromAll.exitOut;
+    release(fromAll.IN);
     approved = null;
     for (const k of calls) { if (!callers.has(k)) callers.set(k, new Set()); callers.get(k).add(r); }
     const old = summaries.get(r.key);
@@ -2704,7 +2746,9 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     waiting.delete(c.key);
     const input = c.stopAt == null ? ZERO : rangeIn.get(c.key);
     const res = run(c.entry, input, c.stopAt);
+    const superseded = results.get(c.key);
     results.set(c.key, res.IN);
+    if (superseded) release(superseded);
     for (const [id, bits] of res.IN) {
       const n = nodes[id];
       if (n.kind !== 'call' || !byKey.has(n.range.key)) continue;
@@ -2723,7 +2767,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   for (const IN of results.values()) {
     for (const [id, bits] of IN) {
       const had = facts.get(id);
-      if (had) meetInto(had, bits); else facts.set(id, bits.slice());
+      if (had) meetInto(had, bits); else facts.set(id, bits);
     }
   }
   };
@@ -2906,7 +2950,31 @@ function readersOf(tree) {
   return out;
 }
 
-export const hasFact = (bits, x) => x != null && bits != null && (bits[x >>> 5] & (1 << (x & 31))) !== 0;
+// A fact set is a Uint32Array with one bit per fact, or, where a program keeps it after its analysis,
+// a Uint16Array holding the sorted numbers of the facts that hold (sparseFacts).
+export const hasFact = (bits, x) => x != null && bits != null
+  && (bits instanceof Uint16Array ? holdsSorted(bits, x) : (bits[x >>> 5] & (1 << (x & 31))) !== 0);
+function holdsSorted(list, x) {
+  let lo = 0;
+  let hi = list.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >>> 1;
+    if (list[mid] === x) return true;
+    if (list[mid] < x) lo = mid + 1; else hi = mid - 1;
+  }
+  return false;
+}
+
+// The facts a set holds as their sorted numbers, where every number fits 16 bits; the set itself otherwise.
+export function sparseFacts(bits) {
+  if (bits.length * 32 > 65536) return bits;
+  let n = 0;
+  for (let i = 0; i < bits.length; i++) for (let w = bits[i]; w; w &= w - 1) n++;
+  const out = new Uint16Array(n);
+  let k = 0;
+  for (let i = 0; i < bits.length; i++) for (let w = bits[i]; w; w &= w - 1) out[k++] = i * 32 + (31 - Math.clz32(w & -w));
+  return out;
+}
 
 // What a node's checks say at a point, given the facts that hold there: 2 when the value it holds is
 // safe for the sink, 1 when a check has run on every route to the point, 0 when neither. The check

package/lib/csd.mjs

@@ -14,7 +14,7 @@ const COMMAND = /^\s*(DEFINE|ADD|ALTER|APPEND|COPY|DELETE|INITIALIZE|LIST|REMOVE
 // { tdqueues: Map(name -> { type, ddname, indirect, line }),
 //   transactions: Map(name -> { program, cmdsec, ressec, line }),
 //   tcpipservices: Map(name -> { port, protocol, ssl, authenticate, transaction, line }),
-//   urimaps: Map(name -> { usage, path, program, transaction, tcpipservice, line }) }
+//   urimaps: Map(name -> { usage, path, program, transaction, tcpipservice, scheme, host, attls, line }) }
 export function parseCsd(text) {
   const tdqueues = new Map();
   const transactions = new Map();
@@ -64,6 +64,11 @@ export function parseCsd(text) {
         program: attrs.get('PROGRAM') || null,
         transaction: attrs.get('TRANSACTION') || null,
         tcpipservice: attrs.get('TCPIPSERVICE') || null,
+        // A client URIMAP's scheme decides whether WEB OPEN URIMAP(name) asks for TLS; ATTLS(AWARE)
+        // has AT-TLS secure an HTTP scheme outside CICS.
+        scheme: attrs.get('SCHEME') || null,
+        host: attrs.get('HOST') || null,
+        attls: attrs.get('ATTLS') || null,
         line: b.line,
       });
     } else if (kind === 'TDQUEUE') {