eyeprolog 1.2.10 → 1.2.12

package/README.md

@@ -79,6 +79,11 @@ member_test ?- member(X, [prolog, logic]).
 ;  X = logic.
 ```
 
+A label may contain several comma-separated metadata fields. When a query has
+multiple indented answer descriptions, each description is checked and counted
+independently, so one failed expectation does not prevent the later ones from
+running.
+
 ## Strict ISO/IEC 13211-1 core
 
 For portability and conformance work, run the Part 1 core with Technical

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 167 | 216 | 0 | 0 | 383 |
+| iso | 167 | 218 | 0 | 0 | 385 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **482** | **267** | **19** | **21** | **789** |
+| **Total** | **482** | **269** | **19** | **21** | **791** |

package/package.json

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

package/src/iso.js

@@ -1564,6 +1564,13 @@ function parseIsoNumber(text) {
   }
 
   const numericText = `${sign}${text.slice(position)}`;
+  // 8.16.7/8.16.8 parse the character sequence according to the syntax rules
+  // for numbers and negative numbers (6.3.1.1/6.3.1.2), not as an arbitrary
+  // term whose value happens to be numeric. Every such number starts with a
+  // decimal digit after an optional negative sign, so parenthesized terms such
+  // as `(0)` or `-(0)` must be rejected before the general term parser sees
+  // them. This keeps the parser reuse below from admitting grouping syntax.
+  if (!/^-?\d/.test(numericText)) return null;
   // ISO floating-point syntax requires a decimal fraction before an exponent.
   if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
   try {

package/src/parser.js

@@ -795,12 +795,28 @@ 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 -->.
+      // Both a quad label and a TS 13211-3 semicontext may contain one or more
+      // unparenthesized commas before their priority-1200 operator.  Parse the
+      // complete comma sequence here instead of stopping after one separator;
+      // portable quad labels commonly carry several metadata fields, e.g.
+      // `9, "case", passes ?- Goal.`.  Build the standard right-associative
+      // comma term so this is the same label as `(9, "case", passes)`.
       if (this.token.type === TOK.COMMA) {
-        this.advance();
-        head = compound(',', [head, this.parseTerm(3)]);
+        const items = [head];
+        let extraCommaLine = null;
+        while (this.token.type === TOK.COMMA) {
+          if (items.length >= 2 && extraCommaLine == null) extraCommaLine = this.token.line;
+          this.advance();
+          items.push(this.parseTerm(3));
+        }
+        // Historically the program grammar admitted exactly one comma in a
+        // DCG semicontext.  Keep that boundary: the broader comma sequence is
+        // specifically the quad-label extension, not a new DCG syntax.
+        if (extraCommaLine != null && this.operatorTokenName() !== '?-') {
+          throw new Error(`parse line ${extraCommaLine}: expected ., got ,`);
+        }
+        head = items.pop();
+        while (items.length > 0) head = compound(',', [items.pop(), head]);
       }
       if (this.operatorTokenName() === '?-') {
         if (this.strictIso) {

package/src/quads.js

@@ -33,9 +33,14 @@ export function runQuads(source, options = {}) {
   const results = [];
   const lines = [];
   for (const quad of quads) {
-    const result = checkQuad(program, quad, options);
-    results.push(result);
-    if (!result.ok) lines.push(formatFailure(program, quad, result));
+    // Every indented answer description is an independent portable quad test.
+    // Re-run the query for each description so a failed expectation does not
+    // prevent later expectations for the same query from being checked.
+    for (const description of quad.answers) {
+      const result = checkQuadDescription(program, quad, description, options);
+      results.push(result);
+      if (!result.ok) lines.push(formatFailure(program, quad, result, description));
+    }
   }
   const passed = results.filter((result) => result.ok).length;
   const failed = results.length - passed;
@@ -43,15 +48,11 @@ export function runQuads(source, options = {}) {
   return { stdout: lines.join(''), total: results.length, passed, failed, results };
 }
 
-function checkQuad(program, quad, options) {
+function checkQuadDescription(program, quad, description, options) {
   if (quad.id != null && !termIsGround(quad.id, new Env())) {
     return { ok: false, kind: 'bad_identifier', expected: quad.id };
   }
-  for (const description of quad.answers) {
-    const checked = checkDescription(program, quad, description, options);
-    if (!checked.ok) return checked;
-  }
-  return { ok: true };
+  return checkDescription(program, quad, description, options);
 }
 
 function checkDescription(program, quad, description, options) {
@@ -398,14 +399,14 @@ function splitOperator(term, name) {
   return [term];
 }
 
-function formatFailure(program, quad, result) {
+function formatFailure(program, quad, result, description = quad.answers[0]) {
   const source = quad.source ?? { filename: '<input>', line: 1 };
   const label = quad.id == null ? '' : `${formatQuadTerm(program, quad.id)}, `;
   const reason = result.kind === 'malformed' ? 'MALFORMED'
     : result.kind === 'bad_identifier' ? 'BAD_ID'
       : result.kind === 'unsupported' ? 'UNSUPPORTED'
         : 'FAILED';
-  const expected = result.expected ?? quad.answers[0];
+  const expected = result.expected ?? description;
   return `quads: ${reason} ${label}${source.filename}:${source.line}\n` +
     `   ?- ${formatQuadTerm(program, quad.query)}.\n` +
     `   expected: ${formatQuadTerm(program, expected)}.\n`;

package/test/conformance/ISO-MATRIX.md

@@ -16,7 +16,7 @@ compliance audit and the remaining work before a full conformance claim.
 | 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses` |
 | 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases |
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin` |
-| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, Logtalk-derived error cases |
+| 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived error cases |
 | 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
 | ISO/IEC 13211-2 modules | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |

package/test/conformance/README.md

@@ -102,7 +102,7 @@ Selected cases are adapted from the ISO and standard-core suites of Logtalk,
 Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 383 cases in `iso/` and 789 file-based conformance cases in
+The corpus has 385 cases in `iso/` and 791 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

package/test/conformance/errors/iso/number_chars_parenthesized.pl

@@ -0,0 +1,2 @@
+%% goal: number_chars(_, ['(', '0', ')'])
+answer :- number_chars(_, ['(', '0', ')']).

package/test/conformance/errors/iso/number_codes_parenthesized.pl

@@ -0,0 +1,2 @@
+%% goal: number_codes(_, [40, 48, 41])
+answer :- number_codes(_, [40, 48, 41]).

package/test/conformance/expected-errors/iso/number_chars_parenthesized.txt

@@ -0,0 +1 @@
+error(syntax_error(number))

package/test/conformance/expected-errors/iso/number_codes_parenthesized.txt

@@ -0,0 +1 @@
+error(syntax_error(number))

package/test/fixtures/number_chars_cont_quad.pl

@@ -36,6 +36,9 @@
 70 ?- number_chars(N,"0x11").
       N=17.
 
+73 ?- number_chars(N,"(0)").
+      syntax_error(...).
+
 4  ?- number_chars(1,"a").
       syntax_error(...).
 

package/test/run-regression.mjs

@@ -258,6 +258,46 @@ why(
         assertEqual(strict.clauses.length, 1, 'strict functional ?-/2 remains an ordinary term');
       },
     },
+    {
+      name: 'quad labels accept multiple metadata fields and each answer description is independent',
+      run: () => {
+        const source = `9, "✳54·43", passes
+` +
+          `?- X is 1+1.
+` +
+          `   X = 3, unexpected. % almost
+` +
+          `   X = 1, unexpected. % too low
+` +
+          `   X = 2.0, unexpected.
+` +
+          `% and after checking PM:
+` +
+          `   X = 2.
+`;
+        const program = Program.parseSources([{ text: source, filename: 'issue-21.pl' }]);
+        assertEqual(program.quads.length, 1, 'query group count');
+        assertEqual(program.quads[0].answers.length, 4, 'answer-description count');
+        assertEqual(program.quads[0].id.name, ',', 'outer label comma');
+        assertEqual(program.quads[0].id.args[1].name, ',', 'right-associated label comma');
+        const result = publicApi.runQuads(program);
+        assertEqual(result.total, 4, 'answer-description total');
+        assertEqual(result.passed, 4, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 4 run, 4 passed, 0 failed.\n', 'issue #21 report');
+
+        const continuing = publicApi.runQuads(
+          `case ?- X is 1+1.
+   X = 3.
+   X = 2.
+`,
+        );
+        assertEqual(continuing.total, 2, 'later descriptions still run after failure');
+        assertEqual(continuing.passed, 1, 'later passing description counted');
+        assertEqual(continuing.failed, 1, 'failed description counted');
+        assertIncludes(continuing.stdout, 'quads: 2 run, 1 passed, 1 failed.', 'continuation summary');
+      },
+    },
     {
       name: 'runQuads checks portable answer descriptions',
       run: () => {
@@ -275,10 +315,10 @@ why(
           `?- X = 1.\n   X = 2, unexpected.\n   X = 1.\n\n` +
           `?- catch(throw(ball), E, true).\n   E = ball | error(system_error, ...).\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'quads.pl' }]));
