eyeprolog 1.2.19 → 1.2.21

package/package.json

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

package/src/parser.js

@@ -436,7 +436,16 @@ class Parser {
         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 });
+        if (value === "'") {
+          // In the single-quoted-character notation used after 0', an
+          // apostrophe is doubled just as it is inside a quoted atom. Thus
+          // 0''' is one numeric token denoting character code 39, while the
+          // undoubled 0'' is not a complete single quoted character.
+          if (this.peek() !== "'") throw new Error(`parse line ${line}: bad character code constant`);
+          this.take();
+        } else 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

@@ -488,8 +488,15 @@ async function solveQuery(engine, state, goal, reader, output) {
   let automatic = 0;
   let answersShown = 0;
   let firstAnswer = true;
+  let formattingAfterAdvance = false;
   while (!current.result.done) {
     const next = pullSolution(solver, solutions, reader);
+    // The control prompt has no trailing space while it waits for input. The
+    // first space appears as soon as the user requests another solution and
+    // remains visible while pullSolution() computes; the second appears only
+    // when the requested leaf answer is ready to format.
+    if (formattingAfterAdvance) output.write(' ');
+    formattingAfterAdvance = false;
     output.write(current.output);
     output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
     answersShown++;
@@ -501,14 +508,15 @@ async function solveQuery(engine, state, goal, reader, output) {
 
     if (automatic > 0 || automatic === Infinity) {
       if (automatic !== Infinity) automatic--;
-      output.write('\n;  ');
+      output.write('\n; ');
+      formattingAfterAdvance = true;
     } else {
       while (true) {
-        const controlLine = await reader.readControl('\n;  ');
+        const controlLine = await reader.readControl('\n;');
         if (controlLine == null || controlLine === '' || controlLine === '\r' || controlLine === '\n' ||
             controlLine.trimStart().startsWith('.')) {
           if (typeof solutions.return === 'function') solutions.return();
-          output.write('... .\n');
+          output.write('  ... .\n');
           return null;
         }
         const control = controlLine === ' ' ? ' ' : controlLine.trimStart()[0];
@@ -527,18 +535,22 @@ async function solveQuery(engine, state, goal, reader, output) {
           break;
         }
         if (control === 'w' || control === 'p') {
-          output.write(`${formatAnswer(engine, state, variables, current.result.value)}`);
+          output.write(`  ${formatAnswer(engine, state, variables, current.result.value)}`);
           continue;
         }
         if (control === 'h') {
           output.write(ANSWER_HELP);
           continue;
         }
-        output.write('Action? ');
+        output.write(' Action? ');
       }
+      output.write(' ');
+      formattingAfterAdvance = true;
     }
 
     if (next.error) {
+      if (formattingAfterAdvance) output.write(' ');
+      formattingAfterAdvance = false;
       output.write(next.output);
       if (next.error?.name === 'HaltSignal') return { halted: true, code: next.error.code };
       throw next.error;

package/test/run-regression.mjs

@@ -538,6 +538,35 @@ c4 ?- call((!;1)).
         }
       },
     },
+    {
+      name: 'apostrophe character-code constants parse in source and number conversion',
+      run: () => {
+        const source = String.raw`
+?- N = 0'''.
+   N = 39.
+?- number_chars(N,"0'''").
+   N = 39.
+?- number_chars(N,"0'\\'").
+   N = 39.
+?- number_codes(N,[48,39,39,39]).
+   N = 39.
+`;
+        const result = publicApi.runQuads(source);
+        assertEqual(result.total, 4, 'quad total');
+        assertEqual(result.passed, 4, 'quad passed');
+        assertEqual(result.stdout, 'quads: 4 run, 4 passed, 0 failed.\n', 'quad report');
+
+        for (const goal of ["N = 0''", 'number_chars(N,"0\'\'")']) {
+          let caught = null;
+          try {
+            publicApi.run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          if (caught == null) throw new Error(`${goal} should reject an undoubled apostrophe`);
+        }
+      },
+    },
     {
       name: 'number conversion rejects parenthesized numeric terms',
       run: () => {
@@ -790,6 +819,61 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL answer prompt distinguishes waiting from computation',
+      run: () => {
+        const helper = `
+          import { spawn } from 'node:child_process';
+
+          const child = spawn(${JSON.stringify(process.execPath)}, [${JSON.stringify(bin)}], {
+            cwd: ${JSON.stringify(packageRoot)},
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          child.stdout.setEncoding('utf8');
+          child.stderr.setEncoding('utf8');
+          let stdout = '';
+          let stderr = '';
+          let sawComputingPrompt = false;
+          child.stdout.on('data', (text) => {
+            stdout += text;
+            if (stdout.endsWith('\\n; ')) sawComputingPrompt = true;
+          });
+          child.stderr.on('data', (text) => { stderr += text; });
+
+          async function waitFor(predicate, label) {
+            const deadline = Date.now() + 5000;
+            while (!predicate()) {
+              if (Date.now() >= deadline) {
+                throw new Error(label + ' timeout; stdout=' + JSON.stringify(stdout) + '; stderr=' + JSON.stringify(stderr));
+              }
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+          }
+
+          child.stdin.write('use_module(library(prologue)).\\n');
+          await waitFor(() => stdout.includes('   true.\\n?- '), 'module import');
+          child.stdin.write('(N = 0; N = 1; (call_nth(repeat, 100000), N = 2)).\\n');
+          await waitFor(() => stdout.endsWith('   N = 0\\n;'), 'waiting prompt');
+          child.stdin.write(';\\n');
+          await waitFor(() => sawComputingPrompt, 'computing prompt');
+          await waitFor(() => stdout.endsWith(';  N = 1\\n;'), 'formatted answer');
+          child.stdin.write('\\n');
+          await waitFor(() => stdout.endsWith('  ... .\\n?- '), 'stopped enumeration');
+          child.stdin.write('halt.\\n');
+          const status = await new Promise((resolve) => child.once('exit', resolve));
+          if (status !== 0) throw new Error('child status ' + status + '; stderr=' + stderr);
+          process.stdout.write('waiting;computing;formatting');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--input-type=module',
+          '--eval',
+          helper,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 10000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `prompt helper status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'waiting;computing;formatting', 'prompt state sequence');
+      },
+    },
     {
       name: 'REPL f stops at five-answer boundaries instead of adding five answers',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5776,8 +5776,9 @@ minus token and the following numeric token. A single-line `%...` comment may
 therefore follow `-` directly because `%` cannot continue a graphic token; an
 adjacent bracketed comment in `-/**/1` remains a syntax error under the eager
 token-consumer rule. Decimal fractions and decimal exponents are supported;
-trailing material and non-finite values are rejected. The regression gate
-vendors all 74 numbered cases from Ulrich Neumerkel's contemporary
+the apostrophe character code is written with a doubled apostrophe as `0'''`
+and has value 39. Trailing material and non-finite values are rejected. The
+regression gate vendors all 74 numbered cases from Ulrich Neumerkel's contemporary
 `number_chars/2` comparison, including the Cor.2 error-precedence cases;
 `number_codes/2` shares the same numeric parser and has mirrored coverage for
 the recent numeric-syntax regressions.
@@ -6284,7 +6285,9 @@ When another answer exists in an interactive terminal, press `;`, Space, or
 enumeration, `a` enumerates all remaining answers, and `f` advances to the
 next five-answer boundary (5, 10, 15, ... displayed leaf answers), regardless
 of how many answers were stepped through individually beforehand. `h` displays
-the answer-control help. While a query is actively
+the answer-control help. The answer prompt is `;` with no trailing space while
+it waits for input; after an advance command, one space marks active search and
+a second marks an answer ready for formatting. While a query is actively
 computing, EyeProlog releases readline's terminal signal handling: `Ctrl-C`
 therefore terminates the current EyeProlog process immediately, and on POSIX
 terminals `Ctrl-Z` suspends it in the usual shell-managed way. This remains a