eyeprolog 1.2.24 → 1.2.26

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.24",
+  "version": "1.2.26",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,9 +50,11 @@
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
+    "test:wg17-syntax": "node test/run-wg17-syntax.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
     "test:playground": "node test/run-playground.mjs",
+    "report:wg17-syntax": "node tools/report-wg17-syntax-coverage.mjs",
     "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
     "postversion": "git push origin HEAD --follow-tags"
   }

package/src/iso.js

@@ -9,6 +9,7 @@ import { sameNumberValue } from './number-value.js';
 import { createParserOperatorState, parseClauses, parseGoalText, parseNumberTokenText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
+import { characterCodeConstantEnd, quotedEscapeEnd } from './syntax-scan.js';
 
 let isoFresh = 0;
 
@@ -1071,33 +1072,9 @@ function isTerminatingFullStop(source, index) {
   return true;
 }
 
-function quotedEscapeEnd(source, index) {
-  const escaped = source[index + 1] ?? '';
-  if (!escaped) return index;
-
-  // A quoted-token continuation escape consumes its newline. Accept CRLF as
-  // the host representation of the same line boundary.
-  if (escaped === '\n') return index + 1;
-  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
-
-  // 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-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);
-  }
-
-  return index + 1;
+const termGraphicCharacters = new Set('#$&*+-./<=>@^~\\:');
+function continuesGraphicToken(source, index) {
+  return index > 0 && termGraphicCharacters.has(source[index - 1]);
 }
 
 function* termTextCandidates(stream) {
@@ -1120,14 +1097,27 @@ function* termTextCandidates(stream) {
       else if (ch === quote) quote = null;
       continue;
     }
+    const characterCodeEnd = characterCodeConstantEnd(source, i);
+    if (characterCodeEnd != null) { i = characterCodeEnd; continue; }
     if (ch === '%') { lineComment = true; continue; }
-    if (ch === '/' && next === '*') { blockComment = true; i++; continue; }
+    // Comment openers are recognized between tokens. Within a maximal
+    // graphic token, as in `//*`, the slash and star remain atom characters.
+    if (ch === '/' && next === '*' && !continuesGraphicToken(source, i)) {
+      blockComment = true;
+      i++;
+      continue;
+    }
     if (ch === "'" || ch === '"') { quote = ch; continue; }
     if (ch === '.' && isTerminatingFullStop(source, i)) {
       yield { text: source.slice(stream.position, i + 1), end: i + 1 };
     }
   }
 }
+function hasNonLayoutRemainder(source, start) {
+  return source.slice(start)
+    .replace(/[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g, '')
+    .length > 0;
+}
 function convertedTermText(text, solver) {
   if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) return text;
   let result = '', quote = null;
@@ -1169,6 +1159,7 @@ function readTermFromStream(stream, solver) {
         const clauses = parseClauses(convertedTermText(candidate.text, solver), {
           sourceMetadata: false,
           operatorState,
+          isoStrict: solver.isoStrict,
           doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
         });
         if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
@@ -1196,8 +1187,13 @@ function readTermFromStream(stream, solver) {
       }
     }
 
-    stream.position = String(stream.content).length;
-    if (!sawCandidate) return atom('end_of_file');
+    const source = String(stream.content);
+    const remainderStart = stream.position;
+    stream.position = source.length;
+    if (!sawCandidate) {
+      if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
+      return atom('end_of_file');
+    }
     throw new PrologError('syntax_error(read_term)');
   }
 }
@@ -1605,6 +1601,11 @@ function sameNumber(left, right) {
 function canonicalNumberText(value) {
   if (isDecimalInteger(value.name)) return BigInt(value.name).toString();
   const finite = Number(value.name);
+  // ISO 13211-1 has a single floating-point zero: a source spelling with a
+  // minus sign does not denote a distinct -0.0 value.  Generate the same
+  // character sequence for both spellings so converting that sequence back
+  // cannot make number_chars/2 change its own subsequent output.
+  if (finite === 0) return '0.0';
   if (Number.isFinite(finite) && /^-?\d+\.\d+(?:[eE][+-]?\d+)?$/.test(value.name)) {
     return value.name;
   }

package/src/parser.js

@@ -87,7 +87,6 @@ const PREFIX_OPERATORS = new Map([
 
 export const ISO_OPERATOR_DEFINITIONS = [
   [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'fx', '?-'], [1200, 'xfx', '-->'],
-  [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
@@ -99,6 +98,13 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// The alternative operator belongs to the Part 3 grammar-rule profile. Part 1
+// reserves `|` as list punctuation but permits a program to declare it as an
+// infix operator at priority 1001 or greater (Corrigendum 2).
+export const PART3_OPERATOR_DEFINITIONS = [
+  [1105, 'xfy', '|'],
+];
+
 // EyeProlog's embedded quad syntax permits an optional label before `?-`.
 // That makes `?-` an implementation-specific xfx operator in addition to its
 // ISO 1200 fx definition.
@@ -118,6 +124,10 @@ function operatorStrength(priority) {
   return 1201 - priority;
 }
 
+// ISO 6.3.3 arguments have maximum priority 999. Parenthesized terms and
+// curly-bracket contents may contain a full priority-1200 term instead.
+const ARG_MIN_PRECEDENCE = operatorStrength(999);
+
 function isGraphicAtomCode(code) {
   return graphicAtomChars.includes(String.fromCharCode(code));
 }
@@ -148,7 +158,10 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
   // The infix ?-/2 form is an EyeProlog quad extension.  ISO 13211-1
   // predefines only the 1200 fx ?- operator; strict core mode starts from that
   // table and still permits an explicit op/3 directive to add an infix form.
-  if (options.isoStrict === true) state.infixOperators.delete('?-');
+  if (options.isoStrict === true) {
+    state.infixOperators.delete('?-');
+    state.infixOperators.delete('|');
+  }
   for (const definition of definitions) {
     const [priority, specifier, name] = Array.isArray(definition)
       ? definition
@@ -342,7 +355,9 @@ class Parser {
   nextToken() {
     // The tokenizer keeps just enough state for useful parse-line errors and
     // treats quoted atoms and quoted strings differently, as Prolog syntax does.
+    const beforeLayout = this.pos;
     this.skipWhitespaceAndComments();
+    const precededByLayout = this.pos !== beforeLayout;
     const line = this.line;
     const ch = this.peek();
     if (!ch) return { type: TOK.EOF, text: '', line };
@@ -377,7 +392,7 @@ class Parser {
     };
     if (punct[ch]) {
       this.take();
-      return { type: punct[ch], text: ch, line };
+      return { type: punct[ch], text: ch, line, precededByLayout };
     }
     if (ch === ':' && this.peek(1) === '-') {
       this.pos += 2;
@@ -420,16 +435,22 @@ class Parser {
     const previousEndsTerm = this.previousToken && (
       [TOK.VAR, TOK.NUMBER, TOK.STRING, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE].includes(this.previousToken.type) ||
       (this.previousToken.type === TOK.ATOM &&
-       !this.infixOperators.has(this.previousToken.text) &&
-       !this.prefixOperators.has(this.previousToken.text) &&
-       !this.postfixOperators.has(this.previousToken.text))
+       (this.postfixOperators.has(this.previousToken.text) ||
+        (!this.infixOperators.has(this.previousToken.text) &&
+         !this.prefixOperators.has(this.previousToken.text))))
     );
     if (isDigitCode(ch.charCodeAt(0)) ||
         (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm)) {
       const start = this.pos;
       const negative = this.peek() === '-';
       if (negative) this.take();
-      if (this.peek() === '0' && this.peek(1) === "'") {
+      const startsQuotedCharacter = this.peek() === '0' && this.peek(1) === "'" &&
+        // `0''` is the integer 0 followed by the empty atom, whereas `0'''`
+        // is the character-code constant for an apostrophe. A continuation
+        // after the integer likewise belongs to the following quoted atom.
+        (this.peek(2) !== "'" || this.peek(3) === "'") &&
+        !(this.peek(2) === '\\' && this.peek(3) === '\n');
+      if (startsQuotedCharacter) {
         this.take();
         this.take();
         let value = this.take();
@@ -461,7 +482,12 @@ class Parser {
         const code = value.codePointAt(0);
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }
-      if (this.peek() === '0' && ['b', 'o', 'x'].includes(this.peek(1))) {
+      const radixKind = this.peek() === '0' ? this.peek(1) : '';
+      const radixHasDigit = radixKind === 'b' ? /^[01]$/.test(this.peek(2))
+        : radixKind === 'o' ? /^[0-7]$/.test(this.peek(2))
+        : radixKind === 'x' ? /^[0-9A-Fa-f]$/.test(this.peek(2))
+        : false;
+      if (radixHasDigit) {
         this.take();
         const kind = this.take();
         const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
@@ -475,11 +501,16 @@ class Parser {
         return { type: TOK.NUMBER, text: integer.toString(), line };
       }
       while (isDigitCode(this.peek().charCodeAt(0))) this.take();
+      let hasFraction = false;
       if (this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
+        hasFraction = true;
         this.take();
         while (isDigitCode(this.peek().charCodeAt(0))) this.take();
       }
-      if ((this.peek() === 'e' || this.peek() === 'E')) {
+      // ISO floating-point syntax requires a fractional part before an
+      // exponent. Thus 1.0e9 is one number token, while 1E9 is the integer 1
+      // followed by the name E9 and is not a valid term without an operator.
+      if (hasFraction && (this.peek() === 'e' || this.peek() === 'E')) {
         let idx = this.pos + 1;
         if (this.source[idx] === '+' || this.source[idx] === '-') idx++;
         if (isDigitCode((this.source[idx] ?? '').charCodeAt(0))) {
@@ -488,7 +519,10 @@ class Parser {
           while (isDigitCode(this.peek().charCodeAt(0))) this.take();
         }
       }
-      return { type: TOK.NUMBER, text: this.source.slice(start, this.pos), line };
+      let text = this.source.slice(start, this.pos);
+      if (!hasFraction) text = BigInt(text).toString();
+      else if (Object.is(Number(text), -0)) text = '0.0';
+      return { type: TOK.NUMBER, text, line };
     }
 
     if (isVariableStartCode(ch.charCodeAt(0))) {
@@ -525,7 +559,9 @@ class Parser {
   parseParenthesizedTerm() {
     this.expect(TOK.LPAREN, '(');
     this.advance();
-    const term = this.parseTerm(0, true);
+    // A current operator atom may be the complete parenthesized term, e.g.
+    // (+), but it cannot silently become an operand in a larger expression.
+    const term = this.parseTerm(0, true, true, true);
     this.expect(TOK.RPAREN, ')');
     this.advance();
     return term;
@@ -542,14 +578,14 @@ class Parser {
     const items = [];
     let tail = null;
     while (true) {
-      items.push(this.parseTerm(0, false, false));
+      items.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
       if (this.token.type === TOK.COMMA) {
         this.advance();
         continue;
       }
       if (this.token.type === TOK.BAR) {
         this.advance();
-        tail = this.parseTerm(0, false, false);
+        tail = this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true);
         this.expect(TOK.RBRACKET, ']');
         this.advance();
         break;
@@ -574,8 +610,33 @@ class Parser {
     this.advance();
     return compound('{}', [term]);
   }
-  parseTerm(minPrecedence = 0, allowComma = false, allowBar = true) {
-    let left = this.parsePrefixTerm(minPrecedence, allowBar);
+  parseFunctionalNotation(name) {
+    this.expect(TOK.LPAREN, '(');
+    this.advance();
+    const args = [];
+    if (this.token.type === TOK.RPAREN) {
+      throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(name)} for arity zero data`);
+    }
+    while (true) {
+      args.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
+      if (this.token.type !== TOK.COMMA) break;
+      this.advance();
+    }
+    this.expect(TOK.RPAREN, ')');
+    this.advance();
+    return compound(name, args);
+  }
+  parseTerm(minPrecedence = 0, allowComma = false, allowBar = true, allowOperatorAtom = false) {
+    const initialOperatorName = this.operatorTokenName();
+    // An atom whose only operator declaration is postfix can still seed a
+    // postfix expression: after `op(100,xf,a), op(200,xf,b)`, `a b` denotes
+    // b(a).  Prefix and infix operator atoms cannot be bare operands.
+    const initialWasCurrentOperator = initialOperatorName != null &&
+      (this.infixOperators.has(initialOperatorName) ||
+       this.prefixOperators.has(initialOperatorName));
+    let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
+    const leftIsBareOperatorAtom = initialWasCurrentOperator &&
+      left.type === ATOM && left.name === initialOperatorName;
     let strictPostfixPrecedence = null;
     while (true) {
       const op = this.token.type === TOK.COMMA && allowComma
@@ -589,15 +650,26 @@ class Parser {
         const postfix = postfixName == null ? null : this.postfixOperators.get(postfixName);
         if (!postfix || postfix.precedence < minPrecedence ||
             (strictPostfixPrecedence === postfix.precedence)) break;
+        if (this.strictIso && leftIsBareOperatorAtom) {
+          throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+        }
         const name = postfixName;
         this.advance();
         left = compound(name, [left]);
         strictPostfixPrecedence = postfix.strict ? postfix.precedence : null;
         continue;
       }
+      if (this.strictIso && leftIsBareOperatorAtom) {
+        throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+      }
       strictPostfixPrecedence = null;
       this.advance();
-      const right = this.parseTerm(info.associativity === 'right' ? info.precedence : info.precedence + 1, allowComma, allowBar);
+      const right = this.parseTerm(
+        info.associativity === 'right' ? info.precedence : info.precedence + 1,
+        allowComma,
+        allowBar,
+        false,
+      );
       left = compound(op, [left, right]);
       if (info.associativity === 'none') {
         const nextOp = this.token.type === TOK.COMMA && allowComma
@@ -610,18 +682,46 @@ class Parser {
         }
       }
     }
+    if (this.strictIso && leftIsBareOperatorAtom && left.type === ATOM && !allowOperatorAtom) {
+      throw new Error(`parse line ${this.token.line}: operator atom ${left.name} requires parentheses as an operand`);
+    }
     return left;
   }
-  parsePrefixTerm(minPrecedence = 0, allowBar = true) {
+  parsePrefixTerm(minPrecedence = 0, allowBar = true, allowOperatorAtom = false) {
     // `:-` is tokenized specially so the program grammar can recognize clause
     // and directive markers. In term argument position, however, ISO 6.3.3.1
     // permits an operator atom directly as an `arg`; a leading `:-` cannot be
     // prefix operator notation at argument priority, so it denotes the atom.
     if (this.token.type === TOK.IF) {
+      if (this.strictIso && !allowOperatorAtom) {
+        throw new Error(`parse line ${this.token.line}: operator atom :- requires argument context or parentheses`);
+      }
       this.advance();
       return atom(':-');
     }
     const operatorName = this.operatorTokenName();
+    // A negative number consists of a minus name token followed by a numeric
+    // token, with layout permitted between them. It is lexical number syntax,
+    // not an application of the current prefix `-` operator, and therefore
+    // remains valid even after op(0, fy, -).
+    if (operatorName === '-' && this.token.type === TOK.ATOM) {
+      const state = {
+        pos: this.pos,
+        line: this.line,
+        previousToken: this.previousToken,
+        token: this.token,
+      };
+      this.advance();
+      if (this.token.type === TOK.NUMBER && !this.token.text.startsWith('-')) {
+        const value = this.token.text;
+        this.advance();
+        return numberTerm(`-${value}`);
+      }
+      this.pos = state.pos;
+      this.line = state.line;
+      this.previousToken = state.previousToken;
+      this.token = state.token;
+    }
     if (operatorName != null && this.prefixOperators.get(operatorName)?.precedence >= minPrecedence) {
       const op = operatorName;
       const info = this.prefixOperators.get(op);
@@ -631,26 +731,30 @@ class Parser {
       // an argument delimiter there is no operand for prefix syntax, so keep
       // the operator as an atom instead of reporting a misleading bad-term
       // error.
-      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.BAR].includes(this.token.type)) {
+      if ([TOK.COMMA, TOK.RPAREN, TOK.RBRACKET, TOK.BAR, TOK.DOT].includes(this.token.type)) {
+        if (this.strictIso && !allowOperatorAtom && this.token.type !== TOK.DOT) {
+          throw new Error(`parse line ${this.token.line}: operator atom ${op} requires argument context or parentheses`);
+        }
         return atom(op);
       }
-      if (this.token.type === TOK.LPAREN) {
-        this.advance();
-        const args = [];
-        while (true) {
-          args.push(this.parseTerm(0, false, false));
-          if (this.token.type !== TOK.COMMA) break;
-          this.advance();
-        }
-        this.expect(TOK.RPAREN, ')');
-        this.advance();
-        return compound(op, args);
+      if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) {
+        return this.parseFunctionalNotation(op);
       }
-      return compound(op, [this.parseTerm(info.precedence + (info.strict ? 1 : 0), false, allowBar)]);
+      return compound(op, [this.parseTerm(info.precedence + (info.strict ? 1 : 0), false, allowBar, false)]);
     }
     if (this.token.type === TOK.LPAREN) return this.parseParenthesizedTerm();
-    if (this.token.type === TOK.LBRACKET) return this.parseList();
-    if (this.token.type === TOK.LBRACE) return this.parseCurly();
+    if (this.token.type === TOK.LBRACKET) {
+      const list = this.parseList();
+      if (list.type === ATOM && list.name === '[]' && this.token.type === TOK.LPAREN &&
+          this.token.precededByLayout !== true) return this.parseFunctionalNotation('[]');
+      return list;
+    }
+    if (this.token.type === TOK.LBRACE) {
+      const curly = this.parseCurly();
+      if (curly.type === ATOM && curly.name === '{}' && this.token.type === TOK.LPAREN &&
+          this.token.precededByLayout !== true) return this.parseFunctionalNotation('{}');
+      return curly;
+    }
     if (this.token.type === TOK.VAR) {
       const name = this.token.text;
       this.advance();
@@ -666,21 +770,7 @@ class Parser {
       const value = this.token.text;
       this.advance();
       if (this.parserFlagState.doubleQuotes === 'atom') {
-        if (this.token.type === TOK.LPAREN) {
-          this.advance();
-          const args = [];
-          if (this.token.type === TOK.RPAREN) {
-            throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(value)} for arity zero data`);
-          }
-          while (true) {
-            args.push(this.parseTerm(0, false, false));
-            if (this.token.type !== TOK.COMMA) break;
-            this.advance();
-          }
-          this.expect(TOK.RPAREN, ')');
-          this.advance();
-          return compound(value, args);
-        }
+        if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) return this.parseFunctionalNotation(value);
         return atom(value);
       }
       const items = Array.from(value, (character) =>
@@ -699,23 +789,12 @@ class Parser {
     if (this.token.type === TOK.ATOM) {
       const name = this.token.text;
       this.advance();
-      if (this.token.type === TOK.LPAREN) {
-        this.advance();
-        const args = [];
-        if (this.token.type === TOK.RPAREN) {
-          throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(name)} for arity zero data`);
-        }
-        while (true) {
-          args.push(this.parseTerm(0, false, false));
-          if (this.token.type === TOK.COMMA) {
-            this.advance();
-            continue;
-          }
-          break;
-        }
-        this.expect(TOK.RPAREN, ')');
-        this.advance();
-        return compound(name, args);
+      if (this.token.type === TOK.LPAREN && this.token.precededByLayout !== true) {
+        return this.parseFunctionalNotation(name);
+      }
+      if (this.strictIso && !allowOperatorAtom &&
+          (this.infixOperators.has(name) || this.prefixOperators.has(name) || this.postfixOperators.has(name))) {
+        throw new Error(`parse line ${this.token.line}: operator atom ${name} requires argument context or parentheses`);
       }
       return atom(name);
     }
@@ -840,7 +919,7 @@ class Parser {
         this.token = headState.token;
       };
 
-      let head = this.parseTerm(3);
+      let head = this.parseTerm(3, false, true, true);
       if (this.token.type === TOK.COMMA && !this.strictIso) {
         restoreHeadState();
         const quadId = this.parseTerm(3, true);
@@ -850,7 +929,7 @@ class Parser {
           continue;
         }
         restoreHeadState();
-        head = this.parseTerm(3);
+        head = this.parseTerm(3, false, true, true);
       }
 
       // Outside quad syntax, preserve the existing program-level comma rule,
@@ -1308,18 +1387,100 @@ export function parseProgramText(source, options = {}) {
 
 export function parseNumberTokenText(text) {
   const source = String(text ?? '');
-  const parser = new Parser(source, {
-    includeDefaultOperators: false,
-    sourceMetadata: false,
-  });
-  // Inspect the tokenizer position before requesting another token: advancing
-  // would skip trailing layout and make `3 ` or `3/**/` look complete. A
-  // literal space consumed by the character-code token `0' ` is already part
-  // of parser.pos and is therefore correctly accepted.
-  if (parser.token.type !== TOK.NUMBER || parser.pos !== source.length) {
-    throw new Error('not exactly one number token');
+  let position = 0;
+  let negative = false;
+  if (source[position] === '-') {
+    negative = true;
+    position++;
+  }
+
+  // number_chars/2 and number_codes/2 need the lexical number production,
+  // not a general term reader. Keeping this scanner number-only avoids
+  // allocating a Parser and three operator tables for every conversion.
+  if (source.startsWith("0'", position)) {
+    position += 2;
+    let value = source[position] ?? '';
+    if (!value || (value !== ' ' && isWhitespaceCode(value.charCodeAt(0)))) {
+      throw new Error('not exactly one number token');
+    }
+    position++;
+    const firstCode = value.charCodeAt(0);
+    if (firstCode >= 0xd800 && firstCode <= 0xdbff) {
+      const secondCode = source.charCodeAt(position);
+      if (secondCode < 0xdc00 || secondCode > 0xdfff) throw new Error('not exactly one number token');
+      value += source[position++];
+    } else if (firstCode >= 0xdc00 && firstCode <= 0xdfff) {
+      throw new Error('not exactly one number token');
+    }
+
+    if (value === "'") {
+      if (source[position] !== "'") throw new Error('not exactly one number token');
+      position++;
+    } else if (value === '\\') {
+      const escaped = source[position++] ?? '';
+      const controls = { a: '\x07', b: '\b', r: '\r', f: '\f', t: '\t', n: '\n', v: '\v' };
+      if (controls[escaped] != null) {
+        value = controls[escaped];
+      } else if (escaped === 'x') {
+        let digits = '';
+        while (/^[0-9A-Fa-f]$/.test(source[position] ?? '')) digits += source[position++];
+        if (!digits || source[position++] !== '\\') throw new Error('not exactly one number token');
+        const code = Number.parseInt(digits, 16);
+        if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw new Error('not exactly one number token');
+        value = String.fromCodePoint(code);
+      } else if (/^[0-7]$/.test(escaped)) {
+        let digits = escaped;
+        while (/^[0-7]$/.test(source[position] ?? '')) digits += source[position++];
+        if (source[position++] !== '\\') throw new Error('not exactly one number token');
+        const code = Number.parseInt(digits, 8);
+        if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw new Error('not exactly one number token');
+        value = String.fromCodePoint(code);
+      } else if (escaped === '\\' || escaped === "'" || escaped === '"' || escaped === '`') {
+        value = escaped;
+      } else {
+        throw new Error('not exactly one number token');
+      }
+    }
+
+    if (position !== source.length) throw new Error('not exactly one number token');
+    const code = value.codePointAt(0);
+    return numberTerm(String(negative ? -code : code));
+  }
+
+  if (source[position] === '0' && ['b', 'o', 'x'].includes(source[position + 1])) {
+    const kind = source[position + 1];
+    const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
+    const digitPattern = radix === 2 ? /^[01]$/ : radix === 8 ? /^[0-7]$/ : /^[0-9A-Fa-f]$/;
+    position += 2;
+    let digits = '';
+    while (digitPattern.test(source[position] ?? '')) digits += source[position++];
+    if (!digits || position !== source.length) throw new Error('not exactly one number token');
+    let integer = 0n;
+    for (const digit of digits) integer = integer * BigInt(radix) + BigInt(Number.parseInt(digit, radix));
+    if (negative) integer = -integer;
+    return numberTerm(integer.toString());
+  }
+
+  const digitsStart = position;
+  while (isDigitCode(source.charCodeAt(position))) position++;
+  if (position === digitsStart) throw new Error('not exactly one number token');
+  let hasFraction = false;
+  if (source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
+    hasFraction = true;
+    position++;
+    while (isDigitCode(source.charCodeAt(position))) position++;
+  }
+  if (hasFraction && (source[position] === 'e' || source[position] === 'E')) {
+    position++;
+    if (source[position] === '+' || source[position] === '-') position++;
+    const exponentStart = position;
+    while (isDigitCode(source.charCodeAt(position))) position++;
+    if (position === exponentStart) throw new Error('not exactly one number token');
   }
-  return numberTerm(parser.token.text);
+  if (position !== source.length) throw new Error('not exactly one number token');
+  if (/^-?\d+$/.test(source)) return numberTerm(BigInt(source).toString());
+  if (Object.is(Number(source), -0)) return numberTerm('0.0');
+  return numberTerm(source);
 }
 
 export function parseGoalText(text, options = {}) {

package/src/program.js

@@ -5,6 +5,7 @@ import { numberValueKey } from './number-value.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
+  PART3_OPERATOR_DEFINITIONS,
   QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
   parseClauses,
@@ -106,7 +107,7 @@ export class Program {
     this.operators = new Map();
     const predefinedOperatorSets = this.strictIso
       ? [ISO_OPERATOR_DEFINITIONS]
-      : [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
+      : [ISO_OPERATOR_DEFINITIONS, PART3_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
     for (const definitions of predefinedOperatorSets) {
       for (const [priority, specifier, name] of definitions) {
         this.defineOperator(priority, specifier, name);