-        assertEqual(result.total, 12, 'quad total');
-        assertEqual(result.passed, 12, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 12 run, 12 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 13, 'answer-description total');
+        assertEqual(result.passed, 13, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 13 run, 13 passed, 0 failed.\n', 'quad report');
       },
     },
     {
@@ -288,10 +328,10 @@ why(
           `   throw(g(_X)).\n` +
           `   throw(g(X)), unexpected.\n`;
         const result = publicApi.runQuads(Program.parseSources([{ text: source, filename: 'throw-copy-quad.pl' }]));
-        assertEqual(result.total, 1, 'quad total');
-        assertEqual(result.passed, 1, 'quad passed');
-        assertEqual(result.failed, 0, 'quad failed');
-        assertEqual(result.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 2, 'answer-description total');
+        assertEqual(result.passed, 2, 'answer-description passed');
+        assertEqual(result.failed, 0, 'answer-description failed');
+        assertEqual(result.stdout, 'quads: 2 run, 2 passed, 0 failed.\n', 'quad report');
 
         const forbiddenFresh = publicApi.runQuads(
           `?- throw(g(X)).\n   throw(g(_X)), unexpected.\n`,
@@ -396,9 +436,24 @@ c4 ?- call((!;1)).
           text: source,
           filename,
         }]));
