eyeprolog 1.1.27 → 1.1.29

package/package.json

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

package/src/iso.js

@@ -1783,7 +1783,7 @@ function* phraseBuiltin({ solver, goal, env }) {
     solver.absorbStatsFrom(child);
   }
 }
-function formalErrorTerm(error) {
+export function formalErrorTerm(error) {
   const context = error.contextTerm ?? atom('eyeprolog');
   if (error.formalTerm != null) return compound('error', [error.formalTerm, context]);
   const parse = (text) => {

package/src/repl.js

@@ -2,6 +2,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
+import { formalErrorTerm } from './iso.js';
 
 const ANSWER_HELP = `
 SPACE, "n" or ";": next solution, if any
@@ -163,11 +164,33 @@ async function readQuery(reader) {
   }
 }
 
+function quotedEscapeEnd(source, index) {
+  const escaped = source[index + 1] ?? '';
+  if (!escaped) return index;
+
+  // 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.
+  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);
+  }
+
+  // Meta escapes, symbolic control escapes, and continuation escapes consume
+  // one character after the backslash.  The parser performs validity checks.
+  return index + 1;
+}
+
 function terminalFullStop(source) {
   let quote = null;
   let lineComment = false;
   let blockComment = false;
-  let escaped = false;
   let depth = 0;
 
   for (let i = 0; i < source.length; i++) {
@@ -185,10 +208,8 @@ function terminalFullStop(source) {
       continue;
     }
     if (quote != null) {
-      if (escaped) {
-        escaped = false;
-      } else if (ch === '\\') {
-        escaped = true;
+      if (ch === '\\') {
+        i = quotedEscapeEnd(source, i);
       } else if (ch === quote) {
         if (next === quote) i++;
         else quote = null;
@@ -425,46 +446,17 @@ function formatError(engine, state, error) {
     const env = new engine.Env();
     const variableNames = new Map();
     let generated = 0;
-    if (error.formalTerm != null) {
-      collectUnboundVariables(engine, error.formalTerm, env, variableNames, () => `_${letterName(generated++)}`);
-      if (error.contextTerm != null) {
-        collectUnboundVariables(engine, error.contextTerm, env, variableNames, () => `_${letterName(generated++)}`);
-      }
-      const formal = engine.formatTermForWrite(error.formalTerm, env, {
-        quoted: true,
-        operators: [...state.program.operators.values()],
-        variableNames,
-      });
-      if (error.contextTerm != null) {
-        const context = engine.formatTermForWrite(error.contextTerm, env, {
-          quoted: true,
-          operators: [...state.program.operators.values()],
-          variableNames,
-        });
-        return `error(${formal}, ${context}).`;
-      }
-      return `error(${formal}).`;
-    }
-    if (error.culprit != null) {
-      collectUnboundVariables(engine, error.culprit, env, variableNames, () => `_${letterName(generated++)}`);
-    }
-    if (error.contextTerm != null) {
-      collectUnboundVariables(engine, error.contextTerm, env, variableNames, () => `_${letterName(generated++)}`);
-    }
-    const culprit = error.culprit == null ? '' : `, ${engine.formatTermForWrite(error.culprit, env, {
+    // ISO 7.12.1 represents processor errors as error(ErrorTerm, ImpDef).
+    // Reuse the same conversion as catch/3 so uncaught errors at the top
+    // level cannot lose the implementation-defined context or misplace a
+    // culprit as the second argument of error/2.
+    const term = formalErrorTerm(error);
+    collectUnboundVariables(engine, term, env, variableNames, () => `_${letterName(generated++)}`);
+    return `${engine.formatTermForWrite(term, env, {
       quoted: true,
       operators: [...state.program.operators.values()],
       variableNames,
-    })}`;
-    if (error.contextTerm != null) {
-      const context = engine.formatTermForWrite(error.contextTerm, env, {
-        quoted: true,
-        operators: [...state.program.operators.values()],
-        variableNames,
-      });
-      return `error(${error.formal}${culprit}, ${context}).`;
-    }
-    return `error(${error.formal}${culprit}).`;
+    })}.`;
   }
   const message = error?.message ?? String(error);
   return message.endsWith('.') ? message : `${message}.`;

package/src/write.js

@@ -22,8 +22,13 @@ function quoteAtom(name) {
   for (const ch of name) {
     if (ch === "'") out += "''";
     else if (ch === '\\') out += '\\\\';
-    else if (ch === '\n') out += '\\n';
+    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;
   }
   return out + "'";

package/test/run-regression.mjs

@@ -533,8 +533,23 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    error(type_error(list), [1, [], _A | 2]).\n' +
-          '?-    error(type_error(list), [1, [], _A | 2]).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), eyeprolog).\n' +
+          '?-    error(type_error(list, [1, [], _A | 2]), eyeprolog).\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL uncaught ISO errors retain the error/2 implementation context',
+      run: () => {
+        const result = runCli([], {
+          input: '_ is _.\ncatch(_ is _, error(Error, Imp_def), true).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    error(instantiation_error, eyeprolog).\n' +
+          '?-    Error = instantiation_error, Imp_def = eyeprolog.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -602,6 +617,22 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL recognizes ISO octal and hexadecimal escapes in quoted atoms',
+      run: () => {
+        const result = runCli([], {
+          input: "writeq('\\7\\').\nwriteq('\\x7\\').\nwriteq('\\a').\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          "?- '\\a'   true.\n" +
+          "?- '\\a'   true.\n" +
+          "?- '\\a'   true.\n" +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL accepts multiline period-terminated queries',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5268,8 +5268,11 @@ city('München').
 message("café").
 ```
 
-Inside a quoted atom, a single quote is doubled: `'don''t'`. Double-quoted lists support
-the common escapes `\n`, `\t`, `\"`, and `\\`. Whitespace is insignificant
+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. 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.
@@ -5803,11 +5806,14 @@ instances whose message contains the corresponding Prolog error term.
 `error(Formal,eyeprolog)` term. `throw/1` copies its ball before unwinding: bound
 parts are preserved, repeated variables remain shared within the copied ball,
 and unbound variables are fresh with respect to the protected goal and catcher.
-Catchable error terms follow the same variable-freshening rule. At the interactive
-top level, variables that occur in an uncaught ISO error are rendered with fresh
-answer names such as `_A` rather than reusing query-variable spellings such as
-`X` or `Xx`; this keeps the displayed error consistent with the copied exception
-term. An unmatched ball or error continues outward.
+Catchable error terms follow the same variable-freshening rule. The interactive
+top level uses the same ISO error envelope for uncaught processor errors, so an
+ordinary runtime error is displayed as `error(Formal,eyeprolog)` rather than
+dropping the implementation-defined second argument. Variables that occur in an
+uncaught ISO error are rendered with fresh answer names such as `_A` rather than
+reusing query-variable spellings such as `X` or `Xx`; this keeps the displayed
+error consistent with the copied exception term. An unmatched ball or error
+continues outward.
 
 Streams belong to one solver run and are shared by nested calls, exceptions,
 and solution collectors. `user_input` and `user_output` are always present.