eyeprolog 1.2.24 → 1.2.26

package/src/repl.js

@@ -4,6 +4,7 @@ import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { formalErrorTerm } from './iso.js';
+import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
 
 const ANSWER_HELP = `
 SPACE, "n" or ";": next solution, if any
@@ -344,38 +345,6 @@ async function readInteractiveTerm(reader) {
   }
 }
 
-function quotedEscapeEnd(source, index) {
-  const escaped = source[index + 1] ?? '';
-  if (!escaped) return index;
-
-  // A backslash-newline pair is a continuation escape (6.4.2), so the
-  // newline is not a literal quoted character. Accept CRLF as the host text
-  // representation of the same continuation boundary.
-  if (escaped === '\n') return index + 1;
-  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
-
-  // 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-9]$/.test(escaped)) {
-    let cursor = index + 1;
-    // Scan all decimal digits here, including 8 and 9.  This scanner only
-    // locates the end of a candidate quoted escape; the parser remains
-    // authoritative and rejects non-octal digits.
-    while (/^[0-9]$/.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;
@@ -411,6 +380,11 @@ function terminalFullStop(source) {
       }
       continue;
     }
+    const characterCodeEnd = characterCodeConstantEnd(source, i);
+    if (characterCodeEnd != null) {
+      i = characterCodeEnd;
+      continue;
+    }
     if (ch === '%') {
       lineComment = true;
       continue;
@@ -636,6 +610,10 @@ function formatAnswer(engine, state, variables, env) {
       operators,
       variableNames: names,
       maxPriority: valueMaxPriority,
+      // A binding value is the right-hand `arg` of =/2.  ISO 6.3.3.1 permits
+      // current operator atoms in argument and list-element positions without
+      // quotes, just as writeq/1 already prints them.
+      operatorAtomsAsArgs: true,
     })}`);
   }
   return bindings.length === 0 ? 'true' : bindings.join(', ');

package/src/syntax-scan.js

@@ -0,0 +1,54 @@
+// Lightweight lexical helpers shared by the interactive and ISO stream
+// readers. These locate token boundaries only; parser.js remains responsible
+// for accepting or rejecting the token itself.
+
+export function quotedEscapeEnd(source, index) {
+  const escaped = source[index + 1] ?? '';
+  if (!escaped) return index;
+
+  if (escaped === '\n') return index + 1;
+  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
+
+  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-9]$/.test(escaped)) {
+    let cursor = index + 1;
+    // Include 8 and 9 while finding the boundary. The parser rejects them as
+    // non-octal rather than letting the reader split the malformed token.
+    while (/^[0-9]$/.test(source[cursor] ?? '')) cursor++;
+    return source[cursor] === '\\' ? cursor : Math.max(index + 1, cursor - 1);
+  }
+
+  return index + 1;
+}
+
+export function characterCodeConstantEnd(source, apostropheIndex) {
+  if (source[apostropheIndex] !== "'" || source[apostropheIndex - 1] !== '0') return null;
+  // The 0 must begin a numeric token. In particular, do not reinterpret the
+  // apostrophe in an identifier such as a0'x as character-code notation.
+  if (/[A-Za-z0-9_]/.test(source[apostropheIndex - 2] ?? '')) return null;
+
+  const characterIndex = apostropheIndex + 1;
+  const character = source[characterIndex] ?? '';
+  if (!character) return apostropheIndex;
+  // `0''` is two tokens (0 and the empty atom), and `0'\\\n...'
+  // likewise starts a quoted atom containing a continuation. Only `0'''`
+  // denotes the character-code constant for an apostrophe.
+  if (character === "'" && source[characterIndex + 1] !== "'") return null;
+  if (character === '\\' && ['\n', '\r'].includes(source[characterIndex + 1])) return null;
+  if (character === '\\') return quotedEscapeEnd(source, characterIndex);
+
+  // An apostrophe character is doubled in 0''' exactly as it is in a quoted
+  // atom. Consume both so neither one opens a quoted-token scan state.
+  if (character === "'" && source[characterIndex + 1] === "'") return characterIndex + 1;
+
+  const firstCode = character.charCodeAt(0);
+  if (firstCode >= 0xd800 && firstCode <= 0xdbff) {
+    const secondCode = source.charCodeAt(characterIndex + 1);
+    if (secondCode >= 0xdc00 && secondCode <= 0xdfff) return characterIndex + 1;
+  }
+  return characterIndex;
+}

