eyeprolog 1.2.0 → 1.2.2

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.0",
+  "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/src/parser.js

@@ -663,8 +663,7 @@ class Parser {
     }
     return this.source[start] === ' ' || this.source[start] === '\t';
   }
-  parseQuad(id, line, accept) {
-    const query = this.parseTerm(0, true);
+  parseQuadAnswers(id, query, line, accept) {
     this.expect(TOK.DOT, '.');
     this.advance();
 
@@ -684,28 +683,38 @@ class Parser {
       source: { filename: this.filename, line },
     });
   }
+  parseQuad(id, line, accept) {
+    const query = this.parseTerm(0, true);
+    this.parseQuadAnswers(id, query, line, accept);
+  }
+  parseQuadTerm(term, line, accept) {
+    if (term.type !== COMPOUND || term.name !== '?-' || ![1, 2].includes(term.arity)) return false;
+    const id = term.arity === 2 ? term.args[0] : null;
+    const query = term.args[term.arity - 1];
+    this.parseQuadAnswers(id, query, line, accept);
+    return true;
+  }
   parseProgram(emit = null) {
     const clauses = emit ? null : [];
     let clauseNumber = 0;
     const accept = emit ?? ((clause) => clauses.push(clause));
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
-      if (this.operatorTokenName() === '?-') {
-        if (this.strictIso) {
-          // In Part 1, ?- is the predefined 1200 fx operator.  A strict-core
-          // source therefore reads it as an ordinary term rather than giving
-          // it EyeProlog's top-level quad meaning.
-          const head = this.parseTerm(0, true);
-          this.expect(TOK.DOT, '.');
+      // In the normal EyeProlog profile, canonical functional ?-/1 and
+      // ?-/2 notation denotes the same quad marker as the corresponding
+      // operator notation.  Keep the existing operator-form query parsing so
+      // a query containing comma remains wholly to the right of `?-`, while
+      // functional notation is parsed as a term and then decomposed by arity.
+      if (this.operatorTokenName() === '?-' && !this.strictIso) {
+        if (this.peek() === '(') {
+          const quadTerm = this.parseTerm(0, true);
+          if (!this.parseQuadTerm(quadTerm, line, accept)) {
+            throw new Error(`parse line ${line}: bad quad term`);
+          }
+        } else {
           this.advance();
-          const clause = { head, body: [] };
-          clauseNumber++;
-          if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
-          accept(clause);
-          continue;
+          this.parseQuad(null, line, accept);
         }
-        this.advance();
-        this.parseQuad(null, line, accept);
         continue;
       }
       if (this.token.type === TOK.IF) {
@@ -740,6 +749,13 @@ class Parser {
         continue;
       }
       let head = this.parseTerm(3);
+      // Both a quad label and a TS 13211-3 semicontext may contain an
+      // unparenthesized comma before their priority-1200 operator.  Assemble
+      // that left operand before deciding whether the marker is ?- or -->.
+      if (this.token.type === TOK.COMMA) {
+        this.advance();
+        head = compound(',', [head, this.parseTerm(3)]);
+      }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {
           // There is no predefined infix ?-/2 in strict core mode.  If a
@@ -761,13 +777,6 @@ class Parser {
         this.parseQuad(head, line, accept);
         continue;
       }
-      // ISO/IEC TS 13211-3 grammar rules use -->/2 at the same top-level
-      // priority as clauses.  The left side may include an unparenthesized
-      // semicontext: NonTerminal, Terminals --> Body.
-      if (this.token.type === TOK.COMMA) {
-        this.advance();
-        head = compound(',', [head, this.parseTerm(3)]);
-      }
       if (this.operatorTokenName() === '-->') {
         this.advance();
         const grammarBody = this.parseTerm(0, true);

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

@@ -221,6 +221,43 @@ why(
         assertEqual(program.quads[1].query.args[1].name, '.', 'dot atom');
       },
     },
+    {
+      name: 'quad parser treats operator and functional ?- notation equivalently',
+      run: () => {
+        const labelled = Program.parse(
+          `0,passes
+  ?- X = 1.
+     X = 1.
+`,
+        );
+        assertEqual(labelled.quads.length, 1, 'labelled quad count');
+        assertEqual(labelled.clauses.length, 0, 'labelled quad clause count');
+        assertEqual(labelled.quads[0].id.name, ',', 'comma label functor');
+        assertEqual(labelled.quads[0].query.name, '=', 'labelled quad query');
+        const labelledReport = publicApi.runQuads(labelled);
+        assertEqual(labelledReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'labelled quad report');
+
+        const functional = Program.parse(
+          `?-(','(0,passes),=(X,1)).
+   X = 1.
+`,
+        );
+        assertEqual(functional.quads.length, 1, 'functional quad count');
+        assertEqual(functional.clauses.length, 0, 'functional quad clause count');
+        assertEqual(functional.quads[0].id.name, ',', 'functional comma label functor');
+        assertEqual(functional.quads[0].query.name, '=', 'functional quad query');
+        assertEqual(termToString(functional.quads[0].id), termToString(labelled.quads[0].id),
+          'operator and functional labels are equivalent');
+        assertEqual(termToString(functional.quads[0].query), termToString(labelled.quads[0].query),
+          'operator and functional queries are equivalent');
+        const functionalReport = publicApi.runQuads(functional);
+        assertEqual(functionalReport.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'functional quad report');
+
+        const strict = Program.parse(`?-(','(0,passes),=(X,1)).\n`, { isoStrict: true });
+        assertEqual(strict.quads.length, 0, 'strict mode has no quads');
+        assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
+      },
+    },
     {
       name: 'runQuads checks portable answer descriptions',
       run: () => {
@@ -1169,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

@@ -5146,7 +5146,11 @@ contains `?-` at priority 1200 with specifier `fx`, so
 an optional label before the query marker (`Label ?- Query.`), so while quad
 syntax is supported it additionally exposes `?-` at priority 1200 with
 specifier `xfx` as an implementation-specific operator. Consequently
-`current_op(Priority, Specifier, ?-)` enumerates both definitions.
+`current_op(Priority, Specifier, ?-)` enumerates both definitions. At top level in the normal EyeProlog profile, the quad marker is recognized
+after term parsing, so equivalent syntax stays equivalent: `Label ?- Query.`
+and canonical `?-(Label, Query).` denote the same labelled quad when followed
+by its indented answer descriptions. In `--iso-strict` mode this quad
+interpretation is disabled, and `?-/2` remains ordinary Prolog term syntax.
 
 Run [`iso-dynamic-database.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl)
 for an explicitly stateful queue and
@@ -5747,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.
 
@@ -6361,7 +6367,10 @@ console.log(report.passed, report.failed, report.stdout);
 The syntax follows the “queries using answer descriptions” convention used by
 Trealla and the ISO Prolog working examples. Because answer descriptions are
 layout-sensitive, indent every description while keeping ordinary clause heads
-and the next quad query at the left margin.
+and the next quad query at the left margin. A comma may be part of a quad label,
+including across layout before `?-`. Canonical functional notation is
+semantically equivalent: `?-(Label, Query).` followed by the same indented
+answer descriptions creates the same labelled quad as `Label ?- Query.`.
 
 Statistics are comparative evidence, not a score in isolation. Preserve the
 program, input, runtime version, selected query, answers, and counters together.