eyeprolog 1.2.6 → 1.2.8

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 167 | 210 | 0 | 0 | 377 |
+| iso | 167 | 216 | 0 | 0 | 383 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **482** | **261** | **19** | **21** | **783** |
+| **Total** | **482** | **267** | **19** | **21** | **789** |

package/package.json

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

package/src/iso.js

@@ -1067,6 +1067,11 @@ function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;
 
+  // A quoted-token continuation escape consumes its newline. Accept CRLF as
+  // the host representation of the same line boundary.
+  if (escaped === '\n') return index + 1;
+  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
+
   // ISO 6.4.2.1 numeric escapes include a terminating backslash.  Consume
   // that delimiter as part of the quoted character so stream scanning does
   // not mistake it for an escape of the quote which follows.
@@ -1096,6 +1101,13 @@ function* termTextCandidates(stream) {
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
       if (ch === '\\') i = quotedEscapeEnd(source, i);
+      else if (ch !== ' ' && /^[\u0009-\u000d]$/.test(ch)) {
+        // Literal layout characters are not quoted characters (6.4.2.1).
+        // Surface the lexical error immediately even when there is no later
+        // full stop; otherwise read/1 would misreport malformed input as EOF.
+        yield { text: source.slice(stream.position, i + 1), end: i + 1, lexicalError: true };
+        return;
+      }
       else if (ch === quote && next === quote) i++;
       else if (ch === quote) quote = null;
       continue;
@@ -1135,28 +1147,53 @@ function convertedTermText(text, solver) {
   return result;
 }
 function readTermFromStream(stream, solver) {
-  let sawCandidate = false;
-  for (const candidate of termTextCandidates(stream)) {
-    sawCandidate = true;
-    try {
-      const operatorState = createParserOperatorState(solver.program.operators.values(), false);
-      const clauses = parseClauses(convertedTermText(candidate.text, solver), {
-        sourceMetadata: false,
-        operatorState,
-        doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-      });
-      if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
-      stream.position = candidate.end;
-      return clauses[0].head;
-    } catch (_) {
-      // A dot inside a graphic operator, such as =.., is only a possible
-      // terminator. Keep scanning until a complete term parses.
+  let requestedInteractiveTerm = false;
+  while (true) {
+    let sawCandidate = false;
+    for (const candidate of termTextCandidates(stream)) {
+      sawCandidate = true;
+      if (candidate.lexicalError) {
+        stream.position = candidate.end;
+        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,
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        });
+        if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
+        stream.position = candidate.end;
+        return clauses[0].head;
+      } catch (_) {
+        // A dot inside a graphic operator, such as =.., is only a possible
+        // terminator. Keep scanning until a complete term parses.
+      }
     }
+
+    // The interactive top level may attach a synchronous reader to the
+    // standard user_input stream. Ask it for one complete read-term only when
+    // this read operation actually reaches the end of buffered input. This is
+    // deliberately a stream hook, not goal-shape recognition, so conjunctions
+    // and reads reached through user predicates behave the same as read/1.
+    if (!sawCandidate && !requestedInteractiveTerm &&
+        typeof stream.interactiveReadTerm === 'function') {
+      requestedInteractiveTerm = true;
+      const text = stream.interactiveReadTerm();
+      if (text != null) {
+        stream.content += String(text);
+        stream.pastEnd = false;
+        continue;
+      }
+    }
+
+    stream.position = String(stream.content).length;
+    if (!sawCandidate) return atom('end_of_file');
+    throw new PrologError('syntax_error(read_term)');
   }
-  stream.position = String(stream.content).length;
-  if (!sawCandidate) return atom('end_of_file');
-  throw new PrologError('syntax_error(read_term)');
 }
+
 function* readBuiltin({ solver, goal, env }) {
   const stream = inputStreamFor(solver, goal, env);
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));

package/src/parser.js

@@ -285,29 +285,58 @@ class Parser {
       break;
     }
   }
-  readEscape(line) {
+  readEscape(line, options = {}) {
     const escaped = this.take();
     if (!escaped) throw new Error(`parse line ${line}: unterminated escape sequence`);
-    if (escaped === '\n') return '';
+
+    // ISO 6.4.2 permits a continuation escape only inside quoted tokens: a
+    // backslash immediately followed by a newline. Character-code constants
+    // use a single quoted character and therefore cannot use continuation.
+    if (escaped === '\n') {
+      if (options.allowContinuation !== false) return '';
+      throw new Error(`parse line ${line}: bad escape sequence`);
+    }
+    if (escaped === '\r' && this.peek() === '\n') {
+      if (options.allowContinuation !== false) {
+        this.take();
+        return '';
+      }
+      throw new Error(`parse line ${line}: bad escape sequence`);
+    }
+
     const controls = { a: '\x07', b: '\b', r: '\r', f: '\f', t: '\t', n: '\n', v: '\v' };
     if (controls[escaped] != null) return controls[escaped];
+
     if (escaped === 'x') {
       let digits = '';
       while (/^[0-9A-Fa-f]$/.test(this.peek())) digits += this.take();
       if (!digits || this.take() !== '\\') throw new Error(`parse line ${line}: bad hexadecimal escape`);
-      return String.fromCodePoint(Number.parseInt(digits, 16));
+      const code = Number.parseInt(digits, 16);
+      if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
+        throw new Error(`parse line ${line}: character escape out of range`);
+      }
+      return String.fromCodePoint(code);
     }
     if (/^[0-7]$/.test(escaped)) {
       let digits = escaped;
       while (/^[0-7]$/.test(this.peek())) digits += this.take();
       if (this.take() !== '\\') throw new Error(`parse line ${line}: bad octal escape`);
-      return String.fromCodePoint(Number.parseInt(digits, 8));
+      const code = Number.parseInt(digits, 8);
+      if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
+        throw new Error(`parse line ${line}: character escape out of range`);
+      }
+      return String.fromCodePoint(code);
     }
     // A backslash followed by a decimal digit is numeric-escape syntax, but
     // ISO octal digits are limited to 0..7.  Do not reinterpret \8 or \9 as
     // implementation-specific one-character escapes.
     if (/^[0-9]$/.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
-    return escaped;
+
+    // The only remaining ISO meta escapes are the four meta characters from
+    // 6.5.5.  Forms such as \c, \d, \e, \u or \. are not quoted
+    // characters in ISO syntax and must not be silently accepted.
+    if (escaped === '\\' || escaped === "'" || escaped === '"' || escaped === '`') return escaped;
+    throw new Error(`parse line ${line}: bad escape sequence`);
   }
   nextToken() {
     // The tokenizer keeps just enough state for useful parse-line errors and
@@ -373,6 +402,11 @@ class Parser {
           }
         } else if (value === '\\' && this.peek()) {
           value = this.readEscape(line);
+        } else if (value !== ' ' && isWhitespaceCode(value.charCodeAt(0))) {
+          // ISO 6.4.2.1 allows an ordinary space in a quoted character, but
+          // not literal layout characters such as tab or newline. Newlines
+          // are permitted only through the continuation escape handled above.
+          throw new Error(`parse line ${line}: layout character in quoted term`);
         }
         text += value;
       }
@@ -398,8 +432,10 @@ class Parser {
         this.take();
         this.take();
         let value = this.take();
-        if (!value || value === '\n') throw new Error(`parse line ${line}: bad character code constant`);
-        if (value === '\\') value = this.readEscape(line);
+        if (!value || (value !== ' ' && isWhitespaceCode(value.charCodeAt(0)))) {
+          throw new Error(`parse line ${line}: bad character code constant`);
+        }
+        if (value === '\\') value = this.readEscape(line, { allowContinuation: false });
         const code = value.codePointAt(0);
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }

package/src/repl.js

@@ -1,5 +1,6 @@
 // Interactive top level for the eyeprolog command.
 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';
@@ -20,7 +21,7 @@ export async function runRepl(engine, options = {}) {
   const errorOutput = options.errorOutput ?? process.stderr;
   const reader = new LineReader(input, output);
   const sources = [];
-  let state = makeState(engine, sources, output, options);
+  let state = makeState(engine, sources, output, options, null, reader);
   let exitCode = 0;
 
   try {
@@ -34,7 +35,7 @@ export async function runRepl(engine, options = {}) {
         const goal = parseGoal(engine, state, text);
         if (!options.isoStrict && isUseModuleGoal(goal)) {
           sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
-          state = makeState(engine, sources, output, options, state);
+          state = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
@@ -42,7 +43,7 @@ export async function runRepl(engine, options = {}) {
         const consultFiles = options.isoStrict ? null : consultDesignations(engine, goal);
         if (consultFiles != null) {
           for (const filename of consultFiles) sources.push(await readSource(filename));
-          state = makeState(engine, sources, output, options, state);
+          state = makeState(engine, sources, output, options, state, reader);
           runWithTerminalSignals(reader, () => state.solver.runInitializations());
           output.write('   true.\n');
           continue;
@@ -78,6 +79,8 @@ export async function runRepl(engine, options = {}) {
 }
 
 class LineReader {
+  static syncWait = new Int32Array(new SharedArrayBuffer(4));
+
   constructor(input, output) {
     this.input = input;
     this.output = output;
@@ -142,6 +145,57 @@ class LineReader {
     return control;
   }
 
+  canReadTermSynchronously() {
+    return this.terminal && Number.isInteger(this.input.fd);
+  }
+
+  readInteractiveTermSync() {
+    if (!this.canReadTermSynchronously()) return null;
+    let source = '';
+    let prompt = '|: ';
+    while (true) {
+      this.output.write(prompt);
+      const line = this.readTerminalLineSync();
+      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';
+      prompt = '|    ';
+    }
+  }
+
+  readTerminalLineSync() {
+    const byte = Buffer.allocUnsafe(1);
+    const bytes = [];
+    while (true) {
+      let count;
+      try {
+        count = readSync(this.input.fd, byte, 0, 1, null);
+      } catch (error) {
+        // Node keeps terminal fds non-blocking.  Once readline is suspended,
+        // a synchronous read can therefore report EAGAIN while waiting for
+        // the user. Sleep briefly and retry; terminal signals still retain
+        // their native action because no readline signal handler is installed.
+        if (error?.code === 'EAGAIN' || error?.code === 'EWOULDBLOCK') {
+          Atomics.wait(LineReader.syncWait, 0, 0, 10);
+          continue;
+        }
+        throw error;
+      }
+      // In canonical terminal mode Ctrl-D on an empty line makes read(2)
+      // return zero bytes.  Scope that EOF to the current Prolog read rather
+      // than closing the outer readline iterator / top-level loop.
+      if (count === 0) {
+        return bytes.length === 0 ? null : Buffer.from(bytes).toString('utf8');
+      }
+      if (byte[0] === 10) {
+        if (bytes.at(-1) === 13) bytes.pop();
+        return Buffer.from(bytes).toString('utf8');
+      }
+      bytes.push(byte[0]);
+    }
+  }
+
   suspendForComputation() {
     if (!this.terminal || !this.readline) return false;
     // Node readline installs terminal signal handling while the interface is
@@ -175,7 +229,7 @@ function runWithTerminalSignals(reader, operation) {
   }
 }
 
-function makeState(engine, sources, output, options = {}, previousState = null) {
+function makeState(engine, sources, output, options = {}, previousState = null, reader = null) {
   const strictIso = options.isoStrict === true;
   const program = engine.Program.parseSources(sources, { strictIso, sourceMetadata: strictIso });
   const solver = new engine.Solver(program, {
@@ -183,6 +237,14 @@ function makeState(engine, sources, output, options = {}, previousState = null)
     isoStrict: strictIso,
     ioOptions: { write: (text) => output.write(String(text)) },
   });
+  const userInput = solver.io.resolve('user_input');
+  if (userInput && reader?.canReadTermSynchronously()) {
+    // The solver is synchronous.  While pullSolution() has readline suspended,
+    // 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();
+  }
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
     const definition = solver.prologFlags.get(name);
@@ -218,6 +280,10 @@ async function readQuery(reader) {
 }
 
 async function prepareInteractiveTermInput(state, goal, reader) {
+  // Real terminals are serviced on demand from readTermFromStream() while the
+  // synchronous solver is running.  Keep the older async preloader only as a
+  // 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;
 
@@ -272,6 +338,12 @@ function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;
 
+  // A backslash-newline pair is a continuation escape (6.4.2), so the
+  // newline is not a literal quoted character. Accept CRLF as the host text
+  // representation of the same continuation boundary.
+  if (escaped === '\n') return index + 1;
+  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
+
   // ISO 6.4.2.1 octal and hexadecimal escapes are terminated by a
   // backslash.  Consume that terminator as part of the escape so the REPL
   // scanner does not mistake it for an escape of the following quote.
@@ -317,6 +389,12 @@ function terminalFullStop(source) {
     if (quote != null) {
       if (ch === '\\') {
         i = quotedEscapeEnd(source, i);
+      } else if (ch === '\n' || ch === '\r') {
+        // A literal newline can never be repaired by a later line: ISO
+        // 6.4.2.1 excludes it from quoted characters. Return this boundary
+        // immediately so the parser reports a syntax error instead of the
+        // top level prompting forever for a closing quote.
+        return i;
       } else if (ch === quote) {
         if (next === quote) i++;
         else quote = null;

package/src/write.js

@@ -7,6 +7,23 @@ import {
 const graphicAtomCharacters = new Set('!#$&*+-/<=>@^~\\'.split(''));
 const compactInfixOperators = new Set([':', '..']);
 
+function quotedControlEscape(ch) {
+  if (ch === '\x00') return '\\0\\';
+  if (ch === '\x07') return '\\a';
+  if (ch === '\b') return '\\b';
+  if (ch === '\r') return '\\r';
+  if (ch === '\f') return '\\f';
+  if (ch === '\t') return '\\t';
+  if (ch === '\n') return '\\n';
+  if (ch === '\v') return '\\v';
+  const code = ch.codePointAt(0);
+  // Other C0 controls and DEL have no ISO symbolic-control escape. Emit an
+  // octal escape so quoted output remains valid read-back syntax instead of
+  // leaking a raw control character into the output stream.
+  if (code < 0x20 || code === 0x7f) return `\\${code.toString(8)}\\`;
+  return null;
+}
+
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
@@ -22,15 +39,7 @@ function quoteAtom(name) {
   for (const ch of name) {
     if (ch === "'") out += "''";
     else if (ch === '\\') out += '\\\\';
-    else if (ch === '\x00') out += '\\0\\';
-    else if (ch === '\x07') out += '\\a';
-    else if (ch === '\b') out += '\\b';
-    else if (ch === '\r') out += '\\r';
-    else if (ch === '\f') out += '\\f';
-    else if (ch === '\t') out += '\\t';
-    else if (ch === '\n') out += '\\n';
-    else if (ch === '\v') out += '\\v';
-    else out += ch;
+    else out += quotedControlEscape(ch) ?? ch;
   }
   return out + "'";
 }
@@ -60,15 +69,7 @@ function writeString(value) {
   let out = '"';
   for (const ch of value) {
     if (ch === '"' || ch === '\\') out += `\\${ch}`;
-    else if (ch === '\x00') out += '\\0\\';
-    else if (ch === '\x07') out += '\\a';
-    else if (ch === '\b') out += '\\b';
-    else if (ch === '\r') out += '\\r';
-    else if (ch === '\f') out += '\\f';
-    else if (ch === '\t') out += '\\t';
-    else if (ch === '\n') out += '\\n';
-    else if (ch === '\v') out += '\\v';
-    else out += ch;
+    else out += quotedControlEscape(ch) ?? ch;
   }
   return out + '"';
 }

package/test/conformance/ISO-COMPLIANCE.md

@@ -30,7 +30,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, writer/read-back regressions. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, quoted-layout/escape error cases, writer/read-back regressions. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. Public/private and multi-text requirements still need complete mapping. |

package/test/conformance/ISO-MATRIX.md

@@ -8,7 +8,7 @@ compliance audit and the remaining work before a full conformance claim.
 
 | Standard area | Implementation | Representative executable coverage |
 | --- | --- | --- |
-| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, syntax error cases |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
 | 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases |

package/test/conformance/README.md

@@ -102,7 +102,7 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 377 cases in `iso/` and 783 file-based conformance cases in
+The corpus has 383 cases in `iso/` and 789 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

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

@@ -85,3 +85,14 @@ numeric_escape_term_input(ok) :-
     A == '\a',
     B == '\a'.
 
+
+%% goal: malformed_quoted_term_input(ok)
+
+malformed_quoted_term_input(ok) :-
+    open('/tmp/eyeprolog-iso-bad-quoted-term.txt', write, Output, []),
+    put_code(Output, 39), nl(Output),
+    close(Output),
+    open('/tmp/eyeprolog-iso-bad-quoted-term.txt', read, Input, []),
+    catch(read(Input, _), error(syntax_error(read_term), _), Caught = yes),
+    close(Input),
+    Caught == yes.

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

@@ -1,6 +1,6 @@
 % High-risk ISO syntax/write regressions, independently derived from
 % ISO/IEC 13211-1 clauses 6.3, 6.4 and 7.10 and cross-checked against the
-% public WG17 conformity-testing syntax cases (#1, #14-15, #28-31, #33-34, #301).
+% public WG17 conformity-testing syntax cases (#1, #7-10, #14-15, #18, #28-31, #33-34, #301, #315-316).
 
 %% goal: wg17_numeric_escape
 wg17_numeric_escape :-
@@ -28,3 +28,18 @@ wg17_canonical_list :-
 %% goal: wg17_zero_character_escape
 wg17_zero_character_escape :-
     writeq('\0\'), nl.
+
+%% goal: wg17_continuation_escapes
+wg17_continuation_escapes :-
+    writeq('\
+'), nl,
+    writeq('\
+a'), nl,
+    writeq('a\
+b'), nl,
+    writeq('a\
+ b'), nl.
+
+%% goal: wg17_non_symbolic_control_write
+wg17_non_symbolic_control_write :-
+    writeq('\033\'), nl.

package/test/conformance/cases/strings/trim_tabs_and_spaces.pl

@@ -1,4 +1,3 @@
 %% goal: answer(X0)
 
-answer(X) :- trim('	 hello 
-', X).
+answer(X) :- trim('\t hello \n', X).

package/test/conformance/cases/syntax/quoted_atom_with_newline_escape.pl

@@ -1,4 +1,3 @@
 %% goal: answer(X0)
 
-answer('line
-break').
+answer('line\nbreak').

package/test/conformance/cases/syntax/string_with_tab_escape.pl

@@ -1,3 +1,3 @@
 %% goal: answer(X0)
 
-answer("a	b").
+answer("a\tb").

package/test/conformance/errors/iso/wg17_bad_character_code_escape.pl

@@ -0,0 +1 @@
+bad :- X = 0'\..

package/test/conformance/errors/iso/wg17_literal_newline_in_quote.pl

@@ -0,0 +1,2 @@
+writeq('
+').

package/test/conformance/errors/iso/wg17_literal_tab_in_quote.pl

@@ -0,0 +1 @@
+writeq('	').

package/test/conformance/errors/iso/wg17_non_iso_escape.pl

@@ -0,0 +1 @@
+writeq('\e').

package/test/conformance/errors/iso/wg17_non_iso_unicode_escape.pl

@@ -0,0 +1 @@
+writeq('\u0021').

package/test/conformance/errors/iso/wg17_unterminated_quoted_token.pl

@@ -0,0 +1 @@
+'

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

@@ -5,3 +5,4 @@ default_streams(ok).
 io_marker
 standard_write(ok).
 numeric_escape_term_input(ok).
+malformed_quoted_term_input(ok).

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

@@ -13,3 +13,10 @@ wg17_operator_precedence.
 wg17_canonical_list.
 '\0\'
 wg17_zero_character_escape.
+''
+a
+ab
+'a b'
+wg17_continuation_escapes.
+'\33\'
+wg17_non_symbolic_control_write.

package/test/conformance/expected-errors/iso/wg17_bad_character_code_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_literal_newline_in_quote.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/iso/wg17_literal_tab_in_quote.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/iso/wg17_non_iso_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_non_iso_unicode_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_unterminated_quoted_token.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

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

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

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

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

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

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

package/test/run-regression.mjs

@@ -696,6 +696,127 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL rejects an unterminated quote at the line boundary instead of waiting',
+      run: () => {
+        const result = runCli([], {
+          input: "'\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    parse line 1: unterminated quoted term.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL rejects a literal newline in a quoted token immediately',
+      run: () => {
+        const result = runCli([], {
+          // The first input line ends while a quote is open. ISO 6.4.2.1
+          // makes that newline a lexical error unless it is escaped by the
+          // immediately preceding backslash. The following true/0 proves
+          // that the top level did not consume another line as continuation.
+          input: "writeq('\ntrue.\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    parse line 1: unterminated quoted term.\n' +
+          '?-    true.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'parser matches WG17 quoted-character and escape syntax cluster',
+      run: () => {
+        const invalid = [
+          ['#2 lone quote', "'\n"],
+          ['#5 literal horizontal tab', "writeq('\t')"],
+          ['#6 literal newline', "writeq('\n')"],
+          ['#11 backslash-space', String.raw`writeq('\ ')`],
+          ['#12 backslash-horizontal-tab', "writeq('\\\t')"],
+          ['#16 non-ISO c escape', String.raw`writeq('\ca')`],
+          ['#241 non-ISO d escape', String.raw`writeq('\d')`],
+          ['#17 non-ISO e escape', String.raw`writeq('\e')`],
+          ['#19 non-ISO e in char_code/2', String.raw`char_code('\e', C)`],
+          ['#21 non-ISO d in char_code/2', String.raw`char_code('\d', C)`],
+          ['#22 non-ISO u escape', String.raw`writeq('\u1')`],
+          ['#312 non-ISO Unicode escape', String.raw`writeq('\u0021')`],
+          ['#314 non-ISO Unicode double-quote escape', String.raw`writeq("\u0021")`],
+          ['#23 non-ISO character-code escape', String.raw`X = 0'\u1`],
+          ['#24 unterminated quoted argument', "writeq('\n"],
+          ['#26 continuation followed by unterminated quote', "'\\\n''"],
+          ['#210 escaped dot character code', String.raw`X = 0'\.`],
+          ['#211 escaped dot character code before layout', String.raw`X = 0'\. `],
+        ];
+        for (const [label, source] of invalid) {
+          let error = null;
+          try {
+            parseGoalText(source);
+          } catch (caught) {
+            error = caught;
+          }
+          if (error == null) throw new Error(`${label} unexpectedly parsed`);
+        }
+
+        const valid = [
+          ['#7 empty continuation', "writeq('\\\n')"],
+          ['#8 leading continuation', "writeq('\\\na')"],
+          ['#9 embedded continuation', "writeq('a\\\nb')"],
+          ['#10 continuation before space', "writeq('a\\\n b')"],
+          ['#13 symbolic tab', String.raw`writeq('\t')`],
+          ['#14 symbolic alert', String.raw`writeq('\a')`],
+          ['#15 octal alert', String.raw`writeq('\7\')`],
+          ['#18 octal escape', String.raw`writeq('\033\')`],
+          ['#301 NUL escape', String.raw`writeq('\0\')`],
+          ['#315 hexadecimal escape', String.raw`writeq('\x21\')`],
+          ['#316 padded hexadecimal escape', String.raw`writeq('\x0021\')`],
+          ['#38 double-quoted meta escapes', "\"\\'\\`\\\"\" = \"'`\"\"\""],
+          ['#39 single-quoted meta escapes', "'\\'\\`\\\"' = '''`\"'"],
+          ['#40 writeq meta escapes', "writeq('\\'\\`\\\"\\\"')"],
+          ['#41 meta backslash escape', String.raw`('\\') = (\)`],
+        ];
+        for (const [label, source] of valid) {
+          try {
+            parseGoalText(source);
+          } catch (error) {
+            throw new Error(`${label} should parse: ${error?.message ?? error}`);
+          }
+        }
+      },
+    },
+    {
+      name: 'stream term input reports malformed quoted layout as syntax_error',
+      run: () => {
+        for (const [label, input] of [
+          ['lone quote', "'\n"],
+          ['literal newline', "writeq('\n').\n"],
+          ['literal tab', "writeq('\t').\n"],
+        ]) {
+          let error = null;
+          try {
+            runEyeProlog('', { goal: 'read(X)', ioOptions: { input } });
+          } catch (caught) {
+            error = caught;
+          }
+          assertEqual(error?.message, 'error(syntax_error(read_term))', `${label} read error`);
+        }
+      },
+    },
+    {
+      name: 'writeq uses ISO numeric escapes for non-symbolic control characters',
+      run: () => {
+        const result = runCli([], {
+          input: "writeq('\\033\\').\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, "?- '\\33\\'   true.\n?- ", 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL read predicates consume following interactive term input',
       run: () => {
@@ -719,6 +840,53 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL term input is on demand in conjunctions and Ctrl-D does not exit the top level',
+      run: () => {
+        if (process.platform === 'win32') return;
+        const available = spawnSync('sh', ['-c',
+          'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
+        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'; } | ` +
+          `script -qefc ${shellQuote(command)} /dev/null`;
+        const result = spawnSync('sh', ['-c', scriptCommand], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+          timeout: 5000,
+        });
+        assertEqual(result.error?.code, undefined, 'interactive read timeout');
+        assertEqual(result.status, 0, 'exit status');
+        assertIncludes(result.stdout, 'X = foo, Y = bar.', 'conjunction reads');
+        assertIncludes(result.stdout, 'Z = end_of_file.', 'Ctrl-D read result');
+        assertIncludes(result.stdout, '?- true.', 'top level resumes after Ctrl-D');
+        assertIncludes(result.stdout, '   true.', 'post-EOF query executes');
+      },
+    },
+    {
+      name: 'interactive user_input hook serves reads reached through user predicates',
+      run: () => {
+        const program = Program.parse('pair(A, B) :- read(A), read(B).\n');
+        const solver = new Solver(program, { registry: getEyePrologRegistry() });
+        const stream = solver.io.resolve('user_input');
+        const pending = ['left.\n', 'right.\n'];
+        let requests = 0;
+        stream.interactiveReadTerm = () => {
+          requests++;
+          return pending.shift() ?? null;
+        };
+        const goal = parseGoalText('pair(X, Y)');
+        const answers = [...solver.solve([goal], new Env(), 0)];
+        assertEqual(answers.length, 1, 'answer count');
+        assertEqual(termToString(copyResolved(goal.args[0], answers[0])), 'left', 'first read');
+        assertEqual(termToString(copyResolved(goal.args[1], answers[0])), 'right', 'second read');
+        assertEqual(requests, 2, 'on-demand read count');
+      },
+    },
     {
       name: 'REPL releases terminal signals while a query computes',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5276,17 +5276,27 @@ city('München').
 message("café").
 ```
 
-Inside a quoted atom, a single quote is doubled: `'don''t'`. Quoted characters
-support the ISO symbolic control escapes such as `\a`, `\n`, and `\t`, and numeric
-octal or hexadecimal escapes are terminated by a backslash; for example, `'\7\'`
-and `'\x7\'` both denote the alert character. The NUL character, when present in
-the processor character set, is written readably as `'\0\'`; digits `8` and `9`
-are not octal digits, so forms such as `'\8\'` are syntax errors rather than
-continuation input. Double-quoted lists use the same
-quoted-character escapes. Whitespace is insignificant
-between tokens, and a `%` 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.
+Inside a quoted atom, a single quote is doubled: `'don''t'`. EyeProlog follows
+the ISO quoted-character grammar rather than accepting arbitrary backslash
+escapes. The symbolic control escapes are `\a`, `\b`, `\r`, `\f`, `\t`,
+`\n`, and `\v`; the meta characters backslash, single quote, double quote, and
+back quote may be escaped after a backslash; and numeric octal or hexadecimal
+escapes are terminated by a backslash. For example, `'\7\'` and `'\x7\'`
+both denote the alert character. Forms such as `\c`, `\d`, `\e`, `\u`, `\.`
+and `\ ` are not ISO quoted-character escapes and are syntax errors.
+
+A literal layout character other than ordinary space is not a quoted
+character. In particular, a literal tab or newline inside quotes is a syntax
+error. A quoted token can cross a line boundary only through a continuation
+escape: a backslash immediately followed by the newline, which contributes no
+character to the atom. The NUL character is written readably as `'\0\'`;
+digits `8` and `9` are not octal digits, so forms such as `'\8\'` are syntax
+errors. `writeq/1` uses octal escapes for other non-symbolic control characters,
+for example ESC is written as `'\33\'`. Double-quoted lists use the same
+quoted-character rules. Whitespace is insignificant between tokens, and a `%`
+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
@@ -6228,21 +6238,27 @@ 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
 consult local source, and `halt.` or `halt(Status).` to leave the top level.
-A direct top-level `read/1-2` or `read_term/2-3` from `user_input` requests the
-next full-stop-terminated Prolog term with a `|: ` input prompt instead of
-treating the interactive input stream as already exhausted. For example:
+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
+with a `|: ` input prompt instead of treating the terminal stream as already
+exhausted. The request is made at execution time, so multiple reads in one goal
+and reads reached through user predicates work independently. For example:
 
 ```text
-?- read(X).
+?- read(X), read(Y).
 |: hello.
-   X = hello.
+|: world.
+   X = hello, Y = world.
 ```
 
-The top-level prompt itself is a host-interface convention rather than part of
-ISO/IEC 13211-1; the term that follows it is parsed by the same ISO term-input
-machinery as `read/1-2` and `read_term/2-3` on other text streams. Up and Down
-recall queries from the current session. Explicit `eyeprolog -h` displays
-command-line help.
+Typing `Ctrl-D` at an empty `|: ` prompt makes that Prolog read return
+`end_of_file`; it does not close the surrounding EyeProlog top-level loop, so a
+new `?- ` query can still be entered afterwards. The top-level prompts and this
+terminal EOF convention are host-interface behavior rather than part of
+ISO/IEC 13211-1; terms supplied to the reads are parsed by the same ISO
+term-input machinery as `read/1-2` and `read_term/2-3` on other text streams.
+Up and Down recall queries from the current session. Explicit `eyeprolog -h`
+displays command-line help.
 
 ### Selecting goals
 
@@ -6953,7 +6969,7 @@ precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 783 cases, including 377 focused ISO
+contains 789 cases, including 383 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal