eyeprolog 1.1.12 → 1.1.13

package/package.json

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

package/src/iso.js

@@ -5,7 +5,7 @@ import {
   isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble,
   properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
-import { createParserOperatorState, parseClauses } from './parser.js';
+import { createParserOperatorState, parseClauses, parseGoalText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 
@@ -1406,12 +1406,129 @@ function* charCodeBuiltin({ goal, env }) {
   } else if (unify(goal.args[0], atom(String.fromCodePoint(Number(code.name))), next)) yield next;
 }
 
+function skipNumberLayout(text, start) {
+  let position = start;
+  while (true) {
+    while (position < text.length && /[\u0009-\u000d\u0020]/.test(text[position])) {
+      position++;
+    }
+    if (text[position] === '%') {
+      const newline = text.indexOf('\n', position + 1);
+      if (newline < 0) return text.length;
+      position = newline + 1;
+      continue;
+    }
+    if (text.startsWith('/*', position)) {
+      const end = text.indexOf('*/', position + 2);
+      if (end < 0) return text.length;
+      position = end + 2;
+      continue;
+    }
+    return position;
+  }
+}
+
+function quotedNumberSign(text, start) {
+  if (text[start] !== "'") return null;
+  let position = start + 1;
+  let value = '';
+  while (position < text.length) {
+    let character = text[position++];
+    if (character === "'") {
+      if (text[position] === "'") {
+        position++;
+        value += "'";
+        continue;
+      }
+      return { value, position };
+    }
+    if (character !== '\\') {
+      value += character;
+      continue;
+    }
+    if (position >= text.length) return null;
+    character = text[position++];
+    if (character === '\n') continue;
+    const controls = { a: '\x07', b: '\b', r: '\r', f: '\f', t: '\t', n: '\n', v: '\v' };
+    if (controls[character] != null) {
+      value += controls[character];
+      continue;
+    }
+    value += character;
+  }
+  return null;
+}
+
 function parseIsoNumber(text) {
-  const trimmed = text.replace(/^[\u0009-\u000d\u0020]+/, '');
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed)) return null;
-  if (/^[+-]?\d+$/.test(trimmed)) return numberTerm(BigInt(trimmed).toString());
-  const value = Number(trimmed);
-  return Number.isFinite(value) ? numberTerm(numberTextFromDouble(value)) : null;
+  // number_chars/2 accepts leading layout, but its character list must end
+  // with the numeric token itself rather than trailing layout text.
+  if (text.length === 0 || /[\u0009-\u000d\u0020]$/.test(text)) return null;
+  let position = skipNumberLayout(text, 0);
+  let sign = '';
+
+  if (text[position] === '-') {
+    if (/[\u0009-\u000d\u0020]/.test(text[position + 1] ?? '')) {
+      position = skipNumberLayout(text, position + 1);
+      sign = '-';
+    }
+  } else {
+    const quoted = quotedNumberSign(text, position);
+    if (quoted?.value === '-') {
+      position = skipNumberLayout(text, quoted.position);
+      sign = '-';
+    }
+  }
+
+  const numericText = `${sign}${text.slice(position)}`;
+  // ISO floating-point syntax requires a decimal fraction before an exponent.
+  if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
+  try {
+    const parsed = parseGoalText(`number_chars_value(${numericText})`);
+    if (parsed.type !== COMPOUND || parsed.name !== 'number_chars_value' ||
+        parsed.arity !== 1 || parsed.args[0].type !== NUMBER) return null;
+    const value = parsed.args[0];
+    if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
+    const finite = Number(value.name);
+    if (!Number.isFinite(finite)) return null;
+    return numberTerm(numberTextFromDouble(finite));
+  } catch (_) {
+    return null;
+  }
+}
+
+function sameNumber(left, right) {
+  const leftInteger = isDecimalInteger(left.name);
+  const rightInteger = isDecimalInteger(right.name);
+  if (leftInteger || rightInteger) {
+    return leftInteger && rightInteger && BigInt(left.name) === BigInt(right.name);
+  }
+  const leftValue = Number(left.name);
+  const rightValue = Number(right.name);
+  return Number.isFinite(leftValue) && Number.isFinite(rightValue) && leftValue === rightValue;
+}
+
+function numberListText(list, env, kind, valueIsBound) {
+  const whole = deref(list, env);
+  const { items, tail } = listElements(list, env);
+  const proper = tail.type === ATOM && tail.name === '[]';
+  if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
+
+  const invalid = items.find((item) => item.type !== VAR &&
+    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item)));
+  if (invalid) {
+    if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
+    if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
+      throw new PrologError('type_error(integer)', invalid);
+    }
+    throw new PrologError('representation_error(character_code)');
+  }
+
+  const hasVariable = tail.type === VAR || items.some((item) => item.type === VAR);
+  if (!valueIsBound && hasVariable) throw new PrologError('instantiation_error');
+  if (hasVariable) return null;
+  return items.map((item) => kind === 'chars'
+    ? item.name
+    : String.fromCodePoint(Number(item.name))).join('');
 }
 
 function numberListBuiltin(kind) {
@@ -1420,14 +1537,21 @@ function numberListBuiltin(kind) {
     if (value.type !== VAR && value.type !== NUMBER) throw new PrologError('type_error(number)', value);
     const list = deref(goal.args[1], env);
     if (value.type === VAR && list.type === VAR) throw new PrologError('instantiation_error');
+    const text = numberListText(list, env, kind, value.type === NUMBER);
     const next = env.clone();
     if (value.type === NUMBER) {
+      if (text != null) {
+        const parsed = parseIsoNumber(text);
+        if (parsed == null) throw new PrologError('syntax_error(number)');
+        if (sameNumber(value, parsed)) yield next;
+        return;
+      }
       const items = characters(value.name).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    const parsed = parseIsoNumber(listToAtomInput(list, env, kind));
+    const parsed = parseIsoNumber(text);
     if (parsed == null) throw new PrologError('syntax_error(number)');
     if (unify(goal.args[0], parsed, next)) yield next;
   };

package/src/lib/eyeprolog.pl

@@ -622,7 +622,21 @@ number_string(Number, Text) :-
 number_string(Number, Text) :-
     var(Number),
     eyeprolog__text_chars(Text, Chars),
-    catch(number_chars(Number, Chars), _, fail).
+    catch(number_chars(Number, Chars), _,
+        catch(( eyeprolog__integer_exponent_chars(Chars, Expanded),
+                number_chars(Number, Expanded)
+              ), _, fail)).
+
+eyeprolog__integer_exponent_chars(Chars, Expanded) :-
+    eyeprolog__split_exponent(Chars, Mantissa, Marker, Exponent),
+    number_chars(Integer, Mantissa),
+    integer(Integer),
+    eyeprolog__append(Mantissa, ['.','0',Marker|Exponent], Expanded).
+
+eyeprolog__split_exponent([e|Exponent], [], e, Exponent).
+eyeprolog__split_exponent(['E'|Exponent], [], 'E', Exponent).
+eyeprolog__split_exponent([C|Chars], [C|Mantissa], Marker, Exponent) :-
+    eyeprolog__split_exponent(Chars, Mantissa, Marker, Exponent).
 
 atom_string(Atom, Text) :-
     atom(Atom),

package/test/fixtures/number_chars_cont_quad.pl

@@ -0,0 +1,235 @@
+% ids refer to https://www.complang.tuwien.ac.at/ulrich/iso-prolog/number_chars_cont
+
+1  ?- number_chars(1.2,"1.2").
+      true.
+
+55 ?- number_chars(1.2,"1.20").
+      true.
+
+2  ?- number_chars(1.0e9,"1.0E9").
+      true.
+
+56 ?- number_chars(1.0e9,"1.0e9").
+      true.
+
+64 ?- number_chars(0.0,"-0.0").
+      true.
+
+3  ?- number_chars(1,"01").
+      true.
+
+65 ?- number_chars(10,"010").
+      true.
+
+66 ?- number_chars(N,"010").
+      N=10.
+
+67 ?- number_chars(N,"08").
+      N=8.
+
+68 ?- number_chars(N,"0b11").
+      N=3.
+
+69 ?- number_chars(N,"0o11").
+      N=9.
+
+70 ?- number_chars(N,"0x11").
+      N=17.
+
+4  ?- number_chars(1,"a").
+      syntax_error(...).
+
+5  ?- number_chars(1,[]).
+      syntax_error(...).
+
+6  ?- number_chars(1,[[]]).
+      type_error(character,[]).
+
+7  ?- number_chars(1,[' ',[]]).
+      type_error(character,[]).
+
+8  ?- number_chars(1,[0]).
+      type_error(character,0).
+
+9  ?- number_chars(1,[_,[]]).
+      type_error(character,[]).
+
+10 ?- number_chars(N,[X]).
+      instantiation_error.
+
+11 ?- number_chars(N,['0'|_]).
+      instantiation_error.
+
+12 ?- number_chars(N,'1').
+      type_error(list,'1').
+
+13 ?- number_chars(N,[a|a]).
+      type_error(list,[a|a]).
+
+14 ?- number_chars(N,[49]).
+      type_error(character,49).
+
+15 ?- number_chars(N,[]).
+      syntax_error(...).
+
+16 ?- number_chars(N,"3 ").
+      syntax_error(...).
+
+17 ?- number_chars(N,"3.").
+      syntax_error(...).
+
+18 ?- number_chars(N," 1").
+      N = 1.
+
+19 ?- number_chars(N,"\n1").
+      N = 1.
+
+20 ?- number_chars(N," 0'a").
+      N = 0'a. N = 97.
+
+58 ?- number_chars(N,"0'").
+      syntax_error(...).
+
+59 ?- number_chars(N,"0'\n").
+      syntax_error(...).
+
+60 ?- number_chars(N,"0'\\n").
+      N=0'\n. N=10.
+
+61 ?- number_chars(N,"0'\\7\\").
+      N=7.
+
+71 ?- number_chars(N,"0'\\7").
+      syntax_error(...).
+
+62 ?- number_chars(N,"0'.").
+      N=0'. . N = 46.
+
+21 ?- number_chars(N,"- 1").
+      N = -1.
+
+54 ?- number_chars(N,"'-'1").
+      N = -1.
+
+22 ?- number_chars(N,"/**/1").
+      N = 1.
+
+23 ?- number_chars(N,"%\n1").
+      N = 1.
+
+57 ?- number_chars(N,"- /**/1").
+      N = -1.
+
+24 ?- number_chars(N,"-/**/1").
+      syntax_error(...).
+
+63 ?- number_chars(N,"'\\\n-' 3").
+      N= -3.
+
+25 ?- number_chars(N,"1e1").
+      syntax_error(...).
+
+26 ?- number_chars(N,"1.0e").
+      syntax_error(...).
+
+27 ?- number_chars(N,"1.0ee").
+      syntax_error(...).
+
+28 ?- number_chars(N,"0x1").
+      N = 1.
+
+29 ?- number_chars(N,"0X1").
+      syntax_error(...).
+
+30 ?- number_chars(N,"1E1").
+      syntax_error(...).
+
+47 ?- number_chars(1,['.'|_]).
+      false.
+
+48 ?- number_chars(N,"+1").
+      syntax_error(...).
+
+49 ?- number_chars(N,"+ 1").
+      syntax_error(...).
+
+50 ?- number_chars(N,"'+'1").
+      syntax_error(...).
+
+
+51 ?- number_chars(N,['11']).
+      type_error(character,'11').
+
+52 ?- number_chars(N,['1.1']).
+      type_error(character,'1.1').
+
+53 ?- number_chars(1+1,"2").
+      type_error(number,1+1).
+
+
+31 ?- number_chars(1,[C]).
+      C = '1'.
+
+32 ?- number_chars(1,[C,D]).
+      false.
+
+
+33 ?- number_chars(1,[C,C]).
+      false.
+
+34 ?- number_chars(0,[C,C]).
+      false.
+
+35 ?- number_chars(10,[C,D]).
+      C = '1', D = '0'.
+
+36 ?- number_chars(100,[C,D]).
+      false.
+
+37 ?- number_chars(N,[X|2]).
+      type_error(list,[_|2])
+   |  instantiation_error.
+
+38 ?- number_chars(N,[1|_]).
+      instantiation_error
+   |  type_error(character,1).
+
+39 ?- number_chars(V,[1|2]).
+      type_error(list,[1|2])
+   |  type_error(character,1).
+
+40 ?- number_chars([],1).
+      type_error(number,[])
+   |  type_error(list,1).
+
+41 ?- number_chars(1,1).
+      type_error(list,1).
+
+42 ?- number_chars(1,[a|2]).
+      type_error(list,[a|2]).
+
+43 ?- number_chars(1,[_|2]).
+      type_error(list,[_|2]).
+
+44 ?- number_chars(1,[[]|_]).
+      type_error(character,[]).
+
+45 ?- number_chars(1,[[]|2]).
+      type_error(character,[])
+   |  type_error(list,[[]|2]).
+
+72 ?- number_chars(V,[1,[],X|2]).
+      type_error(list,[1,[],_A|2])
+   |  type_error(character,1)
+   |  type_error(character,[])
+   |  instantiation_error.
+
+46 ?- L=['1'|L], number_chars(N,L).
+      sto, ... ; ... .
+      ( sto, type_error(list,['1'|...]) % rational trees
+      | sto, false % occurs-check
+      | sto, representation_error(term)
+      | sto, instantiation_error % literal substitutions
+      | sto, resource_error(...)
+      | sto, loops
+      ).

package/test/run-regression.mjs

@@ -322,6 +322,20 @@ c4 ?- call((!;1)).
         assertEqual(result.stdout, 'quads: 58 run, 58 passed, 0 failed.\n', 'quad report');
       },
     },
+    {
+      name: 'runQuads passes the complete vendored number_chars continuation corpus',
+      run: () => {
+        const filename = path.join(testRoot, 'fixtures', 'number_chars_cont_quad.pl');
+        const source = fs.readFileSync(filename, 'utf8');
+        const result = publicApi.runQuads(Program.parseSources([{
+          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');
+      },
+    },
     {
       name: 'runQuads passes the complete vendored Prolog Prologue quad corpus',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5636,7 +5636,7 @@ 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. 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 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)*. |
 
 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