eyeprolog 1.3.22 → 1.3.24

package/package.json

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

package/src/iso.js

@@ -6,7 +6,7 @@ import {
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { sameNumberValue } from './number-value.js';
-import { createParserOperatorState, parseGoalText, parseNumberTokenText, parseTermText } from './parser.js';
+import { NumberRepresentationError, createParserOperatorState, parseGoalText, parseNumberTokenText, parseTermText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import {
@@ -1235,7 +1235,8 @@ function readTermFromStream(stream, solver) {
         const term = parseReadTermText(candidate.text, solver);
         stream.position = candidate.end;
         return scopeReadTerm(term);
-      } catch (_) {
+      } catch (error) {
+        if (error instanceof NumberRepresentationError) throw new PrologError(error.formal);
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.
       }
@@ -1371,6 +1372,7 @@ function writeBuiltin(mode) {
     solver.io.writeUnit(stream, formatTermForWrite(goal.args[goal.arity - 1], env, {
       ...options,
       generateVariableNames: true,
+      variableNameState: solver.writeVariableState,
       operators: solver.program.operators.values(),
     }));
     yield env;
@@ -1388,6 +1390,7 @@ function* writeTermBuiltin({ solver, goal, env }) {
   solver.io.writeUnit(stream, formatTermForWrite(goal.args[goal.arity - 2], env, {
     ...options,
     generateVariableNames: true,
+    variableNameState: solver.writeVariableState,
     operators: solver.program.operators.values(),
   }));
   yield env;
@@ -1659,7 +1662,8 @@ function parseIsoNumber(text) {
     const finite = Number(value.name);
     if (!Number.isFinite(finite)) return null;
     return numberTerm(numberTextFromDouble(finite));
-  } catch (_) {
+  } catch (error) {
+    if (error instanceof NumberRepresentationError) throw new PrologError(error.formal);
     return null;
   }
 }
@@ -2297,9 +2301,10 @@ function evaluate(term, env) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
   if (term.type === NUMBER) {
-    return isDecimalInteger(term.name)
-      ? { integer: true, value: BigInt(term.name) }
-      : { integer: false, value: Number(term.name) };
+    if (isDecimalInteger(term.name)) return { integer: true, value: BigInt(term.name) };
+    const value = Number(term.name);
+    if (!Number.isFinite(value)) throw new PrologError('evaluation_error(float_overflow)');
+    return { integer: false, value };
   }
   if (term.type === ATOM) {
     if (term.name === 'pi') return { integer: false, value: Math.PI };

package/src/parser.js

@@ -3,6 +3,23 @@
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
 
+
+export class NumberRepresentationError extends Error {
+  constructor(formal) {
+    super(`error(${formal})`);
+    this.name = 'NumberRepresentationError';
+    this.formal = formal;
+  }
+}
+
+function finiteFloatTokenText(text) {
+  const value = Number(text);
+  if (!Number.isFinite(value)) {
+    throw new NumberRepresentationError('representation_error(max_float)');
+  }
+  return value === 0 ? '0.0' : text;
+}
+
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
   LPAREN: '(', RPAREN: ')', LBRACKET: '[', RBRACKET: ']', LBRACE: '{', RBRACE: '}',
@@ -536,7 +553,7 @@ class Parser {
       }
       let text = this.source.slice(start, this.pos);
       if (!hasFraction) text = BigInt(text).toString();
-      else if (Object.is(Number(text), -0)) text = '0.0';
+      else text = finiteFloatTokenText(text);
       return { type: TOK.NUMBER, text, line };
     }
 
@@ -1510,8 +1527,7 @@ export function parseNumberTokenText(text) {
   }
   if (position !== source.length) throw invalidNumberTokenError;
   if (/^-?\d+$/.test(source)) return numberTerm(BigInt(source).toString());
-  if (Object.is(Number(source), -0)) return numberTerm('0.0');
-  return numberTerm(source);
+  return numberTerm(finiteFloatTokenText(source));
 }
 
 export function parseTermText(text, options = {}) {

package/src/solver.js

@@ -116,6 +116,11 @@ export class Solver {
       }
     }
     this.io = options.io ?? new StreamManager(options.ioOptions);
+    // Keep generated write-variable names stable for the lifetime of one
+    // top-level query. Inner/meta-call solvers share this state so separate
+    // write/1, writeq/1, write_canonical/1, and write_term/2-3 calls can refer
+    // to the same logical variable by the same printed name.
+    this.writeVariableState = options.writeVariableState ?? { depth: 0, names: new Map(), next: 0 };
     this.solveStacks = [];
     this.active = [];
     this.cutEpoch = 0;
@@ -163,6 +168,7 @@ export class Solver {
       io: this.io,
       innerTableScopes: this.innerTableScopes,
       inferenceObservation: this.inferenceObservation,
+      writeVariableState: this.writeVariableState,
       skipListTailTabling: options.skipListTailTabling ?? this.skipListTailTabling,
     });
     if (options.tableScope != null) {
@@ -279,6 +285,13 @@ export class Solver {
     if (!Array.isArray(goals)) goals = [goals];
     env.setOccursCheckHandler(this.occursCheckHandler);
 
+    const writeVariableState = this.writeVariableState;
+    if (writeVariableState.depth === 0) {
+      writeVariableState.names.clear();
+      writeVariableState.next = 0;
+    }
+    writeVariableState.depth++;
+
     const savedActive = this.active;
     let registeredStack = null;
     try {
@@ -651,6 +664,11 @@ export class Solver {
       const stackIndex = this.solveStacks.indexOf(registeredStack);
       if (stackIndex >= 0) this.solveStacks.splice(stackIndex, 1);
       this.active = savedActive;
+      writeVariableState.depth = Math.max(0, writeVariableState.depth - 1);
+      if (writeVariableState.depth === 0) {
+        writeVariableState.names.clear();
+        writeVariableState.next = 0;
+      }
     }
   }
 

package/src/write.js

@@ -180,13 +180,14 @@ function generatedVariableName(index) {
   return suffix === 0 ? `_${letter}` : `_${letter}${suffix}`;
 }
 
-function printableGeneratedVariableNames(term, env, explicit) {
+function printableGeneratedVariableNames(term, env, explicit, state = null) {
   const names = new Map(explicit);
-  const used = new Set(names.values());
+  const sharedNames = state?.names instanceof Map ? state.names : new Map();
+  const used = new Set([...sharedNames.values(), ...names.values()]);
   const seenVariables = new Set();
   const seenTerms = new Set();
   const stack = [term];
-  let generated = 0;
+  let generated = Number.isSafeInteger(state?.next) ? state.next : 0;
 
   while (stack.length) {
     const current = deref(stack.pop(), env);
@@ -194,8 +195,14 @@ function printableGeneratedVariableNames(term, env, explicit) {
       if (seenVariables.has(current.name)) continue;
       seenVariables.add(current.name);
       if (names.has(current.name)) continue;
+      const shared = sharedNames.get(current.name);
+      if (shared != null) {
+        names.set(current.name, shared);
+        continue;
+      }
       let candidate;
       do candidate = generatedVariableName(generated++); while (used.has(candidate));
+      sharedNames.set(current.name, candidate);
       names.set(current.name, candidate);
       used.add(candidate);
       continue;
@@ -205,6 +212,7 @@ function printableGeneratedVariableNames(term, env, explicit) {
     for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
   }
 
+  if (state != null) state.next = generated;
   return names;
 }
 
@@ -317,7 +325,7 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
     variableNames: options.generateVariableNames === true
-      ? printableGeneratedVariableNames(term, env, explicitVariableNames)
+      ? printableGeneratedVariableNames(term, env, explicitVariableNames, options.variableNameState)
       : printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,

package/test/run-regression.mjs

@@ -738,6 +738,77 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'float literals reject overflow and normalize underflow (issue #54)',
+      run: () => {
+        const result = runCli([], {
+          input: [
+            'T = 1.0e-99999, F is T.',
+            'T = 1.0e99999, float(T).',
+            'T = 1.0e99999, float(T), F is T.',
+            'T = 1.0e99999, U = 2.0e99999, T > U.',
+            'T = 1.0e99999, U = 2.0e99999, T < U.',
+            'T = 1.0e99999, U = 2.0e99999, T = U.',
+            'T = 1.0e99999, U = 2.0e99999, T =:= U.',
+            'halt.',
+            '',
+          ].join('\n'),
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, 'T = 0.0, F = 0.0.', 'underflow rounds on input');
+        assertEqual(
+          (result.stdout.match(/error\(representation_error\(max_float\)\)\./g) ?? []).length,
+          6,
+          'all overflowing literals fail while being read',
+        );
+        assertEqual(result.stderr, '', 'stderr');
+
+        let overflow = null;
+        try {
+          parseNumberTokenText('1.0e99999');
+        } catch (error) {
+          overflow = error;
+        }
+        assertEqual(overflow?.formal, 'representation_error(max_float)', 'number token overflow');
+        assertEqual(parseNumberTokenText('1.0e-99999').name, '0.0', 'number token underflow');
+
+        const chars = Array.from('1.0e99999', atom);
+        const numberChars = createDefaultRegistry().get('number_chars', 2).handler;
+        let numberCharsError = null;
+        try {
+          numberChars({
+            goal: compound('number_chars', [variable('N'), listFromItems(chars)]),
+            env: new Env(),
+          }).next();
+        } catch (error) {
+          numberCharsError = error;
+        }
+        assertEqual(numberCharsError?.formal, 'representation_error(max_float)', 'number_chars overflow');
+
+        let readError = null;
+        try {
+          runEyeProlog('', {
+            goal: 'read(X)',
+            ioOptions: { input: '1.0e99999.\n' },
+          });
+        } catch (error) {
+          readError = error;
+        }
+        assertEqual(readError?.formal, 'representation_error(max_float)', 'read/1 overflow');
+
+        const isHandler = createDefaultRegistry().get('is', 2).handler;
+        let hostTermError = null;
+        try {
+          isHandler({
+            goal: compound('is', [variable('F'), numberTerm('1.0e99999')]),
+            env: new Env(),
+          }).next();
+        } catch (error) {
+          hostTermError = error;
+        }
+        assertEqual(hostTermError?.formal, 'evaluation_error(float_overflow)', 'host-created non-finite term');
+      },
+    },
     {
       name: 'readers keep a full stop inside a character-code constant (WG17 #367)',
       run: () => {
@@ -2989,6 +3060,20 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(fresh.stdout, '_A\nemit.\n', 'fresh clause variable hides its internal suffix');
       },
     },
+    {
+      name: 'write predicates keep generated variable names stable across calls (issue #53 comment 5356861151)',
+      run: () => {
+        const result = run([
+          "emit :- write_term(pair(A,B), []), write(' / '), write_term(user_output,B,[]), write(' / '), writeq(A), write(' / '), write_canonical(B), nl.",
+          "again :- write_canonical(B+B), nl.",
+        ].join('\n'), { goals: ['emit', 'again'] });
+        assertEqual(
+          result.stdout,
+          'pair(_A,_B) / _B / _A / _B\nemit.\n+(_A,_A)\nagain.\n',
+          'stable names across calls and reset at the next top-level query',
+        );
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {