eyeprolog 1.2.1 → 1.2.2

package/package.json

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

@@ -1206,6 +1206,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.