eyeprolog 1.2.26 → 1.2.28

package/package.json

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

package/src/iso.js

@@ -1144,6 +1144,43 @@ function convertedTermText(text, solver) {
   }
   return result;
 }
+
+function scopeReadTerm(term) {
+  // A term read from a stream has its own variable set (ISO 7.10.3).  Parser
+  // variable names cannot be used as environment identities here: a caller
+  // such as read(X) and an input term X=a would otherwise share the same `X`
+  // and incorrectly attempt the cyclic unification X=(X=a).  Use an internal
+  // name containing NUL, which cannot occur in Prolog source, while retaining
+  // the spelling and occurrence count required by read_term/3 metadata.
+  const scope = ++isoFresh;
+  const bySourceName = new Map();
+  const variables = [];
+
+  const copy = (item) => {
+    if (item.type === VAR) {
+      let record = bySourceName.get(item.name);
+      if (record == null) {
+        const scoped = variable(`\u0000read:${scope}:${variables.length}`);
+        scoped.displayName = item.name;
+        record = {
+          sourceName: item.name,
+          term: scoped,
+          count: 0,
+          anonymous: item.name.startsWith('__anon'),
+        };
+        bySourceName.set(item.name, record);
+        variables.push(record);
+      }
+      record.count++;
+      return record.term;
+    }
+    if (item.type !== COMPOUND) return item;
+    return compound(item.name, item.args.map(copy));
+  };
+
+  return { term: copy(term), variables };
+}
+
 function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
@@ -1164,7 +1201,7 @@ function readTermFromStream(stream, solver) {
         });
         if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
         stream.position = candidate.end;
