eyeprolog 1.2.34 → 1.2.36

package/package.json

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

package/src/iso.js

@@ -9,7 +9,9 @@ import { sameNumberValue } from './number-value.js';
 import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
-import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
+import {
+  characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
+} from './syntax-scan.js';
 
 let isoFresh = 0;
 
@@ -1072,20 +1074,6 @@ function* nlBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function isTerminatingFullStop(source, index) {
-  const previous = source[index - 1] ?? '';
-  const next = source[index + 1] ?? '';
-  if (previous === '.' || next === '.') return false;
-  if (/\d/.test(previous) && /\d/.test(next)) return false;
-  if (/[A-Za-z0-9_]/.test(previous) && /[A-Za-z0-9_]/.test(next)) return false;
-  return true;
-}
-
-const termGraphicCharacters = new Set('#$&*+-./<=>?@^~\\:');
-function continuesGraphicToken(source, index) {
-  return index > 0 && termGraphicCharacters.has(source[index - 1]);
-}
-
 function* termTextCandidates(stream) {
   const source = String(stream.content);
   let quote = null, lineComment = false, blockComment = false;
@@ -2029,35 +2017,39 @@ function* negationBuiltin({ solver, goal, env }) {
   for (const _ of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) return;
   yield env;
 }
+function* solveControlBranch(solver, goal, env) {
+  for (const answer of solver.solve([callable(goal, env)], env, 0)) {
+    // A branch answer is internal to its enclosing control construct. The
+    // surrounding solve will count the completed control goal after the
+    // builtin yields it. Leaving both counts in place makes a bounded search
+    // such as once/1 or negation stop before it can observe the branch answer.
+    if (solver.solutionsSeen > 0) solver.solutionsSeen--;
+    yield answer;
+  }
+}
 function* disjunctionBuiltin({ solver, goal, env }) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
     for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(left.args[0], env)], env.clone(), 0)) {
-      yield* solver.solve([callable(left.args[1], conditionEnv)], conditionEnv, 0);
+      yield* solveControlBranch(solver, left.args[1], conditionEnv);
       return;
     }
-    yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+    yield* solveControlBranch(solver, goal.args[1], env.clone());
     return;
   }
   const marker = solver.active[solver.active.length - 1] ?? null;
   const markerCutEpoch = marker?.cutEpoch ?? 0;
   const solverCutEpoch = solver.cutEpoch;
-  yield* solver.solve([callable(goal.args[0], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[0], env.clone());
   const cutThisScope = marker == null
     ? solver.cutEpoch !== solverCutEpoch
     : (marker.cutEpoch ?? 0) !== markerCutEpoch;
   if (cutThisScope) return;
-  yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
+  yield* solveControlBranch(solver, goal.args[1], env.clone());
 }
 function* ifThenBuiltin({ solver, goal, env }) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
-    for (const consequentEnv of solver.solve([callable(goal.args[1], conditionEnv)], conditionEnv, 0)) {
-      // The consequent is an internal part of the current solution, not a
-      // completed top-level solution. Keep a surrounding bounded search (for
-      // example nested ISO once-as-if-then) from consuming its limit early.
-      if (solver.solutionsSeen > 0) solver.solutionsSeen--;
-      yield consequentEnv;
-    }
+    yield* solveControlBranch(solver, goal.args[1], conditionEnv);
     return;
   }
 }

package/src/parser.js

@@ -1,6 +1,7 @@
 // Tokenizer and recursive-descent parser for the EyeProlog source language.
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
+import { isTerminatingFullStop } from './syntax-scan.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -369,12 +370,11 @@ class Parser {
       this.pos += 2;
       return { type: TOK.ATOM, text: '?-', line };
     }
-    if (ch === '.' && this.peek(1) &&
-        !isWhitespaceCode(this.peek(1).charCodeAt(0)) &&
-        this.peek(1) !== '%' && !(this.peek(1) === '/' && this.peek(2) === '*')) {
+    if (ch === '.' && !isTerminatingFullStop(this.source, this.pos)) {
       const start = this.pos;
       this.take();
-      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
+             !isTerminatingFullStop(this.source, this.pos)) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
     if (ch === '!') {
@@ -543,7 +543,8 @@ class Parser {
     if (isGraphicAtomCode(ch.charCodeAt(0))) {
       const start = this.pos;
       this.take();
-      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
+             !isTerminatingFullStop(this.source, this.pos)) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
 

package/src/repl.js

@@ -4,7 +4,9 @@ import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { formalErrorTerm } from './iso.js';
-import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
+import {
+  characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
+} from './syntax-scan.js';
 
 const ANSWER_HELP = `
 SPACE, "n" or ";": next solution, if any
@@ -389,7 +391,7 @@ function terminalFullStop(source) {
       lineComment = true;
       continue;
     }
-    if (ch === '/' && next === '*') {
+    if (ch === '/' && next === '*' && !continuesGraphicToken(source, i)) {
       blockComment = true;
       i++;
       continue;
@@ -400,7 +402,8 @@ function terminalFullStop(source) {
     }
     if ('([{'.includes(ch)) depth++;
     else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
-    else if (ch === '.' && depth === 0 && onlyLayoutAndComments(source.slice(i + 1))) return i;
+    else if (ch === '.' && depth === 0 && isTerminatingFullStop(source, i) &&
+             onlyLayoutAndComments(source.slice(i + 1))) return i;
   }
   return -1;
 }

package/src/syntax-scan.js

@@ -2,6 +2,26 @@
 // readers. These locate token boundaries only; parser.js remains responsible
 // for accepting or rejecting the token itself.
 
+const graphicTokenCharacters = new Set('#$&*+-./<=>?@^~\\:');
+
+export function continuesGraphicToken(source, index) {
+  return index > 0 && graphicTokenCharacters.has(source[index - 1]);
+}
+
+export function isTerminatingFullStop(source, index) {
+  if (source[index] !== '.') return false;
+  const next = source[index + 1] ?? '';
+  // At a line boundary, after a single-line comment marker, or at end of
+  // input, the dot is the read-term end char. Before horizontal layout it is
+  // instead part of an already-started graphic token: `./*. .` is the atom
+  // `./*.` followed by its separate end char. A directly following /* also
+  // stays in the current graphic token; bracketed comments are recognized
+  // only when /* begins a token.
+  if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
+  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return !continuesGraphicToken(source, index);
+  return false;
+}
+
 export function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;

package/test/conformance/cases/iso/streams_and_term_io.pl

@@ -5,7 +5,7 @@ text_roundtrip(Term, Peek, Code, Mode, Alias) :-
     open('/tmp/eyeprolog-iso-text.txt', write, Output, [alias(iso_text_output), type(text)]),
     writeq(iso_text_output, sample(42)),
     put_char(iso_text_output, '.'),
-    put_char(iso_text_output, 'Z'),
+    put_char(iso_text_output, ' '),
     close(Output),
     open('/tmp/eyeprolog-iso-text.txt', read, Input, [alias(iso_text_input), eof_action(eof_code)]),
     stream_property(Input, mode(Mode)),

package/test/conformance/expected/iso/streams_and_term_io.pl

@@ -1,4 +1,4 @@
-text_roundtrip(sample(42), 'Z', 90, read, iso_text_input).
+text_roundtrip(sample(42), ' ', 32, read, iso_text_input).
 binary_roundtrip(65, 65, -1).
 read_term_metadata(ok).
 default_streams(ok).

package/test/conformance/expected-errors/syntax/extra_double_period_rejected.txt

@@ -1 +1 @@
-parse line 1: expected ., got ..
+parse line 1: expected ., got .

package/test/run-regression.mjs

@@ -477,6 +477,32 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 22 run, 22 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'negation observes disjunction through direct and call/1 execution',
+      run: () => {
+        const reported = publicApi.runQuads(String.raw`?- \+ (true ; true).
+   false.
+
+?- call(\+ (true ; true)).
+   false.
+`);
+        assertEqual(reported.total, 2, 'reported query count');
+        assertEqual(reported.passed, 2, 'reported queries pass');
+
+        const program = Program.parse('');
+        const answerCount = (text) => {
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          return [...solver.solve([parseGoalText(text)], new Env(), 0)].length;
+        };
+
+        assertEqual(answerCount(String.raw`\+ (true ; true)`), 0, 'direct successful disjunction is negated');
+        assertEqual(answerCount(String.raw`call(\+ (true ; true))`), 0, 'called negation fails');
+        assertEqual(answerCount(String.raw`\+ (true ; fail)`), 0, 'successful left branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; true)`), 0, 'successful right branch is observed');
+        assertEqual(answerCount(String.raw`\+ (fail ; fail)`), 1, 'failed disjunction is negated');
+        assertEqual(answerCount('once((true ; true))'), 1, 'once keeps the first disjunction answer');
+      },
+    },
     {
       name: 'runQuads passes the complete vendored ISO phrase quad corpus',
       run: () => {
@@ -707,6 +733,43 @@ c4 ?- call((!;1)).
         assertIncludes(upstreamResult.stdout, '46 true.', 'WG17 #367 output');
       },
     },
+    {
+      name: 'readers distinguish graphic tokens, comments, and full stops (issue #41)',
+      run: () => {
+        const parsed = parseProgramText('./*.');
+        assertEqual(parsed.length, 1, 'graphic atom clause count');
+        assertEqual(parsed[0].head.name, './*', 'comment opener stays inside graphic atom');
+
+        const read = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: './*.' },
+        });
+        assertEqual(read.stdout, "read('./*').\n", 'graphic atom writeq readback');
+
+        const consecutive = runEyeProlog('answer(A, B) :- read(A), read(B).\n', {
+          goal: 'answer(A, B)',
+          ioOptions: { input: './*. .\nok.\n' },
+        });
+        assertEqual(consecutive.stdout, "answer('./*.', ok).\n", 'following read starts after the complete term');
+
+        let error = null;
+        try {
+          runEyeProlog('', { goal: 'read(T)', ioOptions: { input: '!.!.' } });
+        } catch (caught) {
+          error = caught;
+        }
+        assertEqual(error?.message, 'error(syntax_error(read_term))', 'solo-token sequence rejection');
+
+        const repl = runCli([], {
+          input: 'read(T).\n./*. .\nread(T).\nok.\nread(T).\n!.!.\nhalt.\n',
+        });
+        assertEqual(repl.status, 0, 'REPL exit status');
+        assertIncludes(repl.stdout, "T = './*.'.", 'REPL dotted graphic atom answer');
+        assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
+        assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
+        assertEqual(repl.stderr, '', 'REPL stderr');
+      },
+    },
     {
       name: 'question mark is a graphic character and writeq keeps graphic atoms unquoted',
       run: () => {
@@ -2755,20 +2818,22 @@ open(X) :- candidate(X), \\+ closed(X).
           const goal = parseGoalText('trial(Chars)');
           let count = 0;
           for (const _ of solver.solve([goal], new Env(), 0)) {
-            if (++count === 500000) break;
+            if (++count === 50000) break;
           }
-          if (count !== 500000) throw new Error('unexpected answer count: ' + count);
+          if (count !== 50000) throw new Error('unexpected answer count: ' + count);
           process.stdout.write(String(count));
         `;
         const result = spawnSync(process.execPath, [
-          '--max-old-space-size=64',
+          // A smaller heap preserves the original false-exhaustion signal
+          // without requiring half a million transient conversion attempts.
+          '--max-old-space-size=32',
           '--input-type=module',
           '--eval',
           script,
-        ], { cwd: packageRoot, encoding: 'utf8', timeout: 45000 });
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
         if (result.error) throw result.error;
         assertEqual(result.status, 0, `bounded-heap child status; stderr=${result.stderr}`);
-        assertEqual(result.stdout, '500000', 'distinct number syntax attempts');
+        assertEqual(result.stdout, '50000', 'distinct number syntax attempts');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -1844,7 +1844,10 @@ normalized at the solver boundary instead of leaking a JavaScript `RangeError`.
 ISO 13211-1 leaves the resource atom implementation dependent. EyeProlog uses
 `memory` for a finite host allocation/capacity ceiling and reserves the
 `finite_memory` spelling for the distinct convention where no finite amount of
-memory could complete the computation.
+memory could complete the computation. After a recoverable memory error, the
+solver keeps a bounded recovery window while the failed search unwinds so the
+host can collect released query terms. The same solver can then run later
+queries; this recovery does not resume the query that exhausted its limit.
 
 The iterative solver keeps active-call frames only where they are semantically
 needed for cut scope or recursive variant guards. Bundled-library helpers whose
@@ -1853,9 +1856,15 @@ guard therefore do not copy a growing active-call sequence at every step.
 Under the normal EyeProlog registry, the bundled Prologue `length/2` also has a
 scoped iterative execution path: named lists are counted or constructed without
 recursive interpreter frames, and an anonymous list is not materialized because
-its binding cannot be observed. The ordinary clauses remain the authoritative
-module definition and are used unchanged by the ISO-only registry and whenever
-delays or finite-domain constraints require their normal wake-up points.
+its binding cannot be observed. A newly constructed fixed-length suffix starts
+as a lazy compact skeleton and expands one ordinary `./2` cell at a time when
+unification, another list predicate, or answer readback inspects it. This is a
+storage optimization, not a distinct Prolog term or list semantics. Embedders
+that inspect the JavaScript term model can recognize this representation with
+`CompactListTerm`, `isCompactList`, and `compactListLength`, or construct one
+with `compactVariableList`. The ordinary clauses remain the authoritative module
+definition and are used unchanged by the ISO-only registry and whenever delays
+or finite-domain constraints require their normal wake-up points.
 
 ### Implementation boundary
 
@@ -5360,9 +5369,16 @@ comment continues to the end of its line. Doubling the active delimiter is
 also accepted inside either quoted form, so `""` inside double-quoted notation
 denotes one literal double quote character.
 
-Graphic atoms may contain `#$&*+-/<=>@^~\;`. A colon is the Part 2 module
-qualification operator in `Module:Goal`; quote an atom whose name itself
-contains a colon. Unquoted angle-bracket IRIs are not syntax.
+Graphic tokens use the characters `#$&*+-./<=>?@^~\`; `!` and `;` are solo
+atoms. A colon is the Part 2 module qualification operator in `Module:Goal`;
+quote an atom whose name itself contains a colon. Unquoted angle-bracket IRIs
+are not syntax.
+
+A `/*` sequence opens a block comment only when it begins a token; inside a
+maximal graphic token the slash and star remain atom characters. A period ends
+a term only when it is recognized as the terminating full stop. Consequently,
+`./*.` at the end of a line reads the atom `./*`, whereas `./*. .` reads the
+atom `./*.` and consumes the second period as the terminator.
 
 In the grammar below, `{ x }` means zero or more repetitions of `x`, `[ x ]`
 means that `x` is optional, and parentheses group alternatives. These marks