eyeprolog 1.2.39 → 1.2.40

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.39",
+  "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;

package/test/run-regression.mjs

@@ -777,6 +777,37 @@ c4 ?- call((!;1)).
           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: '!.!.' } });