-        return clauses[0].head;
+        return scopeReadTerm(clauses[0].head);
       } catch (_) {
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.
@@ -1192,7 +1229,7 @@ function readTermFromStream(stream, solver) {
     stream.position = source.length;
     if (!sawCandidate) {
       if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
-      return atom('end_of_file');
+      return { term: atom('end_of_file'), variables: [] };
     }
     throw new PrologError('syntax_error(read_term)');
   }
@@ -1202,39 +1239,31 @@ function* readBuiltin({ solver, goal, env }) {
   const stream = inputStreamFor(solver, goal, env);
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
   const next = env.clone();
-  if (unify(goal.args[goal.arity - 1], readTermFromStream(stream, solver), next)) yield next;
+  const { term } = readTermFromStream(stream, solver);
+  if (unify(goal.args[goal.arity - 1], term, next)) yield next;
 }
 function* readTermBuiltin({ solver, goal, env }) {
   const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
   const options = optionList(goal.args[goal.arity - 1], env);
   const target = goal.args[goal.arity - 2];
-  const term = readTermFromStream(stream, solver);
+  const { term, variables } = readTermFromStream(stream, solver);
   const next = env.clone();
   if (!unify(target, term, next)) return;
-  const variables = [];
-  const counts = new Map();
-  const visit = (item) => {
-    if (item.type === VAR) {
-      counts.set(item.name, (counts.get(item.name) ?? 0) + 1);
-      if (!variables.some((entry) => entry.name === item.name)) variables.push(item);
-    } else for (const arg of item.args) visit(arg);
-  };
-  visit(term);
   for (const option of options) {
     if (option.type === VAR) throw new PrologError('instantiation_error');
     if (option.type !== COMPOUND || option.arity !== 1) throw new PrologError('domain_error(read_option)', option);
     let value;
     if (option.name === 'variables') {
-      value = listFromItems(variables);
+      value = listFromItems(variables.map((item) => item.term));
     } else if (option.name === 'variable_names') {
       value = listFromItems(variables
-        .filter((item) => !item.name.startsWith('__anon'))
-        .map((item) => compound('=', [atom(item.name), item])));
+        .filter((item) => !item.anonymous)
+        .map((item) => compound('=', [atom(item.sourceName), item.term])));
     } else if (option.name === 'singletons') {
       value = listFromItems(variables
-        .filter((item) => !item.name.startsWith('__anon') && counts.get(item.name) === 1)
-        .map((item) => compound('=', [atom(item.name), item])));
+        .filter((item) => !item.anonymous && item.count === 1)
+        .map((item) => compound('=', [atom(item.sourceName), item.term])));
     } else {
       throw new PrologError('domain_error(read_option)', option);
     }

package/src/platform.js

@@ -15,6 +15,8 @@ if (isNode) {
   BufferCtor = globalThis.Buffer ?? null;
 }
 
+const configuredOldSpaceLimit = configuredOldSpaceBytes();
+
 export { fs, path, BufferCtor, isNode };
 
 export function currentWorkingDirectory() {
@@ -23,6 +25,17 @@ export function currentWorkingDirectory() {
 
 export function usedHeapSize() {
   if (isNode && typeof process.memoryUsage === 'function') {
+    // --max-old-space-size constrains V8's old generation, not the complete
+    // heap reported by process.memoryUsage().heapUsed. Comparing that limit
+    // with total heap use makes bursts of collectible new-space objects look
+    // like retained memory. Measure the corresponding non-young spaces when
+    // an old-space limit was supplied.
+    if (configuredOldSpaceLimit != null && typeof v8?.getHeapSpaceStatistics === 'function') {
+      const spaces = v8.getHeapSpaceStatistics();
+      return spaces
+        .filter(({ space_name: name }) => name !== 'read_only_space' && !name.startsWith('new_'))
+        .reduce((total, { space_used_size: size }) => total + size, 0);
+    }
     return process.memoryUsage().heapUsed;
   }
   const memory = globalThis.performance?.memory;
@@ -33,8 +46,7 @@ export function softHeapLimit() {
   let limit = null;
   if (isNode) {
     limit = v8?.getHeapStatistics?.().heap_size_limit ?? null;
-    const configuredOldSpace = configuredOldSpaceBytes();
-    if (configuredOldSpace != null) limit = Math.min(limit ?? Infinity, configuredOldSpace);
+    if (configuredOldSpaceLimit != null) limit = Math.min(limit ?? Infinity, configuredOldSpaceLimit);
   } else {
     const memory = globalThis.performance?.memory;
     if (Number.isFinite(memory?.jsHeapSizeLimit)) limit = memory.jsHeapSizeLimit;

package/src/term.js

@@ -413,9 +413,26 @@ function writeList(term, env, options) {
 }
 
 export function termToString(term, env = new Env(), quoteStrings = true, options = {}) {
-  options = { doubleQuotes: options.doubleQuotes ?? 'chars' };
+  options = {
+    ...options,
+    doubleQuotes: options.doubleQuotes ?? 'chars',
+    readVariableNames: options.readVariableNames instanceof Map ? options.readVariableNames : new Map(),
+    usedReadVariableNames: options.usedReadVariableNames instanceof Set ? options.usedReadVariableNames : new Set(),
+  };
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return writeVariable(resolved.name);
+  if (resolved.type === VAR) {
+    if (resolved.displayName == null) return writeVariable(resolved.name);
+    let printed = options.readVariableNames.get(resolved.name);
+    if (printed == null) {
+      const base = writeVariable(resolved.displayName);
+      printed = base;
+      let suffix = 1;
+      while (options.usedReadVariableNames.has(printed)) printed = `${base}_${suffix++}`;
+      options.readVariableNames.set(resolved.name, printed);
+      options.usedReadVariableNames.add(printed);
+    }
+    return printed;
+  }
   if (isCons(resolved)) return writeList(resolved, env, options);
   if (resolved.type === STRING) return writeString(resolved.name, quoteStrings);
   if (resolved.type === ATOM) return writeAtom(resolved.name);

package/src/write.js

@@ -134,9 +134,42 @@ function chooseOperator(term, table) {
   return null;
 }
 
+function printableReadVariableNames(term, env, explicit) {
+  const names = new Map(explicit);
+  const used = new Set(names.values());
+  const suffixes = new Map();
+  const seenVariables = new Set();
+  const seenTerms = new Set();
+  const stack = [term];
+
+  while (stack.length) {
+    const current = deref(stack.pop(), env);
+    if (current.type === VAR) {
+      if (seenVariables.has(current.name)) continue;
+      seenVariables.add(current.name);
+      if (names.has(current.name) || current.displayName == null) continue;
+      const base = writeVariable(current.displayName);
+      let candidate = base;
+      let suffix = suffixes.get(base) ?? 1;
+      while (used.has(candidate)) candidate = `${base}_${suffix++}`;
+      suffixes.set(base, suffix);
+      names.set(current.name, candidate);
+      used.add(candidate);
+      continue;
+    }
+    if (current.type !== COMPOUND || seenTerms.has(current)) continue;
+    seenTerms.add(current);
+    for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
+  }
+
+  return names;
+}
+
 function format(term, env, options, table, maxPriority = 1200, context = 'term') {
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return options.variableNames.get(resolved.name) ?? writeVariable(resolved.name);
+  if (resolved.type === VAR) {
+    return options.variableNames.get(resolved.name) ?? writeVariable(resolved.displayName ?? resolved.name);
+  }
   if (resolved.type === STRING) return writeString(resolved.name);
   if (resolved.type === ATOM) {
     if (!options.quoted) return resolved.name;
@@ -224,12 +257,13 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
 }
 
 export function formatTermForWrite(term, env = new Env(), options = {}) {
+  const explicitVariableNames = options.variableNames instanceof Map ? options.variableNames : new Map();
   const normalized = {
     quoted: options.quoted === true,
     ignoreOps: options.ignoreOps === true,
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
-    variableNames: options.variableNames instanceof Map ? options.variableNames : new Map(),
+    variableNames: printableReadVariableNames(term, env, explicitVariableNames),
     compact: options.compact === true,
     operatorAtomsAsArgs: options.operatorAtomsAsArgs === true,
   };

package/test/run-regression.mjs

@@ -1284,6 +1284,35 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'read terms have a variable scope distinct from the calling query',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'read(X).\n' +
+            'X=a.\n' +
+            'read(X).\n' +
+            'Y=a.\n' +
+            'read_term(X, [variables(Vs), variable_names(Names), singletons(Singletons)]).\n' +
+            'X = pair(X, Y).\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-   |:  X = (_A = a).\n' +
+          '?-   |:  X = (_A = a).\n' +
+          "?-   |:  X = (_A = pair(_A, _B)), Vs = [_A, _B], Names = ['X' = _A, 'Y' = _B], Singletons = ['Y' = _B].\n" +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+
+        const distinctReads = run(
+          'check :- read(A), read(B), A \\== B, write_canonical(pair(A, B)), nl.\n',
+          { goal: 'check', ioOptions: { input: 'V.\nV.\n' } },
+        );
+        assertEqual(distinctReads.stdout, 'pair(V,V_1)\ncheck.\n', 'separate read variable sets');
+      },
+    },
     {
       name: 'REPL term input is on demand in conjunctions and Ctrl-D does not exit the top level',
       run: () => {
@@ -2557,6 +2586,42 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(result.stdout, '300000', 'fresh-variable answer count');
       },
     },
+    {
+      name: 'caught number syntax errors do not exhaust memory on distinct inputs',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = `
+          :- use_module(library(lists)).
+          alphabet(['0','1','2','3','4','5','6','7','8','9','.']).
+          trial([A,B,C,D,E]) :-
+            alphabet(Chars),
+            member(A, Chars), member(B, Chars), member(C, Chars),
+            member(D, Chars), member(E, Chars),
+            catch(number_chars(_, [A,B,C,D,E]), error(syntax_error(number), _), true).
+        `;
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)});
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const goal = parseGoalText('trial(Chars)');
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 150000) break;
+          }
+          if (count !== 150000) throw new Error('unexpected answer count: ' + count);
+          process.stdout.write(String(count));
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=64',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, '150000', 'distinct number syntax attempts');
+      },
+    },
     {
       name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {