eyeprolog 1.2.9 → 1.2.11

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 167 | 216 | 0 | 0 | 383 |
+| iso | 167 | 218 | 0 | 0 | 385 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **482** | **267** | **19** | **21** | **789** |
+| **Total** | **482** | **269** | **19** | **21** | **791** |

package/package.json

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

package/src/explain.js

@@ -101,8 +101,9 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active) {
     for (let candidateIndex = 0; candidateIndex < clauseCandidateLength(pass); candidateIndex++) {
       const clause = clauseCandidateAt(pass, candidateIndex);
       const id = nextFreshId();
-      const freshHead = freshTerm(clause.head, id);
-      const freshBody = clause.body.map((term) => freshTerm(term, id));
+      const freshVariables = new Map();
+      const freshHead = freshTerm(clause.head, id, freshVariables);
+      const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
       const next = env.clone();
       if (!unify(goal, freshHead, next)) continue;
 

package/src/iso.js

@@ -1564,6 +1564,13 @@ function parseIsoNumber(text) {
   }
 
   const numericText = `${sign}${text.slice(position)}`;
+  // 8.16.7/8.16.8 parse the character sequence according to the syntax rules
+  // for numbers and negative numbers (6.3.1.1/6.3.1.2), not as an arbitrary
+  // term whose value happens to be numeric. Every such number starts with a
+  // decimal digit after an optional negative sign, so parenthesized terms such
+  // as `(0)` or `-(0)` must be rejected before the general term parser sees
+  // them. This keeps the parser reuse below from admitting grouping syntax.
+  if (!/^-?\d/.test(numericText)) return null;
   // ISO floating-point syntax requires a decimal fraction before an exponent.
   if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
   try {

package/src/parser.js

@@ -165,6 +165,7 @@ class Parser {
     this.pos = 0;
     this.line = 1;
     this.anonymous = 0;
+    this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
     this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
@@ -633,7 +634,12 @@ class Parser {
       const name = this.token.text;
       this.advance();
       if (name === '_') return variable(`__anon${this.anonymous++}`);
-      return variable(name);
+      let term = this.variables.get(name);
+      if (term == null) {
+        term = variable(name);
+        this.variables.set(name, term);
+      }
+      return term;
     }
     if (this.token.type === TOK.STRING) {
       const value = this.token.text;

package/src/solver.js

@@ -398,6 +398,8 @@ export class Solver {
         break;
       }
       }
+    } catch (error) {
+      throw normalizeHostResourceError(error);
     } finally {
       const stackIndex = this.solveStacks.indexOf(registeredStack);
       if (stackIndex >= 0) this.solveStacks.splice(stackIndex, 1);
@@ -450,8 +452,9 @@ export class Solver {
         }
         if (headCannotMatch(goal, clause.head, env)) continue;
         const id = nextFreshId();
-        const freshHead = freshTerm(clause.head, id);
-        const freshBody = clause.body.map((term) => freshTerm(term, id));
+        const freshVariables = new Map();
+        const freshHead = freshTerm(clause.head, id, freshVariables);
+        const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
         const next = env.clone();
         this.stats.unify_calls++;
         if (!unify(goal, freshHead, next)) continue;
@@ -482,6 +485,19 @@ export class Solver {
 
 }
 
+function normalizeHostResourceError(error) {
+  if (error?.name !== 'RangeError') return error;
+  const message = String(error?.message ?? '');
+  // V8 reports exhausted Map/Set capacity as a host RangeError.  ISO 7.12.2 h
+  // requires processor resource exhaustion to surface as resource_error/1,
+  // with the resource atom implementation dependent.  EyeProlog uses the
+  // finite_memory spelling already accepted by its ISO conformance corpus.
+  if (/^(?:Map|Set) maximum size exceeded$/.test(message)) {
+    return new PrologError('resource_error(finite_memory)');
+  }
+  return error;
+}
+
 function qualifyMetaArguments(goal, group) {
   const callerModule = goal.module ?? 'user';
   for (const index of group.metaArgumentPositions ?? []) {
@@ -601,8 +617,9 @@ function pushUserGoalUncachedFrames(stack, solver, group, goal, rest, env, depth
       }
       if (headCannotMatch(goal, clause.head, env)) continue;
       const id = nextFreshId();
-      const freshHead = freshTerm(clause.head, id);
-      const freshBody = clause.body.map((term) => freshTerm(term, id));
+      const freshVariables = new Map();
+      const freshHead = freshTerm(clause.head, id, freshVariables);
+      const freshBody = clause.body.map((term) => freshTerm(term, id, freshVariables));
       const next = env.clone();
       solver.stats.unify_calls++;
       if (!unify(goal, freshHead, next)) continue;
@@ -1233,7 +1250,7 @@ function copyResolvedWithKey(term, env, variables) {
       id = variables.size;
       variables.set(value.name, id);
     }
-    return { term: termModuleCache.variable(value.name), key: `var:${id}` };
+    return { term: termModuleCache.variable(value.name, value.order), key: `var:${id}` };
   }
   if (!value.args?.length) {
     return {

package/src/term.js

@@ -6,8 +6,10 @@ export const STRING = 'string';
 export const NUMBER = 'number';
 export const COMPOUND = 'compound';
 const EMPTY_ARGS = Object.freeze([]);
+// Variable term order is carried by the variable objects themselves.  Do not
+// retain a process-global name registry: runtime clause freshening can create
+// an unbounded sequence of names in an otherwise constant-space computation.
 let variableOrder = 0;
-const variableOrders = new Map();
 
 export class Term {
   constructor(type, name, args = []) {
@@ -20,10 +22,9 @@ export class Term {
   }
 }
 
-export const variable = (name) => {
+export const variable = (name, order = null) => {
   const term = new Term(VAR, name, EMPTY_ARGS);
-  if (!variableOrders.has(term.name)) variableOrders.set(term.name, ++variableOrder);
-  term.order = variableOrders.get(term.name);
+  term.order = order ?? ++variableOrder;
   return term;
 };
 export const atom = (name) => new Term(ATOM, name, EMPTY_ARGS);
@@ -270,6 +271,7 @@ export function unify(left, right, env, options = {}) {
 }
 
 export function cloneTerm(term) {
+  if (term.type === VAR) return variable(term.name, term.order);
   const cloned = term.type === COMPOUND && term.arity === 0
     ? atom(term.name)
     : new Term(term.type, term.name, term.args.map(cloneTerm));
@@ -277,18 +279,25 @@ export function cloneTerm(term) {
   return cloned;
 }
 
-export function freshTerm(term, suffix) {
-  if (term.type === VAR) return variable(`${term.name}#${suffix}`);
+export function freshTerm(term, suffix, variables = new Map()) {
+  if (term.type === VAR) {
+    let fresh = variables.get(term.name);
+    if (fresh == null) {
+      fresh = variable(`${term.name}#${suffix}`);
+      variables.set(term.name, fresh);
+    }
+    return fresh;
+  }
   const fresh = term.type === COMPOUND && term.arity === 0
     ? atom(term.name)
-    : new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix)));
+    : new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix, variables)));
   if (term.module != null) fresh.module = term.module;
   return fresh;
 }
 
 export function copyResolved(term, env) {
   const resolved = deref(term, env);
-  if (resolved.type === VAR) return variable(resolved.name);
+  if (resolved.type === VAR) return variable(resolved.name, resolved.order);
   const copied = resolved.type === COMPOUND && resolved.arity === 0
     ? atom(resolved.name)
     : new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
@@ -517,9 +526,13 @@ export function compareTerms(left, right) {
     return compareNumberText(left.name, right.name);
   }
   if (left.type === VAR) {
+    if (left.name === right.name) return 0;
     const leftOrder = left.order ?? 0;
     const rightOrder = right.order ?? 0;
-    return leftOrder < rightOrder ? -1 : leftOrder > rightOrder ? 1 : 0;
+    if (leftOrder !== rightOrder) return leftOrder < rightOrder ? -1 : 1;
+    // Explicitly copied order values are permitted internally; keep the
+    // implementation-defined variable order total even in that case.
+    return left.name < right.name ? -1 : 1;
   }
   if (left.type === ATOM || left.type === STRING) return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
   if (left.arity !== right.arity) return left.arity < right.arity ? -1 : 1;

package/test/conformance/ISO-MATRIX.md

@@ -16,7 +16,7 @@ compliance audit and the remaining work before a full conformance claim.
 | 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses` |
 | 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases |
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin` |
-| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, Logtalk-derived error cases |
+| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived error cases |
 | 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
 | ISO/IEC 13211-2 modules | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |

package/test/conformance/README.md

@@ -102,7 +102,7 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 383 cases in `iso/` and 789 file-based conformance cases in
+The corpus has 385 cases in `iso/` and 791 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

package/test/conformance/errors/iso/number_chars_parenthesized.pl

@@ -0,0 +1,2 @@
+%% goal: number_chars(_, ['(', '0', ')'])
+answer :- number_chars(_, ['(', '0', ')']).

package/test/conformance/errors/iso/number_codes_parenthesized.pl

@@ -0,0 +1,2 @@
+%% goal: number_codes(_, [40, 48, 41])
+answer :- number_codes(_, [40, 48, 41]).

package/test/conformance/expected-errors/iso/number_chars_parenthesized.txt

@@ -0,0 +1 @@
+error(syntax_error(number))

package/test/conformance/expected-errors/iso/number_codes_parenthesized.txt

@@ -0,0 +1 @@
+error(syntax_error(number))

package/test/fixtures/number_chars_cont_quad.pl

@@ -36,6 +36,9 @@
 70 ?- number_chars(N,"0x11").
       N=17.
 
+73 ?- number_chars(N,"(0)").
+      syntax_error(...).
+
 4  ?- number_chars(1,"a").
       syntax_error(...).
 

package/test/run-regression.mjs

@@ -396,9 +396,24 @@ c4 ?- call((!;1)).
           text: source,
           filename,
         }]));
-        assertEqual(result.total, 72, 'quad total');
-        assertEqual(result.passed, 72, 'quad passed');
-        assertEqual(result.stdout, 'quads: 72 run, 72 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 73, 'quad total');
+        assertEqual(result.passed, 73, 'quad passed');
+        assertEqual(result.stdout, 'quads: 73 run, 73 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'number conversion rejects parenthesized numeric terms',
+      run: () => {
+        for (const goal of ['number_chars(N,"(0)")', 'number_codes(N,[40,48,41])']) {
+          let caught = null;
+          try {
+            publicApi.run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          if (caught == null) throw new Error(`${goal} should throw`);
+          assertIncludes(String(caught?.message ?? caught), 'syntax_error(number)', goal);
+        }
       },
     },
     {
@@ -2078,6 +2093,53 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(answers.join('\n'), 'p(a)', 'answer beyond former default ceiling');
       },
     },
+    {
+      name: 'fresh-variable generation stays bounded under a small host heap',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = 'p(X) :- repeat, q(X).\nq(_).\n';
+        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('p(X)');
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 300000) break;
+          }
+          if (count !== 300000) throw new Error('unexpected answer count: ' + count);
+          process.stdout.write(String(count));
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=32',
+          '--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, '300000', 'fresh-variable answer count');
+      },
+    },
+    {
+      name: 'host Map capacity errors become ISO resource errors',
+      run: () => {
+        const registry = new BuiltinRegistry();
+        registry.add('exhaust_map', 0, function* () {
+          throw new RangeError('Map maximum size exceeded');
+        });
+        const solver = new Solver(Program.parse(''), { registry });
+        const goal = parseGoalText('exhaust_map');
+        let caught = null;
+        try {
+          [...solver.solve([goal], new Env(), 0)];
+        } catch (error) {
+          caught = error;
+        }
+        assertEqual(caught?.name, 'PrologError', 'normalized error type');
+        assertEqual(caught?.formal, 'resource_error(finite_memory)', 'normalized resource error');
+      },
+    },
     {
       name: 'solver honors solution limits',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1811,7 +1811,10 @@ child searches that inherit the solver limit do not stop after a fixed number of
 solutions. This matters for re-executable goals such as `repeat/0` and for
 library relations such as `call_nth/2`; an implementation safety threshold must
 not turn a still re-executable search into logical failure. Embedders that need
-a finite answer budget should pass `solutionLimit` explicitly.
+a finite answer budget should pass `solutionLimit` explicitly. Host capacity
+failures that V8 reports as `Map maximum size exceeded` or `Set maximum size
+exceeded` are normalized at the solver boundary to the ISO error
+`resource_error(finite_memory)` instead of leaking a JavaScript `RangeError`.
 
 ### Implementation boundary
 
@@ -5611,8 +5614,16 @@ nonterminals.
 For ISO terms, the standard term order is variables, numbers, atoms, then compounds;
 compound terms compare by arity, functor, and arguments. Within the numeric
 category, floats precede integers; floats compare by finite numeric value and
-integers compare exactly. Double-quoted Prolog source follows the
-`double_quotes` flag and never creates an extra host-only scalar category.
+integers compare exactly. ISO leaves the ordering of two distinct variables
+implementation dependent, subject to stability while a sorted list is being
+created. EyeProlog assigns a creation ordinal to each logical variable and
+carries that ordinal on the variable term itself; repeated occurrences share it
+within parsing or clause-freshening scope. It therefore does not keep a
+process-global table of every fresh variable name ever created, so long-running
+generators can create and discard fresh variables without growing an unrelated
+host `Map`. Double-quoted Prolog source
+follows the `double_quotes` flag and never creates an extra host-only scalar
+category.
 
 ### Term construction and inspection
 
@@ -5724,13 +5735,16 @@ quoted_atom("ab").           % quoted_atom(ab)
 | `sub_atom(+Atom,?Before,?Length,?After,?SubAtom)` | Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers. |
 | `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or Unicode scalar codes. At least one side must be instantiated. |
 | `char_code(?Character,?Code)` | Converts one character atom and one Unicode scalar code. Surrogates and values outside `0..0x10ffff` raise a representation error. |
-| `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO numeric-token syntax, including radix integers, character-code constants, and leading layout. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
+| `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
 
 Conversions accept partial output lists when the atomic input is known, but
 constructing an atom or number requires a complete proper list with no unbound
 elements. Numeric parsing accepts leading ISO layout characters, an optional
 sign, decimal fractions, and decimal exponents; it rejects trailing material
-and non-finite values.
+and non-finite values. The regression gate vendors all 73 numbered cases from
+Ulrich Neumerkel's contemporary `number_chars/2` comparison, including the
+Cor.2 error-precedence cases; `number_codes/2` shares the same numeric parser
+and has mirrored coverage for the parenthesized-number regression.
 
 ### Streams and unit I/O
 
@@ -6975,7 +6989,7 @@ precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 789 cases, including 383 focused ISO
+contains 791 cases, including 385 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal