eyeprolog 1.5.100 → 1.5.102

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.100",
+  "version": "1.5.102",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/parser.js

@@ -203,6 +203,21 @@ const CLPZ_OPERATOR_DEFINITIONS = [
   [450, 'xfx', '..'],
 ];
 
+// Names of bundled library(Name) modules whose own operators are pre-seeded
+// into the live parser's operator table the moment `:- use_module(library(
+// Name))` is parsed (applyImportedLibraryOperators below), rather than only
+// once that module's own `:- op(...)` directives are themselves parsed. A
+// library's clauses are parsed and processed in one pass (see
+// loadSourceIntoBuilder in program.js), so without this a file that both
+// imports one of these libraries and uses its custom operator syntax later
+// in the very same source text would fail to parse. Any bundled library
+// whose own source declares `:- op(...)` must be listed here, or it cannot
+// safely be served from the prepared-clause cache in program.js: a cache
+// hit replays already-parsed clause objects directly and never re-runs a
+// live Parser over that library's text, so a cached op/3 directive from an
+// unlisted library would never reach a live parser's operator table.
+export const PRESEEDED_LIBRARY_OPERATOR_NAMES = new Set(['clpz', 'atts', 'tabling', 'debug']);
+
 function operatorStrength(priority) {
   return 1201 - priority;
 }
@@ -421,6 +436,7 @@ class Parser {
     const designation = directive.args[0];
     if (designation?.type !== COMPOUND || designation.name !== 'library' || designation.arity !== 1 ||
         designation.args[0]?.type !== ATOM) return;
+    if (!PRESEEDED_LIBRARY_OPERATOR_NAMES.has(designation.args[0].name)) return;
     if (designation.args[0].name === 'clpz') {
       for (const [priority, specifier, name] of CLPZ_OPERATOR_DEFINITIONS) {
         this.defineOperator(priority, specifier, name);
@@ -1428,6 +1444,28 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return value;
   };
 
+  // SIMPLE_NUMBER-matched text is already lexically valid Prolog number
+  // syntax, and this fast path deliberately leaves a numeric literal's
+  // spelling otherwise untouched (test/conformance/cases/arithmetic/
+  // 024_numeric_literal_readback.pl: decimal and exponent literals retain
+  // their lexical form here, so e.g. 6.02e23 must not become 6.02e+23).
+  // Two things still cannot be left as raw matched text, though: an integer
+  // is never left non-canonical anywhere else in the language (a leading
+  // zero, or the "-0" from issue #114, must collapse the same way the
+  // scanner's own adjacent-minus BigInt construction already does), and a
+  // float whose value is exactly zero must never print with a stray minus --
+  // this implementation deliberately never produces -0.0 (term.js
+  // numberTextFromDouble) -- without reformatting any non-zero float.
+  const canonicalFastNumberText = (text) => {
+    if (text.includes('.') || text.includes('e') || text.includes('E')) {
+      return (text.charCodeAt(0) === 45 && Number(text) === 0) ? text.slice(1) : text;
+    }
+    const first = text.charCodeAt(0);
+    if (first !== 45 && (text.length === 1 || first !== 48)) return text;
+    return BigInt(text).toString();
+  };
+  const fastNumberTerm = (text) => numberTerm(canonicalFastNumberText(text));
+
   const isFastScalarToken = (text) => SIMPLE_VARIABLE.test(text) || SIMPLE_ATOM.test(text) || GRAPHIC_ATOM.test(text) || SIMPLE_NUMBER.test(text);
   const scalarOrVariableFast = (text) => {
     if (!text || !isFastScalarToken(text)) throw new Error('bad simple term');
@@ -1440,7 +1478,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
       variableCache.set(text, value);
       return value;
     }
-    if ((first === 45 || isDigitCode(first)) && SIMPLE_NUMBER.test(text)) return cached(numberCache, text, numberTerm);
+    if ((first === 45 || isDigitCode(first)) && SIMPLE_NUMBER.test(text)) return cached(numberCache, text, fastNumberTerm);
     return atom(text);
   };
 
@@ -1506,7 +1544,10 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
       return term;
     }
     if (kind === 'atom') return atom(value);
