eyeprolog 1.5.100 → 1.5.101

package/package.json

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

package/src/parser.js

@@ -1428,6 +1428,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 +1462,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 +1528,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 +1547,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/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`);
+        }
+      },
+    },
   ];
 }