eyeprolog 1.2.39 → 1.2.41

package/package.json

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

package/src/iso.js

@@ -1074,8 +1074,16 @@ function* nlBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function* termTextCandidates(stream) {
+function activeCharConverter(solver) {
+  if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) {
+    return null;
+  }
+  return (character) => solver.charConversions.get(character) ?? character;
+}
+
+function* termTextCandidates(stream, solver) {
   const source = String(stream.content);
+  const convert = activeCharConverter(solver);
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
@@ -1105,15 +1113,25 @@ function* termTextCandidates(stream) {
       continue;
     }
     if (ch === "'" || ch === '"') { quote = ch; continue; }
-    if (ch === '.' && isTerminatingFullStop(source, i)) {
+    if (isTerminatingFullStop(source, i, convert)) {
       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;
@@ -1207,7 +1225,7 @@ function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
     let sawCandidate = false;
-    for (const candidate of termTextCandidates(stream)) {
+    for (const candidate of termTextCandidates(stream, solver)) {
       sawCandidate = true;
       if (candidate.lexicalError) {
         stream.position = candidate.end;

package/src/parser.js

@@ -378,10 +378,6 @@ class Parser {
     const line = this.line;
     const ch = this.peek();
     if (!ch) return { type: TOK.EOF, text: '', line };
-    if (this.source.startsWith('...', this.pos) && this.peek(3) !== '.') {
-      this.pos += 3;
-      return { type: TOK.ATOM, text: '...', line };
-    }
     if (ch === '?' && this.peek(1) === '-' &&
         !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
       this.pos += 2;

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, isCompleteReadTermText } from './iso.js';
+import { formalErrorTerm } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -171,8 +171,8 @@ class LineReader {
       const line = this.readTerminalLineSync();
       if (line == null) return source.trim() ? source : null;
       source += `${line}\n`;
-      const end = terminalFullStop(source);
-      if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+      const end = terminalFullStop(source, solver);
+      if (end >= 0) {
         return source.slice(0, end + 1) + '\n';
       }
       prompt = '|    ';
@@ -300,7 +300,7 @@ async function prepareInteractiveTermInput(state, goal, reader) {
   // fallback for piped/non-TTY REPL tests and scripted input.
   if (reader.canReadTermSynchronously()) return;
   const stream = interactiveTermInputStream(state, goal);
-  if (stream == null || terminalFullStop(String(stream.content).slice(stream.position)) >= 0) return;
+  if (stream == null || terminalFullStop(String(stream.content).slice(stream.position), state.solver) >= 0) return;
 
   const text = await readInteractiveTerm(reader, state.solver);
   if (text == null) return;
@@ -343,24 +343,23 @@ async function readInteractiveTerm(reader, solver = null) {
     const line = await reader.read(prompt);
     if (line == null) return source.trim() ? source : null;
     source += `${line}\n`;
-    const end = terminalFullStop(source);
-    if (end >= 0 && acceptsReadTermBoundary(source, end, solver)) {
+    const end = terminalFullStop(source, solver);
+    if (end >= 0) {
       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 activeCharConverter(solver) {
+  if (solver?.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) {
+    return null;
+  }
+  return (character) => solver.charConversions.get(character) ?? character;
 }
 
-function terminalFullStop(source) {
+function terminalFullStop(source, solver = null) {
+  const convert = activeCharConverter(solver);
   let quote = null;
   let lineComment = false;
   let blockComment = false;
@@ -415,7 +414,7 @@ function terminalFullStop(source) {
     }
     if ('([{'.includes(ch)) depth++;
     else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
-    else if (ch === '.' && depth === 0 && isTerminatingFullStop(source, i) &&
+    else if (depth === 0 && isTerminatingFullStop(source, i, convert) &&
              onlyLayoutAndComments(source.slice(i + 1))) return i;
   }
   return -1;
@@ -503,11 +502,15 @@ async function solveQuery(engine, state, goal, reader, output) {
     if (formattingAfterAdvance) output.write(' ');
     formattingAfterAdvance = false;
     output.write(current.output);
-    output.write(`${firstAnswer ? ' ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
+    const answer = formatAnswer(engine, state, variables, current.result.value);
+    output.write(`${firstAnswer ? ' ' : ''}${answer}`);
     answersShown++;
     firstAnswer = false;
     if (!next.error && next.result.done) {
-      output.write('.\n');
+      // A terminal full stop cannot immediately follow a graphic token: the
+      // scanner would absorb it into that token. Insert layout so the printed
+      // answer remains valid Prolog text (issue #44).
+      output.write(`${continuesGraphicToken(answer, answer.length) ? ' ' : ''}.\n`);
       return null;
     }
 

package/src/syntax-scan.js

@@ -4,21 +4,49 @@
 
 const graphicTokenCharacters = new Set('#$&*+-./<=>?@^~\\:');
 
-export function continuesGraphicToken(source, index) {
-  return index > 0 && graphicTokenCharacters.has(source[index - 1]);
+export function continuesGraphicToken(source, index, convert = null) {
+  if (index <= 0) return false;
+  const rawPrevious = source[index - 1];
+  const previous = convert == null ? rawPrevious : convert(rawPrevious);
+  // Most full stops follow a non-graphic token. Reject those in O(1) before
+  // doing the rarer character-code/comment disambiguation below; otherwise a
+  // large source with many term-ending dots degenerates into repeated backward
+  // scans (notably multi-megabyte generated data files).
+  if (!graphicTokenCharacters.has(previous)) return false;
+
+  // A graphic-looking character can be the payload or closing escape of a
+  // character-code constant rather than a graphic token.  For example, the
+  // backslash immediately before the full stop in `0'\x41\.` belongs to
+  // the number token, so that full stop still terminates the term.
+  const apostrophe = source.lastIndexOf("'", index - 1);
+  if (apostrophe >= 0 && characterCodeConstantEnd(source, apostrophe) === index - 1) return false;
+  // The slash that closes a bracketed comment is layout, not the tail of a
+  // graphic token. Distinguish it from spellings such as `//*.*/`, where the
+  // apparent /* is itself embedded in a graphic token and therefore never
+  // opens a comment.
+  if (source[index - 1] === '/' && source[index - 2] === '*') {
+    for (let open = source.lastIndexOf('/*', index - 3); open >= 0;
+         open = source.lastIndexOf('/*', open - 1)) {
+      if (open === 0 || !graphicTokenCharacters.has(source[open - 1])) return false;
+    }
+  }
+  return true;
 }
 
-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.
+export function isTerminatingFullStop(source, index, convert = null) {
+  const current = convert == null ? source[index] : convert(source[index]);
+  if (current !== '.') return false;
+  const rawNext = source[index + 1] ?? '';
+  const next = convert == null ? rawNext : convert(rawNext);
+  // A full stop cannot terminate a term when it can still extend the graphic
+  // token immediately before it. This remains true at a line boundary and at
+  // the current end of interactive input: `*.\n` is the graphic token `*.`
+  // followed by layout, so read/1 must keep waiting for a separate end char.
+  // Conversely `!.\n` terminates because ! is a solo token, not a graphic
+  // token character accepted by continuesGraphicToken().
+  if (continuesGraphicToken(source, index, convert)) return false;
   if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
-  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return !continuesGraphicToken(source, index);
+  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return true;
   return false;
 }
 

package/src/write.js

@@ -4,8 +4,8 @@ import {
   Env, deref, isCons, isEmptyList,
 } from './term.js';
 
-const graphicAtomCharacters = new Set('!#$&*+-/<=>?@^~\\'.split(''));
-const dottedGraphicAtomCharacters = new Set([...graphicAtomCharacters, '.']);
+const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
+const dottedGraphicAtomCharacters = graphicAtomCharacters;
 const compactInfixOperators = new Set([':', '..']);
 
 function quotedControlEscape(ch) {
@@ -28,7 +28,11 @@ function quotedControlEscape(ch) {
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
-  if (name === '...') return false;
+  // A lone full stop is the end token, not a graphic atom.  Longer
+  // graphic tokens may contain dots and are valid unquoted writeq/1 output
+  // (WG17 #371-373: ./*, .*, ...*).  Only a token beginning with /* would
+  // be read as a bracketed comment and therefore still requires quoting.
+  if (name === '.') return true;
   if (name.startsWith('/*')) return true;
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;

package/test/conformance/expected-errors/rules/extra_rule_without_body.txt

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

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/conformance/wg17-syntax-cases.json

@@ -671,7 +671,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "'//*.*/'",
+            "output": "//*.*/",
             "variables": "[]"
           }
         ]
@@ -4302,7 +4302,7 @@
             "variables": "[]"
           },
           {
-            "output": ">('>.'(a),b)",
+            "output": ">(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4322,7 +4322,7 @@
             "variables": "[]"
           },
           {
-            "output": "=('>.'(a),b)",
+            "output": "=(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4342,7 +4342,7 @@
             "variables": "[]"
           },
           {
-            "output": "','('>.'(a),b)",
+            "output": "','(>.(a),b)",
             "variables": "[]"
           }
         ]
@@ -4362,7 +4362,7 @@
             "variables": "[]"
           },
           {
-            "output": "'>.'(a)",
+            "output": ">.(a)",
             "variables": "[]"
           }
         ]
@@ -5022,7 +5022,7 @@
         "type": "success",
         "stages": [
           {
-            "output": "'.+'",
+            "output": ".+",
             "variables": "[]"
           }
         ]
@@ -5273,7 +5273,7 @@
             "variables": "[]"
           },
           {
-            "output": "'.>'('.>'(a))",
+            "output": ".>(.>(a))",
             "variables": "[]"
           }
         ]

package/test/run-regression.mjs

@@ -102,6 +102,16 @@ export function runRegression(reporter = new TestReporter()) {
 
 function regressionCases() {
   return [
+    {
+      name: 'large source scanning avoids quadratic full-stop lookback',
+      run: () => {
+        const result = runCli(['examples/path-discovery.pl'], { timeout: 10000 });
+        if (result.error) throw new Error(`path-discovery timed out or failed to launch: ${result.error.message}`);
+        assertEqual(result.status, 0, `path-discovery status; stderr=${result.stderr}`);
+        assertIncludes(result.stdout, "airroute('Ostend-Bruges International Airport', 'Václav Havel Airport Prague'",
+          'path-discovery result');
+      },
+    },
     {
       name: '--proof rule fact explanation output',
       run: () => runWhy({
@@ -733,24 +743,77 @@ c4 ?- call((!;1)).
         assertIncludes(upstreamResult.stdout, '46 true.', 'WG17 #367 output');
       },
     },
+    {
+      name: 'top level separates terminal full stop from graphic answers (issue #44)',
+      run: () => {
+        const result = runCli([], { input: 'X = .* .\nhalt.\n' });
+        assertEqual(result.status, 0, 'issue #44 exit status');
+        assertIncludes(result.stdout, 'X = .* .\n', 'graphic binding is separated from terminal full stop');
+        assertNotIncludes(result.stdout, 'X = .*.\n', 'terminal full stop is not absorbed into graphic atom');
+        assertEqual(result.stderr, '', 'issue #44 stderr');
+      },
+    },
+    {
+      name: 'writeq leaves ISO dotted graphic atoms unquoted (WG17 #371-373)',
+      run: () => {
+        const result = runCli([], {
+          input: 'writeq(./*).\nwriteq(.*).\nwriteq(...*).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'dotted graphic writeq exit status');
+        assertIncludes(result.stdout, '  ./* true.\n', 'writeq ./* is unquoted');
+        assertIncludes(result.stdout, '  .* true.\n', 'writeq .* is unquoted');
+        assertIncludes(result.stdout, '  ...* true.\n', 'writeq ...* is unquoted');
+        assertNotIncludes(result.stdout, "'./*'", 'writeq ./* has no quotes');
+        assertNotIncludes(result.stdout, "'.*'", 'writeq .* has no quotes');
+        assertNotIncludes(result.stdout, "'...*'", 'writeq ...* has no quotes');
+      },
+    },
     {
       name: 'readers distinguish graphic tokens, comments, and full stops (issue #41)',
       run: () => {
-        const parsed = parseProgramText('./*.');
+        const parsed = parseProgramText('./* .');
         assertEqual(parsed.length, 1, 'graphic atom clause count');
         assertEqual(parsed[0].head.name, './*', 'comment opener stays inside graphic atom');
 
+        // A dot immediately after a graphic token belongs to that maximal
+        // token. A separate end char is therefore required even at a line
+        // boundary; this is the waiting behavior called out in WG17 #370-373.
+        const waitProgram = Program.parse('');
+        const waitSolver = new Solver(waitProgram, {
+          registry: getEyePrologRegistry(),
+          ioOptions: { input: '*.\n' },
+        });
+        const waitStream = waitSolver.io.resolve('user_input');
+        let refillRequests = 0;
+        waitStream.interactiveReadTerm = () => {
+          refillRequests++;
+          return '.\n';
+        };
+        const waitGoal = parseGoalText('read(T)', {
+          operatorDefinitions: [...waitProgram.operators.values()],
+        });
+        const waitAnswers = [...waitSolver.solve([waitGoal], new Env(), 0)];
+        assertEqual(waitAnswers.length, 1, 'graphic token read answer after refill');
+        assertEqual(refillRequests, 1, 'graphic token boundary waits for a separate end char');
+        assertEqual(copyResolved(waitGoal.args[0], waitAnswers[0]).name, '*.', 'maximal graphic token after refill');
+
         const read = runEyeProlog('', {
           goal: 'read(T)',
-          ioOptions: { input: './*.' },
+          ioOptions: { input: './*. .' },
+        });
+        assertEqual(read.stdout, "read(./*.).\n", 'dotted graphic atom writeq readback');
+
+        const ellipsisGraphic = runEyeProlog('', {
+          goal: 'read(T)',
+          ioOptions: { input: '...*\n.\n' },
         });
-        assertEqual(read.stdout, "read('./*').\n", 'graphic atom writeq readback');
+        assertEqual(ellipsisGraphic.stdout, "read(...*).\n", 'ellipsis prefix remains inside maximal graphic atom');
 
         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');
+        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
@@ -777,6 +840,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: '!.!.' } });
@@ -789,7 +883,7 @@ c4 ?- call((!;1)).
           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 = ./*. .', 'REPL dotted graphic atom answer');
         assertNotIncludes(repl.stdout, "T = './*.'", 'REPL dotted graphic atom has no spurious quotes');
         assertIncludes(repl.stdout, 'T = ok.', 'REPL following read answer');
         assertIncludes(repl.stdout, 'error(syntax_error(read_term), eyeprolog)', 'REPL syntax error');
@@ -1531,10 +1625,10 @@ c4 ?- call((!;1)).
         if (available.status !== 0) return;
         const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
         const scriptCommand =
-          `{ printf 'read(X), read(Y).\n'; sleep 0.15; ` +
-          `printf 'foo.\n'; sleep 0.15; printf 'bar.\n'; sleep 0.15; ` +
-          `printf 'read(Z).\n'; sleep 0.15; printf '\\004'; sleep 0.15; ` +
-          `printf 'true.\n'; sleep 0.15; printf 'halt.\n'; } | ` +
+          `{ printf 'read(X), read(Y).\n'; sleep 0.3; ` +
+          `printf 'foo.\n'; sleep 0.3; printf 'bar.\n'; sleep 0.3; ` +
+          `printf 'read(Z).\n'; sleep 0.3; printf '\\004'; sleep 0.3; ` +
+          `printf 'true.\n'; sleep 0.3; printf 'halt.\n'; } | ` +
           `script -qefc ${shellQuote(command)} /dev/null`;
         const result = spawnSync('sh', ['-c', scriptCommand], {
           cwd: packageRoot,
@@ -4338,6 +4432,7 @@ function runCli(args, options = {}) {
     encoding: 'utf8',
     env: options.env ? { ...process.env, ...options.env } : process.env,
     input: options.input ?? undefined,
+    timeout: options.timeout ?? undefined,
   });
 }
 

package/the-art-of-eyeprolog.md

@@ -5253,10 +5253,12 @@ write_event(Path, Event) :-
 
 The period is essential when another Prolog processor will read the result as
 a term. `write/1-2` uses readable conventional syntax, `writeq/1-2` quotes
-where needed, and `write_canonical/1-2` exposes canonical structure. ISO term
-output uses only the separator characters needed by the syntax, so functional
-arguments and list elements are emitted compactly; for example `writeq([a,b])`
-outputs `[a,b]`.
+where needed, and `write_canonical/1-2` exposes canonical structure. Dotted
+graphic atoms do not need quotes merely because they contain a period:
+`writeq(./*)`, `writeq(.*)`, and `writeq(...*)` output `./*`, `.*`, and `...*`
+respectively. ISO term output uses only the separator characters needed by the
+syntax, so functional arguments and list elements are emitted compactly; for
+example `writeq([a,b])` outputs `[a,b]`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`.
 
@@ -5377,10 +5379,12 @@ 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.
+maximal graphic token the slash and star remain atom characters. Graphic tokens
+are formed maximally before a period can be recognized as the terminating full
+stop. Consequently, interactive input `*.` or `./*.` is not yet a complete term:
+the period is part of the graphic atom and the reader waits for a separate
+terminating full stop. Thus `./*. .` 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
@@ -6344,8 +6348,10 @@ period-terminated query with no solutions prints `false.`; a solution without
 visible variable bindings prints `true.`. Answer substitutions are rendered as
 valid Prolog syntax under the current operator table: when a bound value would
 not be a valid right operand of the displayed `=/2`, EyeProlog adds parentheses,
-for example `T = (a = b).` rather than the invalid `T = a = b.`. Use `[file].`
-or `['file.pl'].` to
+for example `T = (a = b).` rather than the invalid `T = a = b.`. When an answer
+ends in a graphic token, the top level inserts layout before its terminating
+full stop so the two tokens cannot merge; for example `?- X = .* .` displays
+`X = .* .`, not `X = .*.`. Use `[file].` or `['file.pl'].` to
 consult local source, and `halt.` or `halt(Status).` to leave the top level.
 When `read/1-2` or `read_term/2-3` actually reaches interactive
 `user_input`, the top level requests the next full-stop-terminated Prolog term