-    if (simpleNumberInRange(text, start, end)) return cached(numberCache, value, numberTerm);
+    // See canonicalFastNumberText above: "-0" and "007" must still come out
+    // the same as everywhere else in the language (issue #114), without
+    // reformatting a non-zero float's retained lexical spelling.
+    if (simpleNumberInRange(text, start, end)) return cached(numberCache, value, fastNumberTerm);
     return null;
   };
 
@@ -1522,6 +1563,12 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     if (type == null) return false;
     let name = text.slice(start, end);
     if (type === 'var' && name === '_') name = `__anon${anonymous++}`;
+    // This range becomes a CompactBinaryClause argument, materialized lazily
+    // as numberTerm(name) (program-indexing.js) and used as-is for indexing.
+    // Canonicalize the stored text up front for the same reason as the two
+    // callers above -- otherwise a fact such as bar(-0, 1) or bar(007, 1)
+    // keeps its raw, non-canonical spelling forever (issue #114).
+    if (type === 'number') name = canonicalFastNumberText(name);
     if (slot === 0) {
       out.arg0Type = type;
       out.arg0Name = name;

package/src/program.js

@@ -6,6 +6,7 @@ import {
   ISO_OPERATOR_DEFINITIONS,
   PART2_OPERATOR_DEFINITIONS,
   PART3_OPERATOR_DEFINITIONS,
+  PRESEEDED_LIBRARY_OPERATOR_NAMES,
   QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
@@ -108,9 +109,43 @@ function hasDirectCutTailRecursion(group) {
   return sawRecursive;
 }
 
+// library(clpz) alone pulls in about a dozen further bundled libraries
+// (assoc, pairs, between, lists, atts, iso_ext, dcgs, terms, error, si,
+// freeze, arithmetic, debug, format) via its own use_module/1-2 directives,
+// each recursively loaded and prepared (parsed, DCG- and goal-expanded,
+// dependency-analyzed) from scratch on every single program that needs
+// clpz. Matching against every bundled filename, not just clpz.pl's own,
+// lets each of those dependencies -- and every other bundled library used
+// this way -- be prepared once per process and reused, the same as clpz.pl
+// itself already was.
+//
+// A cache hit replays already-prepared clause objects directly (see below)
+// and never re-runs a live Parser over that library's own source text. A
+// library whose own source declares `:- op(...)` relies on exactly that
+// live parse to install its operators into the importing file's operator
+// table before the rest of that file is parsed (loadSourceIntoBuilder
+// processes one whole source's clauses only after fully parsing it), so
+// serving such a library from this cache would silently stop a sibling
+// source term, later in the very same file as its use_module/1 directive,
+// from parsing with that library's operator syntax. Only a library the
+// parser separately pre-seeds regardless of caching
+// (PRESEEDED_LIBRARY_OPERATOR_NAMES) is safe to include despite declaring
+// its own operators.
+const OWN_OPERATOR_DIRECTIVE = /:-(?:\s|\/\*[\s\S]*?\*\/)*op\s*\(/;
+const bundledLibraryFilenames = new Set(
+  Array.from(standardLibrarySources.entries())
+    .filter(([name, entry]) => PRESEEDED_LIBRARY_OPERATOR_NAMES.has(name) || !OWN_OPERATOR_DIRECTIVE.test(entry.source))
+    .map(([, entry]) => entry.filename),
+);
+
 function preparedBundledLibraryCacheKey(program, options) {
   const filename = String(options.filename ?? '');
-  if (filename !== standardLibrarySources.get('clpz')?.filename) return null;
+  if (!bundledLibraryFilenames.has(filename)) return null;
+  // Strict ISO Part 1 skips the normal-profile clause preparation
+  // (expandClauseGoals, normalizeQualifiedClauseHead, DCG expansion) that
+  // this cache stores the result of, so a strict-mode load must never be
+  // served from -- or poison -- a normal-mode cache entry for the same file.
+  if (program.strictIso) return null;
   // A user hook deliberately defined before use_module/1 is allowed to
   // transform bundled source. Such a program needs its own ordinary expansion.
   if (program.groups.has(modulePredicateKey('user', 'term_expansion', 2)) ||

package/test/regression/cases-regression.mjs

@@ -5892,5 +5892,60 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
         }
       },
     },
+    {
+      // https://github.com/eyereasoner/eyeprolog/issues/114#issuecomment-5663598188
+      name: 'the fast compact-clause loader canonicalizes numeric literals the same way the general parser does (issue #114 follow-up)',
+      run: () => {
+        // parseClausesFastNoSource (src/parser.js) has its own, separate
+        // number-token handling for facts and rules that match its compact
+        // two-argument shape -- exactly the kind of second code path that
+        // reintroduces the #114 bug class. It used to build every numeric
+        // argument straight from the raw regex-matched text, so a fact like
+        // bar(-0, 1) or bar(007, 1) kept that raw spelling forever instead of
+        // canonicalizing like every other numeric literal in the language.
+        for (const [program, goal, expected] of [
+          ["bar(-0, 1).\n", 'bar(A, B), write_canonical(A), nl', '0'],
+          ["bar(-0.0, 1).\n", 'bar(A, B), write_canonical(A), nl', '0.0'],
+          ["bar(007, 1).\n", 'bar(A, B), write_canonical(A), nl', '7'],
+          ['point(1, -0).\n', 'point(A, B), write_canonical(B), nl', '0'],
+        ]) {
+          const stdout = run(program, { goal }).stdout;
+          assertEqual(stdout.split('\n')[0], expected, `${program.trim()}: ${goal}`);
+        }
+        // The fast loader also deliberately retains a numeric literal's exact
+        // lexical spelling otherwise (test/conformance/cases/arithmetic/
+        // 024_numeric_literal_readback.pl): the zero-canonicalization above
+        // must not turn into a general reformatting pass that rewrites a
+        // non-zero float's notation.
+        assertEqual(
+          run('raw(a, 6.02e23).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
+          '6.02e23',
+          'non-zero exponent notation is preserved, not reformatted to 6.02e+23',
+        );
+        assertEqual(
+          run('raw(a, -1.0e-3).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
+          '-1.0e-3',
+          'non-zero negative exponent notation is preserved, not reformatted to -0.001',
+        );
+      },
+    },
+    {
+      // https://github.com/eyereasoner/eyeprolog/issues/114#issuecomment-5663598188
+      name: 'a genuine IEEE-754 negative zero produced by arithmetic (not just parsed from text) still prints as 0.0',
+      run: () => {
+        // Every fix above canonicalizes -0.0 where it is spelled out in
+        // source text. EyeProlog's floats are ordinary JS doubles, though,
+        // and JS arithmetic itself produces a real, distinct -0.0 bit
+        // pattern for operations such as a negative number times zero --
+        // this is genuine IEEE-754 negative zero, not a text-parsing
+        // artifact, and 13211-1 has nothing to say about it either way. It
+        // must still come out normalized to plain 0.0 on the way to a term,
+        // the same as every syntactic spelling of negative zero does.
+        for (const goal of ['X is -1.0 * 0.0', 'X is 0.0 * -1.0', 'X is -(1.0 - 1.0)']) {
+          const stdout = run('', { goal: `${goal}, write_canonical(X), nl` }).stdout;
+          assertEqual(stdout.split('\n')[0], '0.0', `${goal}: internal -0.0 normalizes to 0.0`);
+        }
+      },
+    },
   ];
 }