package/src/write.js

@@ -28,6 +28,7 @@ function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
   if (name === '...') return false;
+  if (name.startsWith('/*')) return true;
   if (name === '\\+' || name === '+' || name === '-' || name === '\\') return true;
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;
@@ -104,6 +105,7 @@ function writeNumberedVariable(index) {
 }
 
 function operatorName(name) {
+  if (name === '.' || name.startsWith('/*')) return quoteAtom(name);
   if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return name;
   if (/^[!#$&*+\-./<=>@^~\\;:]+$/.test(name)) return name;
   return quoteAtom(name);
@@ -142,6 +144,12 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
     // `arg` production: an atom that is a current operator is valid there
     // without quoting. Keep lexical exceptions such as `|` quoted.
     if (options.operatorAtomsAsArgs && context === 'argument' && table.has(resolved.name)) return operatorName(resolved.name);
+    if (!options.ignoreOps && context !== 'argument' && table.has(resolved.name)) {
+      const definitions = table.get(resolved.name);
+      const requiresParentheses = definitions.some(({ specifier }) =>
+        ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(specifier));
+      if (requiresParentheses) return `(${operatorName(resolved.name)})`;
+    }
     return writeAtom(resolved.name);
   }
   if (resolved.type === NUMBER) return resolved.name;
@@ -186,11 +194,20 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         const argumentPriority = specifier === 'fx' ? priority - 1 : priority;
         text = `${token} ${format(resolved.args[0], env, options, table, argumentPriority)}`;
       } else if (specifier === 'xf' || specifier === 'yf') {
-        const argumentPriority = specifier === 'xf' ? priority - 1 : priority;
+        let argumentPriority = specifier === 'xf' ? priority - 1 : priority;
+        const childDefinition = chooseOperator(deref(resolved.args[0], env), table);
+        if (childDefinition?.priority === priority &&
+            ['fx', 'fy', 'xfx', 'xfy', 'yfx'].includes(childDefinition.specifier)) {
+          argumentPriority = priority - 1;
+        }
         text = `${format(resolved.args[0], env, options, table, argumentPriority)} ${token}`;
       } else {
-        const leftPriority = specifier === 'yfx' ? priority : priority - 1;
+        let leftPriority = specifier === 'yfx' ? priority : priority - 1;
         const rightPriority = specifier === 'xfy' ? priority : priority - 1;
+        const leftDefinition = chooseOperator(deref(resolved.args[0], env), table);
+        if (leftDefinition?.priority === priority && ['fx', 'fy'].includes(leftDefinition.specifier)) {
+          leftPriority = priority - 1;
+        }
         const left = format(resolved.args[0], env, options, table, leftPriority);
         const right = format(resolved.args[1], env, options, table, rightPriority);
         text = resolved.name === ',' ? `${left}, ${right}`

package/test/conformance/ISO-COMPLIANCE.md

@@ -18,7 +18,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
-| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the selected WG17 high-risk syntax case. Complete character-by-character external syntax sweep remains open. |
+| 5.1(a) prepare conforming Prolog text | audit | Clause 6 parser/tokenizer coverage, directive coverage, syntax-error corpus, and the [complete 366-case WG17 syntax matrix](WG17-SYNTAX-STATUS.md). Wider shall-by-shall text-processing audit remains open. |
 | 5.1(b) execute conforming Prolog goals | audit | Clause 7-9 conformance corpus plus regression/API/example gates. A normative goal-semantics ledger is still being expanded. |
 | 5.1(c) reject nonconforming text/read-terms | audit | Dedicated syntax-error cases and strict-core extension rejection. Exhaustive lexical rejection coverage remains open. |
 | 5.1(d) document permitted variations | audit | Major implementation-defined choices are documented in *The Art of EyeProlog*. Every occurrence of “implementation defined/dependent/specific” in Part 1 still needs a final documentation cross-check. |
@@ -30,7 +30,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, quoted-layout/escape error cases, writer/read-back regressions. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete 366-case WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, and writer/read-back regressions. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. Public/private and multi-text requirements still need complete mapping. |
@@ -75,6 +75,7 @@ A release intended to advance ISO conformance must pass all of:
 npm test
 npm run test:iso-strict
 npm run test:conformance
+npm run test:wg17-syntax
 ```
 
 The unified `npm test` gate includes the strict-core suite. Expected conformance
@@ -88,9 +89,9 @@ ISO/IEC 13211-1 processor” until all of the following are true:
 1. every normative Part 1 processor requirement is represented in this ledger;
 2. every `audit` row above has been reduced to explicit pass/not-applicable or
    documented implementation-defined choices;
-3. the complete external WG17 syntax/conversion/variable-name conformity
-   corpus has been run against the strict core mode, with every difference
-   explained or fixed;
+3. the external WG17 conversion and variable-name conformity corpora have
+   joined the now-complete syntax corpus in strict core mode, with every
+   difference explained or fixed;
 4. prescribed modes, errors, side effects, and relevant error precedence for
    every Part 1 built-in have executable coverage;
 5. every implementation-defined/dependent/specific choice required to be

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -0,0 +1,42 @@
+# WG17 syntax traceability status
+
+Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)  
+Upstream inventory checked: 2026-08-15
+
+This ledger counts an upstream case only when its WG17 identifier, query,
+expected ISO disposition, and observed EyeProlog outcome are stored in the
+offline executable matrix. Semantically similar parser tests are not inferred
+as coverage.
+
+## Current standing
+
+| Measure | Count |
+| --- | ---: |
+| Active upstream cases | 366 |
+| Executable EyeProlog dispositions | 366 (100.0%) |
+| Not yet traced one-by-one | 0 |
+| Deleted upstream identifiers | #20, #273 |
+
+The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
+three upstream `waits` cases are checked through EyeProlog's interactive input
+hook; the other 363 cases are checked for their exact stored
+success output, bindings, failure, or ISO error category.
+
+## Traceable evidence
+
+| Executable evidence | Referenced IDs | WG17 cases |
+| --- | ---: | --- |
+| [complete offline executable matrix](../run-wg17-syntax.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
+
+The evidence groups overlap. Their union is **366** active cases:
+#1–#19, #21–#272, #274–#368.
+
+## Untraced upstream identifiers
+
+None.
+
+## Maintenance
+
+1. Refresh the dated fixture when the upstream table changes.
+2. Review any changed ISO expectation before updating an observed snapshot.
+3. Keep this generated status page synchronized in the release gate.

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

@@ -1,6 +1,6 @@
 % High-risk ISO syntax/write regressions, independently derived from
 % ISO/IEC 13211-1 clauses 6.3, 6.4 and 7.10 and cross-checked against the
-% public WG17 conformity-testing syntax cases (#1, #7-10, #14-15, #18, #28-31, #33-34, #301, #315-316).
+% public WG17 conformity-testing syntax cases (#1, #7-10, #14-15, #18, #28-31, #33-34, #299, #301, #315-316).
 
 %% goal: wg17_numeric_escape
 wg17_numeric_escape :-
@@ -21,6 +21,10 @@ wg17_operator_precedence :-
     writeq(a*(b+c)), nl,
     writeq((a :- b,c)), nl.
 
+%% goal: wg17_spaced_prefix_operator(T)
+wg17_spaced_prefix_operator(T) :-
+    (\+ (a,b)) = \+(T).
+
 %% goal: wg17_canonical_list
 wg17_canonical_list :-
     write_canonical([a]), nl.

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

@@ -9,6 +9,7 @@ wg17_operator_arguments.
 a * (b + c)
 a :- b, c
 wg17_operator_precedence.
+wg17_spaced_prefix_operator((a, b)).
 '.'(a,[])
 wg17_canonical_list.
 '\0\'