-        assertEqual(result.total, 72, 'quad total');
-        assertEqual(result.passed, 72, 'quad passed');
-        assertEqual(result.stdout, 'quads: 72 run, 72 passed, 0 failed.\n', 'quad report');
+        assertEqual(result.total, 77, 'answer-description total');
+        assertEqual(result.passed, 77, 'answer-description passed');
+        assertEqual(result.stdout, 'quads: 77 run, 77 passed, 0 failed.\n', 'quad report');
+      },
+    },
+    {
+      name: 'number conversion rejects parenthesized numeric terms',
+      run: () => {
+        for (const goal of ['number_chars(N,"(0)")', 'number_codes(N,[40,48,41])']) {
+          let caught = null;
+          try {
+            publicApi.run('', { goal });
+          } catch (error) {
+            caught = error;
+          }
+          if (caught == null) throw new Error(`${goal} should throw`);
+          assertIncludes(String(caught?.message ?? caught), 'syntax_error(number)', goal);
+        }
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5735,13 +5735,16 @@ quoted_atom("ab").           % quoted_atom(ab)
 | `sub_atom(+Atom,?Before,?Length,?After,?SubAtom)` | Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers. |
 | `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or Unicode scalar codes. At least one side must be instantiated. |
 | `char_code(?Character,?Code)` | Converts one character atom and one Unicode scalar code. Surrogates and values outside `0..0x10ffff` raise a representation error. |
-| `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO numeric-token syntax, including radix integers, character-code constants, and leading layout. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
+| `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
 
 Conversions accept partial output lists when the atomic input is known, but
 constructing an atom or number requires a complete proper list with no unbound
 elements. Numeric parsing accepts leading ISO layout characters, an optional
 sign, decimal fractions, and decimal exponents; it rejects trailing material
-and non-finite values.
+and non-finite values. The regression gate vendors all 73 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 parenthesized-number regression.
 
 ### Streams and unit I/O
 
@@ -6405,8 +6408,10 @@ descriptions; variables introduced only by a description are fresh. For example,
 a query `throw(g(X))` is described by `throw(g(_X))`, while
 `throw(g(X)), unexpected` verifies that ISO `throw/1` did not retain the query
 variable in the renamed exception term. `...` and `ad_infinitum` accept further answers. Multiple
-indented descriptions after one query must all hold. `inputs/1` supplies and
-checks consumed characters; `outputs/1` checks emitted characters. `sto` marks
+indented descriptions after one query are independent checks: each re-runs the
+query, each is counted in the `quads:` summary, and a failing description does
+not suppress later descriptions for that query. `inputs/1` supplies and checks
+consumed characters; `outputs/1` checks emitted characters. `sto` marks
 an answer description that this finite-tree implementation skips. `loops` is
 checked with a deterministic solver-depth budget. The advanced stream
 annotations `peeks/1` and `waits`, and the unordered `other_answer_sequence`
@@ -6425,10 +6430,12 @@ 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. 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.`.
+and the next quad query at the left margin. A quad label may contain any number
+of comma-separated metadata fields, including across layout before `?-`; for
+example `9, "case", passes ?- Goal.` is one labelled query. 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.
@@ -6986,7 +6993,7 @@ precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 789 cases, including 383 focused ISO
+contains 791 cases, including 385 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal