@portll/cobolwork 0.2.76 → 0.2.140

package/lib/options.mjs

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Whether the options a program is compiled with generate the run-time checks a policy requires:
 // docs/spec/build-gate.md §7. Enterprise COBOL's options and what they mean are from IBM's
-// documentation; the GnuCOBOL flags are recorded in provenance/compiler-options.json with how each
-// was confirmed by compiling. Nothing here is taken from GnuCOBOL's source (spec §16).
+// documentation; the GnuCOBOL and gcobol flags are recorded in provenance/compiler-options.json with
+// how each was confirmed by compiling. Nothing here is taken from either compiler's source (spec §16).
 import { basename, posix } from 'node:path';
 import { PROGRAM_EXT } from './sources.mjs';
+import { OPTION_SPELLINGS } from './enterprise-options.mjs';
 
 // Split on blanks and commas outside parentheses: SSRANGE(NOZLEN,ABD) is one option.
 export function optionTokens(text) {
@@ -43,13 +44,10 @@ const parse = (token) => {
   return m ? { name: m[1], subs: m[2] === undefined ? [] : optionTokens(m[2]) } : { name: token, subs: [] };
 };
 
-// Each family's spellings. An abbreviation IBM does not document is not accepted, so an option the
-// gate cannot read counts as absent, which fails closed.
-const FAMILIES = {
-  SSRANGE: { on: ['SSRANGE', 'SSR'], off: ['NOSSRANGE', 'NOSSR'] },
-  NUMCHECK: { on: ['NUMCHECK'], off: ['NONUMCHECK'] },
-  PARMCHECK: { on: ['PARMCHECK', 'PC'], off: ['NOPARMCHECK', 'NOPC'] },
-};
+// Each family's spellings, as IBM's option table gives them. A spelling the table does not hold is
+// not accepted, so an option the gate cannot read counts as absent, which fails closed.
+const spellingsOf = (option, off) => Object.keys(OPTION_SPELLINGS).filter((s) => OPTION_SPELLINGS[s][0] === option && OPTION_SPELLINGS[s][1] === off);
+const FAMILIES = Object.fromEntries(['SSRANGE', 'NUMCHECK', 'PARMCHECK'].map((f) => [f, { on: spellingsOf(f, false), off: spellingsOf(f, true) }]));
 const FAMILY_OF_CHECK = { subscript: 'SSRANGE', 'reference-modification': 'SSRANGE', 'numeric-data': 'NUMCHECK', 'argument-length': 'PARMCHECK' };
 
 // Whether one family's setting abends on a failed check. A bare SSRANGE is SSRANGE(NOZLEN,ABD); a
@@ -121,7 +119,17 @@ const EXCEPTION_OF_CHECK = {
   'argument-length': 'EC-PROGRAM-ARG-MISMATCH',
 };
 
-export const isCobc = (command) => /^cobc(\.exe)?$/i.test(basename(String(command || '')));
+// gcobol 16 refuses to compile with these enabled ("sorry, unimplemented"), and EC-ALL does not
+// generate them.
+const GCOBOL_UNIMPLEMENTED = new Set(['EC-DATA-INCOMPATIBLE', 'EC-PROGRAM-ARG-MISMATCH']);
+
+// GnuCOBOL's cobc, or GCC's gcobol under its versioned or cross-compiler names.
+export function compilerOf(command) {
+  const name = basename(String(command || '')).replace(PREFIX, '');
+  if (/^cobc(\.exe)?$/i.test(name)) return 'gnucobol';
+  if (/^(?:[a-z0-9_]+-)*gcobol(?:-\d+(?:\.\d+)*)?(\.exe)?$/i.test(name)) return 'gcobol';
+  return null;
+}
 
 const exceptionName = (v) => {
   const u = String(v).toUpperCase();
@@ -251,17 +259,21 @@ const argsOf = (words) => {
   return out;
 };
 
-// The argument vector of each cobc command in one simple command. A command held in one word -
-// sh -c "…", an alias, a CMD's string - is read as a command line of its own.
-function cobcCommands(words, dialect, depth = 0) {
+// Text that may run cobc or gcobol.
+const NAMES_A_COMPILER = /cobc|gcobol/i;
+
+// The compiler and argument vector of each cobc or gcobol command in one simple command. A command
+// held in one word - sh -c "…", an alias, a CMD's string - is read as a command line of its own.
+function compilerCommands(words, dialect, depth = 0) {
   const at = leadOf(words);
   if (at < 0 || MESSAGE.test(words[at].replace(PREFIX, ''))) return [];
   for (let i = at; i < words.length; i++) {
     const w = words[i];
-    if (isCobc(w.replace(PREFIX, ''))) return [argsOf(words.slice(i + 1))];
+    const compiler = compilerOf(w);
+    if (compiler) return [{ compiler, args: argsOf(words.slice(i + 1)) }];
     const inner = w.replace(/^[A-Za-z_]\w*=/, '');
-    if (depth < 2 && /\s/.test(inner) && /cobc/i.test(inner)) {
-      const found = commandsOf(shellTokens(inner, dialect)).flatMap((ws) => cobcCommands(ws, dialect, depth + 1));
+    if (depth < 2 && /\s/.test(inner) && NAMES_A_COMPILER.test(inner)) {
+      const found = commandsOf(shellTokens(inner, dialect)).flatMap((ws) => compilerCommands(ws, dialect, depth + 1));
       if (found.length) return found;
     }
   }
@@ -272,15 +284,15 @@ function cobcCommands(words, dialect, depth = 0) {
 const changeDir = (dir, to) => (!to || /[$%~`]/.test(to) || /^(?:\/|[A-Za-z]:[\\/]|-$)/.test(to) ? null
   : posix.normalize(posix.join(dir || '.', to.replace(/\\/g, '/'))));
 
-// The cobc commands in a command line, each with the directory a cd before it on the line moved to.
-// `state.dir` carries a cd forward to later lines, for a script whose lines one shell runs.
+// The compiler commands in a command line, each with the directory a cd before it on the line moved
+// to. `state.dir` carries a cd forward to later lines, for a script whose lines one shell runs.
 function commandLine(text, dialect, state, line, out) {
   for (const words of commandsOf(Array.isArray(text) ? text.map((word) => ({ word })) : shellTokens(text, dialect))) {
     const at = leadOf(words);
     const lead = at >= 0 ? words[at].replace(PREFIX, '').toLowerCase() : '';
     if (lead === 'cd' || lead === 'pushd' || lead === 'set-location') { state.dir = changeDir(state.dir, words.slice(at + 1).find((w) => !/^-./.test(w))); continue; }
-    for (const args of cobcCommands(words, dialect)) {
-      if (cobcOperands(args).length) out.push({ line, args, ...(state.dir && state.dir !== '.' ? { dir: state.dir } : {}) });
+    for (const { compiler, args } of compilerCommands(words, dialect)) {
+      if (sourceOperands(args, compiler).length) out.push({ line, compiler, args, ...(state.dir && state.dir !== '.' ? { dir: state.dir } : {}) });
     }
   }
 }
@@ -328,11 +340,12 @@ function expanded(text, vars, kind) {
   return t;
 }
 
-// Every cobc command a build script runs that names a source file, with the variables the same file
-// assigns substituted: [{ line, args, dir? }]. `kind` is make, sh, yaml, docker, batch or powershell.
-// A command whose options come from a variable set elsewhere keeps the reference, which reads as no
-// option; one that names no source - cobc --version, which cobc - compiles nothing and is left out.
-export function cobcInvocations(text, { kind = 'sh' } = {}) {
+// Every cobc or gcobol command a build script runs that names a source file, with the variables the
+// same file assigns substituted: [{ line, compiler, args, dir? }]. `kind` is make, sh, yaml, docker,
+// batch or powershell. A command whose options come from a variable set elsewhere keeps the
+// reference, which reads as no option; one that names no source - cobc --version, which cobc -
+// compiles nothing and is left out.
+export function compilerInvocations(text, { kind = 'sh' } = {}) {
   const dialect = kind === 'batch' || kind === 'powershell' ? kind : 'sh';
   const vars = new Map();
   const continuation = { batch: /\^$/, powershell: /`$/ }[kind] || /\\$/;
@@ -403,11 +416,11 @@ function looseJson(text) {
   return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'));
 }
 
-// The cobc commands an editor's task file runs: VS Code's tasks.json. A task's command line is its
-// command and its arguments, read as its shell reads them, with the variants it gives for Windows,
-// Linux and macOS; it runs in the workspace folder, or in its options.cwd. ${workspaceFolder} is that
-// folder, and a variable that names the open file stands for any file.
-export function cobcTasks(text) {
+// The cobc and gcobol commands an editor's task file runs: VS Code's tasks.json. A task's command
+// line is its command and its arguments, read as its shell reads them, with the variants it gives for
+// Windows, Linux and macOS; it runs in the workspace folder, or in its options.cwd. ${workspaceFolder}
+// is that folder, and a variable that names the open file stands for any file.
+export function compilerTasks(text) {
   let doc;
   try { doc = looseJson(text); } catch { return []; }
   const lines = String(text).split(/\r?\n/);
@@ -428,7 +441,7 @@ export function cobcTasks(text) {
     for (const [variant, dialect] of [[task, 'sh'], [task.linux, 'sh'], [task.osx, 'sh'], [task.windows, 'powershell']]) {
       if (!variant || typeof variant !== 'object') continue;
       const command = valueOf(variant.command);
-      if (typeof command !== 'string' || !/cobc/i.test(`${command} ${JSON.stringify(variant.args || task.args || [])}`)) continue;
+      if (typeof command !== 'string' || !NAMES_A_COMPILER.test(`${command} ${JSON.stringify(variant.args || task.args || [])}`)) continue;
       const args = Array.isArray(variant.args) ? variant.args : Array.isArray(task.args) ? task.args : [];
       const cwd = (variant.options && variant.options.cwd) || (task.options && task.options.cwd);
       const dir = typeof cwd === 'string' ? changeDir(null, folder(cwd)) : null;
@@ -443,19 +456,25 @@ export function cobcTasks(text) {
 }
 
 // Options whose value is the next argument, which is not a source file: the output file, include and
-// library directories, a library, and options for the C compiler and the linker. Each was observed to
-// take the next argument (provenance/compiler-options.json).
-const TAKES_VALUE = new Set(['-o', '-I', '-L', '-l', '-A', '-Q', '-fec', '-fno-ec']);
+// library directories, a library, options for the C compiler and the linker, and for gcobol a CDF
+// name, a language, a dialect, a copybook extension and an included file. Each was observed to take
+// the next argument (provenance/compiler-options.json). gcobol's -main takes none: it marks the source
+// that follows it.
+const TAKES_VALUE = {
+  gnucobol: new Set(['-o', '-I', '-L', '-l', '-A', '-Q', '-fec', '-fno-ec']),
+  gcobol: new Set(['-o', '-I', '-L', '-l', '-D', '-x', '-dialect', '-copyext', '-include', '-fcobol-exceptions', '-fno-cobol-exceptions']),
+};
 const SOURCE_FILE = new RegExp(`(?:${PROGRAM_EXT.map((e) => e.replace('.', '\\.')).join('|')})$`, 'i');
 // A variable, a batch argument, a glob or find's {}: a file the command names only when it runs.
 const UNNAMED = /[$%*?!]|\{\}/;
 
-// The operands of a cobc command that name source files, as written.
-export function cobcOperands(args) {
+// The operands of a cobc or gcobol command that name source files, as written.
+export function sourceOperands(args, compiler = 'gnucobol') {
+  const takesValue = TAKES_VALUE[compiler];
   const out = [];
   for (let i = 0; i < args.length; i++) {
     const a = String(args[i]);
-    if (TAKES_VALUE.has(a)) { i++; continue; }
+    if (takesValue.has(a)) { i++; continue; }
     if (a.startsWith('-')) continue;
     if (SOURCE_FILE.test(a) || UNNAMED.test(a)) out.push(a);
   }
@@ -486,11 +505,6 @@ export function cobcChecks(args, { required, forbid = [] }) {
     if (value === undefined) continue;
     set(exceptionName(value), !m[1], shown);
   }
-  const forbidden = [];
-  for (const entry of forbid) {
-    const hit = args.find((a) => a === entry || String(a).startsWith(`${entry}=`));
-    if (hit) forbidden.push(`${hit} is on the command line, and the policy forbids it`);
-  }
   const add = [];
   const checks = required.map((check) => {
     if (state.get(check) === true) return { check, ok: true, why: 'turned on by the command line' };
@@ -499,14 +513,63 @@ export function cobcChecks(args, { required, forbid = [] }) {
     if (!add.includes(flag)) add.push(flag);
     return { check, ok: true, added: true, why: `added as ${flag}` };
   });
-  return { checks, forbidden, add };
+  return { checks, forbidden: forbiddenOn(args, forbid), add };
 }
 
+const forbiddenOn = (args, forbid) => forbid
+  .map((entry) => args.find((a) => a === entry || String(a).startsWith(`${entry}=`)))
+  .filter(Boolean).map((hit) => `${hit} is on the command line, and the policy forbids it`);
+
+// A gcobol argument vector, as cobcChecks reads cobc's. -fcobol-exceptions enables each condition it
+// lists; -fno-cobol-exceptions N withdraws the enabled conditions N covers, so after EC-BOUND it does
+// not withdraw EC-BOUND-SUBSCRIPT, and it never stops a later enable. A check whose condition gcobol
+// does not implement cannot be generated at all.
+export function gcobolChecks(args, { required, forbid = [] }) {
+  let enabled = [];
+  const turnedOff = new Map();
+  const listed = (v) => String(v).split(',').map((n) => n.trim().toUpperCase()).filter(Boolean);
+  for (let i = 0; i < args.length; i++) {
+    const a = String(args[i]);
+    const m = /^-f(no-)?cobol-exceptions(?:=(.*))?$/.exec(a);
+    if (!m) continue;
+    const value = m[2] !== undefined ? m[2] : args[++i];
+    if (value === undefined) continue;
+    const shown = m[2] !== undefined ? a : `${a} ${value}`;
+    for (const name of listed(value)) {
+      for (const check of required) {
+        if (!covers(name, EXCEPTION_OF_CHECK[check])) continue;
+        if (m[1]) turnedOff.set(check, shown); else turnedOff.delete(check);
+      }
+      enabled = m[1] ? enabled.filter((e) => !covers(name, e)) : [...enabled, name];
+    }
+  }
+  const add = [];
+  const checks = required.map((check) => {
+    const condition = EXCEPTION_OF_CHECK[check];
+    if (GCOBOL_UNIMPLEMENTED.has(condition)) return { check, ok: false, why: `${check} needs ${condition}, which gcobol does not implement` };
+    if (enabled.some((e) => covers(e, condition))) return { check, ok: true, why: 'turned on by the command line' };
+    if (turnedOff.has(check)) return { check, ok: false, why: `${turnedOff.get(check)} turns off the ${check} check` };
+    const flag = `-fcobol-exceptions=${condition}`;
+    add.push(flag);
+    return { check, ok: true, added: true, why: `added as ${flag}` };
+  });
+  return { checks, forbidden: forbiddenOn(args, forbid), add };
+}
+
+const CHECKS_OF = { gnucobol: cobcChecks, gcobol: gcobolChecks };
+const NOT_GIVEN = {
+  gnucobol: (check, c) => `${check} needs -fec=${c} or -debug, and the command gives neither`,
+  gcobol: (check, c) => `${check} needs -fcobol-exceptions=${c}, and the command does not give it`,
+};
+
+// The checks one compiler's argument vector generates: cobcChecks or gcobolChecks.
+export const compilerChecks = (compiler, args, opts) => CHECKS_OF[compiler](args, opts);
+
 // The same, for a command the gate reads rather than runs: a check nothing turned on is missing.
-export function scriptedCobcChecks(args, opts) {
-  const r = cobcChecks(args, opts);
+export function scriptedChecks(compiler, args, opts) {
+  const r = compilerChecks(compiler, args, opts);
   return {
-    checks: r.checks.map((c) => (c.added ? { check: c.check, ok: false, why: `${c.check} needs -fec=${EXCEPTION_OF_CHECK[c.check]} or -debug, and the command gives neither` } : c)),
+    checks: r.checks.map((c) => (c.added ? { check: c.check, ok: false, why: NOT_GIVEN[compiler](c.check, EXCEPTION_OF_CHECK[c.check]) } : c)),
     forbidden: r.forbidden,
   };
 }