eyeprolog 1.2.1 → 1.2.3

package/package.json

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

package/src/iso.js

@@ -1063,16 +1063,36 @@ function isTerminatingFullStop(source, index) {
   return true;
 }
 
+function quotedEscapeEnd(source, index) {
+  const escaped = source[index + 1] ?? '';
+  if (!escaped) return index;
+
+  // 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.
+  if (escaped === 'x') {
+    let cursor = index + 2;
+    while (/^[0-9A-Fa-f]$/.test(source[cursor] ?? '')) cursor++;
+    return source[cursor] === '\\' ? cursor : Math.max(index + 1, cursor - 1);
+  }
+  if (/^[0-7]$/.test(escaped)) {
+    let cursor = index + 1;
+    while (/^[0-7]$/.test(source[cursor] ?? '')) cursor++;
+    return source[cursor] === '\\' ? cursor : Math.max(index + 1, cursor - 1);
+  }
+
+  return index + 1;
+}
+
 function* termTextCandidates(stream) {
   const source = String(stream.content);
-  let quote = null, escaped = false, lineComment = false, blockComment = false;
+  let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
     if (lineComment) { if (ch === '\n') lineComment = false; continue; }
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
-      if (escaped) escaped = false;
-      else if (ch === '\\') escaped = true;
+      if (ch === '\\') i = quotedEscapeEnd(source, i);
       else if (ch === quote && next === quote) i++;
       else if (ch === quote) quote = null;
       continue;
@@ -1087,13 +1107,21 @@ function* termTextCandidates(stream) {
 }
 function convertedTermText(text, solver) {
   if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) return text;
-  let result = '', quote = null, escaped = false;
-  for (const ch of text) {
+  let result = '', quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i], next = text[i + 1];
     if (quote) {
       result += ch;
-      if (escaped) escaped = false;
-      else if (ch === '\\') escaped = true;
-      else if (ch === quote) quote = null;
+      if (ch === '\\') {
+        const end = quotedEscapeEnd(text, i);
+        if (end > i) result += text.slice(i + 1, end + 1);
+        i = end;
+      } else if (ch === quote && next === quote) {
+        result += next;
+        i++;
+      } else if (ch === quote) {
+        quote = null;
+      }
     } else if (ch === "'" || ch === '"') {
       quote = ch;
       result += ch;

package/src/repl.js

@@ -48,6 +48,7 @@ export async function runRepl(engine, options = {}) {
           continue;
         }
 
+        await prepareInteractiveTermInput(state, goal, reader);
         const result = await solveQuery(engine, state, goal, reader, output);
         if (result?.halted) {
           exitCode = result.code;
@@ -166,6 +167,57 @@ async function readQuery(reader) {
   }
 }
 
+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);
+  if (text == null) return;
+  stream.content += text;
+  stream.pastEnd = false;
+}
+
+function interactiveTermInputStream(state, goal) {
+  if (goal.type !== 'compound') return null;
+  let reference = null;
+  if (goal.name === 'read' && goal.arity === 1) {
+    reference = state.solver.io.currentInput;
+  } else if (goal.name === 'read' && goal.arity === 2) {
+    reference = explicitInputReference(goal.args[0]);
+  } else if (goal.name === 'read_term' && goal.arity === 2) {
+    reference = state.solver.io.currentInput;
+  } else if (goal.name === 'read_term' && goal.arity === 3) {
+    reference = explicitInputReference(goal.args[0]);
+  } else {
+    return null;
+  }
+
+  const stream = reference == null ? null : state.solver.io.resolve(reference);
+  return stream?.standard && stream.alias === 'user_input' && stream.mode === 'read' ? stream : null;
+}
+
+function explicitInputReference(term) {
+  if (term.type === 'atom') return term.name;
+  if (term.type === 'compound' && term.name === '$stream' && term.arity === 1 &&
+      term.args[0].type === 'number' && /^\d+$/.test(term.args[0].name)) {
+    return Number(term.args[0].name);
+  }
+  return null;
+}
+
+async function readInteractiveTerm(reader) {
+  let source = '';
+  let prompt = '|: ';
+  while (true) {
+    const line = await reader.read(prompt);
+    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 = '|    ';
+  }
+}
+
 function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;

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

@@ -65,3 +65,23 @@ default_streams(ok) :-
 standard_write(ok) :-
     write(io_marker),
     nl.
+
+%% goal: numeric_escape_term_input(ok)
+
+numeric_escape_term_input(ok) :-
+    open('/tmp/eyeprolog-iso-read-escapes.txt', write, Output, []),
+    put_code(Output, 39), put_code(Output, 92), put_code(Output, 55),
+    put_code(Output, 92), put_code(Output, 39), put_code(Output, 46), nl(Output),
+    put_code(Output, 39), put_code(Output, 92), put_code(Output, 120), put_code(Output, 55),
+    put_code(Output, 92), put_code(Output, 39), put_code(Output, 46), nl(Output),
+    close(Output),
+    current_input(Old),
+    open('/tmp/eyeprolog-iso-read-escapes.txt', read, Input, []),
+    set_input(Input),
+    read(A),
+    read_term(B, []),
+    set_input(Old),
+    close(Input),
+    A == '\a',
+    B == '\a'.
+

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

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

package/test/run-regression.mjs

@@ -671,6 +671,29 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL read predicates consume following interactive term input',
+      run: () => {
+        const result = runCli([], {
+          input:
+            'read(X).\n' +
+            'foo.\n' +
+            'read_term(Y, []).\n' +
+            "'\\7\\'.\n" +
+            'read(user_input, Z).\n' +
+            'bar.\n' +
+            'halt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?- |:    X = foo.\n' +
+          "?- |:    Y = '\\a'.\n" +
+          '?- |:    Z = bar.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL accepts multiline period-terminated queries',
       run: () => {
@@ -1206,6 +1229,44 @@ c4 ?- call((!;1)).
         assertIncludes(result.stderr, 'implementation-specific directive use_module/1', 'stderr');
       },
     },
+    {
+      name: 'term input accepts ISO numeric escapes through read predicates',
+      run: () => {
+        const escapePath = path.join(tmp, `read-escapes-${++tmpCounter}.term`);
+        // Two raw read-terms: '\7\'. and '\x7\'.  Build the file from
+        // character codes so this regression tests stream parsing rather than
+        // the parser which reads this JavaScript fixture.
+        fs.writeFileSync(escapePath, String.fromCharCode(
+          39, 92, 55, 92, 39, 46, 10,
+          39, 92, 120, 55, 92, 39, 46, 10,
+        ));
+        const source = [
+          `read_escapes(A, B) :-`,
+          `  current_input(Old),`,
+          `  open(${sourceAtom(escapePath)}, read, Input, []),`,
+          `  set_input(Input),`,
+          `  read(A),`,
+          `  read_term(B, []),`,
+          `  set_input(Old),`,
+          `  close(Input).`,
+          '',
+        ].join('\n');
+        assertEqual(
+          run(source, { goal: 'read_escapes(A, B)' }).stdout,
+          "read_escapes('\\a', '\\a').\n",
+          'read/1 and read_term/2 numeric escapes',
+        );
+
+        assertEqual(
+          run('answer(T) :- read(T).\n', {
+            goal: 'answer(T)',
+            ioOptions: { input: "'\\7\\'." },
+          }).stdout,
+          "answer('\\a').\n",
+          'read/1 user_input numeric escape',
+        );
+      },
+    },
     {
       name: 'term input keeps dotted operators intact and uses program operators',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5751,9 +5751,11 @@ the beginning. A peek does not mark the stream as past-end.
 | `write_canonical(+Term)`, `write_canonical(+Stream,+Term)` | Writes quoted canonical functor notation while ignoring operators and without interpreting *$VAR/1*. |
 | `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. |
 
-Term input uses the program's current operator table and applies installed
-character conversions outside quoted text when the `char_conversion` flag is
-`on`. `variable_names/1` and `singletons/1` omit anonymous variables. Output
+Term input uses the program's current operator table and the same ISO quoted-character
+syntax as source text, including backslash-terminated octal and hexadecimal
+escapes such as `'\7\'` and `'\x7\'`. This applies equally to `read/1-2` and
+`read_term/2-3`. Installed character conversions are applied outside quoted text
+when the `char_conversion` flag is `on`. `variable_names/1` and `singletons/1` omit anonymous variables. Output
 predicates do not append a period or newline; call `write/1`, then `write('.')`
 and `nl/0` when emitting a complete source term manually.
 
@@ -6214,8 +6216,21 @@ 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.
-Up and Down recall queries from the current session. Explicit `eyeprolog -h`
-displays command-line help.
+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:
+
+```text
+?- read(X).
+|: hello.
+   X = hello.
+```
+
+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.
 
 ### Selecting goals