eyeprolog 1.2.38 → 1.2.40

package/package.json

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

package/src/iso.js

@@ -1076,6 +1076,7 @@ function* nlBuiltin({ solver, goal, env }) {
 
 function* termTextCandidates(stream) {
   const source = String(stream.content);
+  const lastBufferedNonLayout = lastNonLayoutIndex(source, stream.position);
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
@@ -1106,14 +1107,29 @@ function* termTextCandidates(stream) {
     }
     if (ch === "'" || ch === '"') { quote = ch; continue; }
     if (ch === '.' && isTerminatingFullStop(source, i)) {
+      // A buffered stream exposes what follows the layout after this dot.  If
+      // the dot continues a graphic token and later non-layout input exists,
+      // it is part of that maximal token rather than an early end char.  The
+      // interactive reader makes the corresponding decision incrementally.
+      if (continuesGraphicToken(source, i) && lastBufferedNonLayout > i) continue;
       yield { text: source.slice(stream.position, i + 1), end: i + 1 };
     }
   }
 }
 function hasNonLayoutRemainder(source, start) {
-  return source.slice(start)
-    .replace(/[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g, '')
-    .length > 0;
+  return lastNonLayoutIndex(source, start) >= start;
+}
+function lastNonLayoutIndex(source, start = 0) {
+  const ignored = /[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g;
+  ignored.lastIndex = start;
+  let cursor = start;
+  let last = -1;
+  for (let match = ignored.exec(source); match != null; match = ignored.exec(source)) {
+    if (match.index > cursor) last = match.index - 1;
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < source.length) last = source.length - 1;
+  return last;
 }
 function convertedTermText(text, solver) {
   if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) return text;
@@ -1178,6 +1194,31 @@ function scopeReadTerm(term) {
   return { term: copy(term), variables };
 }
 
+function parseReadTermText(text, solver) {
+  const converted = convertedTermText(text, solver);
+  const operatorState = createParserOperatorState(solver.program.operators.values(), false);
+  const clauses = parseClauses(converted, {
+    sourceMetadata: false,
+    operatorState,
+    isoStrict: solver.isoStrict,
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    // The stream scanner supplies one candidate ending at this full stop.
+    // Earlier ambiguous dots must remain available to maximal graphic tokens.
+    readTermEnd: converted.length - 1,
+  });
+  if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+  return clauses[0].head;
+}
+
+export function isCompleteReadTermText(text, solver) {
+  try {
+    parseReadTermText(text, solver);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
 function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
@@ -1189,16 +1230,9 @@ function readTermFromStream(stream, solver) {
         throw new PrologError('syntax_error(read_term)');
       }
       try {
-        const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-        const clauses = parseClauses(convertedTermText(candidate.text, solver), {
-          sourceMetadata: false,
-          operatorState,
-          isoStrict: solver.isoStrict,
-          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-        });
-        if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+        const term = parseReadTermText(candidate.text, solver);
         stream.position = candidate.end;
-        return scopeReadTerm(clauses[0].head);
+        return scopeReadTerm(term);
       } catch (_) {
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.

package/src/parser.js

@@ -1,7 +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';
+import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -196,9 +196,25 @@ class Parser {
     this.infixOperators = operatorState.infixOperators;
     this.prefixOperators = operatorState.prefixOperators;
     this.postfixOperators = operatorState.postfixOperators;
+    this.readTermEnd = Number.isInteger(options.readTermEnd) ? options.readTermEnd : null;
     this.previousToken = null;
     this.token = this.nextToken();
   }
+  terminatingFullStop(index = this.pos) {
+    // read/1 tries each possible full stop in turn.  While parsing a later
+    // candidate, a preceding dot after a graphic character belongs to that
+    // maximal graphic token; the candidate's final dot is the end char.  Keep
+    // ordinary program parsing context-free by enabling this only for a
+    // designated read-term candidate.
+    if (this.readTermEnd != null) {
+      if (index === this.readTermEnd) return true;
+      if (index < this.readTermEnd && continuesGraphicToken(this.source, index)) {
+        const next = this.source[index + 1] ?? '';
+        if (next === '%' || /^[\u0009-\u000d\u0020]$/.test(next)) return false;
+      }
+    }
+    return isTerminatingFullStop(this.source, index);
+  }
   defineOperator(priority, specifier, name) {
     defineParserOperator(this, priority, specifier, name);
   }
@@ -366,15 +382,16 @@ class Parser {
       this.pos += 3;
       return { type: TOK.ATOM, text: '...', line };
     }
-    if (ch === '?' && this.peek(1) === '-') {
+    if (ch === '?' && this.peek(1) === '-' &&
+        !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;
       return { type: TOK.ATOM, text: '?-', line };
     }
-    if (ch === '.' && !isTerminatingFullStop(this.source, this.pos)) {
+    if (ch === '.' && !this.terminatingFullStop()) {
       const start = this.pos;
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
-             !isTerminatingFullStop(this.source, this.pos)) this.take();
+             !this.terminatingFullStop()) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
     if (ch === '!') {
@@ -394,11 +411,13 @@ class Parser {
       this.take();
       return { type: punct[ch], text: ch, line, precededByLayout };
     }
-    if (ch === ':' && this.peek(1) === '-') {
+    if (ch === ':' && this.peek(1) === '-' &&
+        !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;
       return { type: TOK.IF, text: ':-', line };
     }
-    if (ch === ':') {
+    if (ch === ':' &&
+        !(isGraphicAtomCode(this.peek(1).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 1))) {
       this.take();
       return { type: TOK.ATOM, text: ':', line };
     }
@@ -544,7 +563,7 @@ class Parser {
       const start = this.pos;
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
-             !isTerminatingFullStop(this.source, this.pos)) this.take();
+             !this.terminatingFullStop()) this.take();
       return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
     }
 
@@ -1034,7 +1053,7 @@ export function parseClauses(source, options = {}) {
   const parserOptions = ownsParserFlagState
     ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes } }
     : options;
-  if (options.sourceMetadata === false) {
+  if (options.sourceMetadata === false && options.readTermEnd == null) {
     const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
     if (ownsParserFlagState) parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;

package/src/repl.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
-import { formalErrorTerm } from './iso.js';
+import { formalErrorTerm, isCompleteReadTermText } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -162,7 +162,7 @@ class LineReader {
     return this.terminal && Number.isInteger(this.input.fd);
   }
 
-  readInteractiveTermSync() {
+  readInteractiveTermSync(solver = null) {
     if (!this.canReadTermSynchronously()) return null;
     let source = '';
     let prompt = '|: ';
@@ -172,7 +172,9 @@ class LineReader {
       if (line == null) return source.trim() ? source : null;
       source += `${line}\n`;
       const end = terminalFullStop(source);
-      if (end >= 0) return source.slice(0, end + 1) + '\n';
+      if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+        return source.slice(0, end + 1) + '\n';
+      }
       prompt = '|    ';
     }
   }
@@ -256,7 +258,7 @@ function makeState(engine, sources, output, options = {}, previousState = null,
     // let ISO term input request a complete terminal term exactly when read/1-2
     // or read_term/2-3 actually executes.  This also works inside conjunctions
     // and user predicates instead of only when read/* is the whole REPL goal.
-    userInput.interactiveReadTerm = () => reader.readInteractiveTermSync();
+    userInput.interactiveReadTerm = () => reader.readInteractiveTermSync(solver);
   }
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
@@ -300,7 +302,7 @@ async function prepareInteractiveTermInput(state, goal, reader) {
   const stream = interactiveTermInputStream(state, goal);
   if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
 
-  const text = await readInteractiveTerm(reader);
+  const text = await readInteractiveTerm(reader, state.solver);
   if (text == null) return;
   stream.content += text;
   stream.pastEnd = false;
@@ -334,7 +336,7 @@ function explicitInputReference(term) {
   return null;
 }
 
-async function readInteractiveTerm(reader) {
+async function readInteractiveTerm(reader, solver = null) {
   let source = '';
   let prompt = '|: ';
   while (true) {
@@ -342,11 +344,22 @@ async function readInteractiveTerm(reader) {
     if (line == null) return source.trim() ? source : null;
     source += `${line}\n`;
     const end = terminalFullStop(source);
-    if (end >= 0) return source.slice(0, end + 1) + '\n';
+    if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+      return source.slice(0, end + 1) + '\n';
+    }
     prompt = '|    ';
   }
 }
 
+function acceptsReadTermBoundary(source, end, solver) {
+  // A dot after a graphic character has two possible readings.  Stop at once
+  // when the candidate is already a complete term (for example `./*.`);
+  // otherwise keep reading so a later end char can make it part of an atom
+  // (for example the first dot in `!,*.\n.`).
+  return !continuesGraphicToken(source, end) || solver == null ||
+    isCompleteReadTermText(source.slice(0, end + 1), solver);
+}
+
 function terminalFullStop(source) {
   let quote = null;
   let lineComment = false;

package/test/run-regression.mjs

@@ -752,6 +752,62 @@ c4 ?- call((!;1)).
         });
         assertEqual(consecutive.stdout, "answer('./*.', ok).\n", 'following read starts after the complete term');
 
+        // A possible full stop can fail to complete the term while still
+        // extending a current graphic operator into an ordinary atom.  The
+        // later standalone full stop then completes the read term.  Exercise
+        // every predefined graphic operator, including the tokenizer's
+        // special :- and ?- cases, so they cannot diverge from * again.
+        const graphicOperator = /^[#$&*+\-./<=>?@^~\\:]+$/;
+        const graphicOperators = [...new Set(ISO_OPERATOR_DEFINITIONS.map(([, , name]) => name))]
+          .filter((name) => graphicOperator.test(name));
+        for (const name of graphicOperators) {
+          const program = Program.parse('');
+          const solver = new Solver(program, {
+            registry: getEyePrologRegistry(),
+            ioOptions: { input: `!,${name}.\n.\n` },
+          });
+          const readGoal = parseGoalText('read(T)', {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          const answers = [...solver.solve([readGoal], new Env(), 0)];
+          assertEqual(answers.length, 1, `graphic operator read answer for ${name}`);
+          const term = copyResolved(readGoal.args[0], answers[0]);
+          assertEqual(term.name, ',', `graphic operator conjunction for ${name}`);
+          assertEqual(term.args[0].name, '!', `graphic operator left operand for ${name}`);
+          assertEqual(term.args[1].name, `${name}.`, `graphic operator atom for ${name}`);
+        }
+
+        // Unlike an interactive reader waiting at a line boundary, a buffered
+        // stream can see later non-layout input.  Its first dot therefore
+        // remains in the maximal graphic token, making the adjacent ! invalid
+        // rather than prematurely returning the shorter atom.
+        for (const name of [...graphicOperators, '?', '#', '@', './*', '//*']) {
+          let bufferedError = null;
+          try {
+            runEyeProlog('', {
+              goal: 'read_term(T, [])',
+              ioOptions: { input: `${name}.\n!\n.` },
+            });
+          } catch (caught) {
+            bufferedError = caught;
+          }
+          assertEqual(
+            bufferedError?.message,
+            'error(syntax_error(read_term))',
+            `buffered graphic atom boundary for ${name}`,
+          );
+        }
+
+        const bufferedPath = path.join(tmp, 'graphic-atom-boundary.pl');
+        fs.writeFileSync(bufferedPath, '*.\n!\n.');
+        const namedStream = runEyeProlog([
+          `caught(ok) :- open(${sourceAtom(bufferedPath)}, read, S),`,
+          '  catch(read_term(S, _, []), error(syntax_error(read_term), _), true),',
+          '  close(S).',
+          '',
+        ].join('\n'), { goal: 'caught(ok)' });
+        assertEqual(namedStream.stdout, 'caught(ok).\n', 'named buffered stream syntax error');
+
         let error = null;
         try {
           runEyeProlog('', { goal: 'read(T)', ioOptions: { input: '!.!.' } });
@@ -769,6 +825,15 @@ c4 ?- call((!;1)).
         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');
+
+        const continuedGraphic = runCli([], {
+          input: 'read(T).\n!,*.\n.\nread(T).\na\n.\nhalt.\n',
+        });
+        assertEqual(continuedGraphic.status, 0, 'continued graphic operator REPL status');
+        assertIncludes(continuedGraphic.stdout, 'T = (!, *.).', 'continued graphic operator answer');
+        assertIncludes(continuedGraphic.stdout, 'T = a.', 'read after continued graphic operator');
+        assertNotIncludes(continuedGraphic.stdout, 'syntax_error', 'continued graphic operator syntax');
+        assertEqual(continuedGraphic.stderr, '', 'continued graphic operator REPL stderr');
       },
     },
     {