eyeprolog 1.3.15 → 1.3.17

package/package.json

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

package/src/repl.js

@@ -366,7 +366,6 @@ function terminalFullStop(source, solver = null) {
   let quote = null;
   let lineComment = false;
   let blockComment = false;
-  let depth = 0;
 
   for (let i = 0; i < source.length; i++) {
     const ch = source[i];
@@ -415,10 +414,12 @@ function terminalFullStop(source, solver = null) {
       quote = ch;
       continue;
     }
-    if ('([{'.includes(ch)) depth++;
-    else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
-    else if (depth === 0 && isTerminatingFullStop(source, i, convert) &&
-             onlyLayoutAndComments(source.slice(i + 1))) return i;
+    // ISO 8.14.1.1 locates the end token lexically before read-term parsing.
+    // An unmatched opening bracket therefore must not make the top level wait
+    // for more input after a terminating full stop; parsing the collected text
+    // is what reports the syntax error (for example `[l.` or `{.`).
+    if (isTerminatingFullStop(source, i, convert) &&
+        onlyLayoutAndComments(source.slice(i + 1))) return i;
   }
   return -1;
 }

package/src/solver.js

@@ -513,6 +513,23 @@ export class Solver {
           break;
         }
 
+        const betweenIterator = bundledBetweenIterator(this, group, goal, env);
+        if (betweenIterator != null) {
+          const firstResult = betweenIterator.next();
+          if (firstResult.done) break;
+          stack.push({
+            kind: 'resumeBuiltin',
+            iterator: betweenIterator,
+            goals: rest,
+            depth: depth + 1,
+            active,
+          });
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         const memberIterator = bundledMemberIterator(this, group, goal, env);
         if (memberIterator != null) {
           const firstResult = memberIterator.next();
@@ -1216,6 +1233,53 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
   }
 }
 
+function bundledBetweenIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true ||
+      group.module !== 'prologue' || group.name !== 'between' || group.arity !== 3 ||
+      group.bundledLibrary !== true || group.clauses.length !== 1) {
+    return null;
+  }
+
+  // The portable Prologue definition is intentionally kept as the semantic
+  // source of between/3. Its recursive helper, however, carries the output
+  // variable through one fresh clause instance per integer. With persistent
+  // environments that builds a growing variable-alias chain, so dereferencing
+  // the generated value in the caller repeatedly revisits all earlier frames.
+  // Enumerate the canonical bundled relation directly while leaving user
+  // definitions and non-EyeProlog registries on the ordinary Prolog path.
+  return bundledBetweenSolutions(solver, goal, env);
+}
+
+function requireBetweenInteger(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type !== NUMBER || !isDecimalInteger(value.name)) {
+    throw new PrologError('type_error(integer)', value);
+  }
+  return BigInt(value.name);
+}
+
+function* bundledBetweenSolutions(solver, goal, env) {
+  const lower = requireBetweenInteger(goal.args[0], env);
+  const upper = requireBetweenInteger(goal.args[1], env);
+  const requested = deref(goal.args[2], env);
+
+  if (requested.type !== VAR) {
+    if (requested.type !== NUMBER || !isDecimalInteger(requested.name)) {
+      throw new PrologError('type_error(integer)', requested);
+    }
+    const value = BigInt(requested.name);
+    if (value >= lower && value <= upper) yield env;
+    return;
+  }
+
+  for (let value = lower; value <= upper; value++) {
+    const next = env.clone();
+    solver.stats.unify_calls++;
+    if (unify(goal.args[2], numberTerm(value), next)) yield next;
+  }
+}
+
 function bundledMemberIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       !['lists', 'prologue'].includes(group.module) || group.name !== 'member' || group.arity !== 2 ||

package/test/run-regression.mjs

@@ -1410,6 +1410,27 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'ok', 'DCG hand-off benchmark result');
       },
     },
+    {
+      name: 'DCG state hand-off reaches the next non-terminal at 8192 cells (issue #49 comment 5347991607)',
+      run: () => {
+        const filename = path.join(tmp, `issue49-small-handoff-${tmpCounter++}.pl`);
+        fs.writeFileSync(filename,
+          ':- set_prolog_flag(occurs_check, true).\na --> ..., epsilon.\nepsilon --> [].\n');
+        const result = runCli([], {
+          input:
+            `[${sourceAtom(filename)}].\n` +
+            'use_module(library(lists)).\n' +
+            '\\+ \\+ (length(L,8192), phrase(a,L)).\n' +
+            'halt.\n',
+          timeout: 3000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `small DCG hand-off status; stderr=${result.stderr}`);
+        assertNotIncludes(result.stdout, 'resource_error', 'small DCG hand-off resource error');
+        assertNotIncludes(result.stdout, 'depth_limit_exceeded', 'small DCG hand-off depth error');
+        assertEqual(result.stderr, '', 'small DCG hand-off stderr');
+      },
+    },
     {
       name: 'Trealla-style DCG hand-off reaches 65536 cells without the solver depth ceiling',
       run: () => {
@@ -1910,6 +1931,19 @@ c4 ?- call((!;1)).
         assertIncludes(result.stdout, '?- repeat, fail.', 'terminal query echo');
       },
     },
+    {
+      name: 'REPL stops at the end token before parsing unmatched brackets (issue #51)',
+      run: () => {
+        const result = runCli([], { input: '[l.\ntrue.\n{.\ntrue.\nhalt.\n' });
+        assertEqual(result.status, 0, 'exit status');
+        assertNotIncludes(result.stdout, '|    ', 'no continuation prompt after malformed end token');
+        assertEqual((result.stdout.match(/\?-    true\./g) ?? []).length, 2,
+          'following lines remain separate top-level queries');
+        assertEqual((result.stdout.match(/parse line 1:/g) ?? []).length, 2,
+          'both malformed bracketed queries report syntax errors');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL accepts multiline period-terminated queries',
       run: () => {
@@ -2398,6 +2432,22 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'between/3 generated values avoid recursive environment chains (issue #52)',
+      run: () => {
+        const goalText = 'between(1, 1024, X), X < 0';
+        const program = Program.parse('', { autoloadGoals: [goalText] });
+        const solver = new Solver(program, { registry: getEyePrologRegistry() });
+        const goal = parseGoalText(goalText, {
+          operatorDefinitions: [...solver.program.operators.values()],
+        });
+        let answers = 0;
+        for (const _env of solver.solve([goal], new Env(), 0)) answers++;
+        assertEqual(answers, 0, 'positive generated values fail X < 0');
+        assertEqual(solver.stats.unify_calls, 1024, 'one output unification per generated integer');
+        assertEqual(solver.stats.max_depth <= 4, true, 'generation stays at bounded solver depth');
+      },
+    },
     {
       name: 'library(lists) length/2 stays relational and call_nth/2 autoloads (issue #28)',
       run: () => {