eyeprolog 1.3.47 → 1.3.49

package/package.json

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

package/src/iso-arithmetic.js

@@ -20,10 +20,57 @@ function evaluate(term, env, options = {}) {
     throw new PrologError('type_error(evaluable)', compound('/', [atom(term.name), numberTerm(0)]));
   }
   if (term.type !== COMPOUND) throw new PrologError('type_error(evaluable)', term);
-  const args = term.args.map((arg) => evaluate(arg, env, options));
-  return evaluateOperation(term, args);
+
+  let args;
+  if (options.isoStrict === true) {
+    // ISO 7.9.2(b) gives a direct variable argument precedence over the other
+    // expression errors of the same compound expression. Check the direct
+    // arguments before selecting an implementation-dependent evaluation order.
+    const operands = term.args.map((arg) => deref(arg, env));
+    if (operands.some((arg) => arg.type === VAR)) throw new PrologError('instantiation_error');
+    args = operands.map((arg) => evaluateOperand(term, arg, env, options));
+  } else {
+    // Preserve the normal EyeProlog profile's established left-to-right
+    // evaluator and diagnostics; the stricter prescribed errors belong to
+    // the explicit ISO profile.
+    args = term.args.map((arg) => evaluate(arg, env, options));
+  }
+  return evaluateOperation(term, args, options);
+}
+
+function evaluatesAtomDirectly(term, options) {
+  return term.type === ATOM && (term.name === 'pi' || (term.name === 'e' && options.isoStrict !== true));
 }
-function evaluateOperation(term, args) {
+
+function directOperandType(term) {
+  const name = term.name;
+  const arity = term.arity;
+  if ((arity === 1 && name === '\\') ||
+      (arity === 2 && ['>>', '<<', '/\\', '\\/', 'xor'].includes(name))) return 'integer';
+
+  if ((arity === 1 && ['+', '-', 'abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
+    'float_integer_part', 'float_fractional_part', 'sin', 'cos', 'atan', 'asin', 'acos', 'tan',
+    'exp', 'log', 'sqrt'].includes(name)) ||
+      (arity === 2 && ['+', '-', '*', '/', '//', 'div', 'mod', 'rem', '**', '^', 'max', 'min', 'atan2'].includes(name))) {
+    return 'number';
+  }
+  return null;
+}
+
+function evaluateOperand(parent, operand, env, options) {
+  // The arithmetic-functor error clauses use the offending operand as the
+  // culprit when an atomic operand is not numeric (e.g. +(foo,77),
+  // truncate(foo), and the bitwise families).  A nested compound still goes
+  // through ordinary expression evaluation so an unknown nested F/N retains
+  // type_error(evaluable,F/N).
+  if (operand.type === ATOM && !evaluatesAtomDirectly(operand, options)) {
+    const expected = directOperandType(parent);
+    if (expected) throw new PrologError(`type_error(${expected})`, operand);
+  }
+  return evaluate(operand, env, options);
+}
+
+function evaluateOperation(term, args, options = {}) {
   const name = term.name;
   const arity = term.arity;
   if (arity === 1 && (name === '+' || name === '-')) {
@@ -38,6 +85,12 @@ function evaluateOperation(term, args) {
   if (arity === 1 && ['abs', 'sign', 'float', 'truncate', 'round', 'ceiling', 'floor',
     'float_integer_part', 'float_fractional_part',
     'sin', 'cos', 'atan', 'asin', 'acos', 'tan', 'exp', 'log', 'sqrt'].includes(name)) {
+    // The four float-to-integer rounding functors have only F->I operators
+    // (9.1.1/9.1.6). Corrigendum 1/2 therefore requires type_error(float,...)
+    // when their evaluated argument has integer type.
+    if (options.isoStrict === true && ['truncate', 'round', 'ceiling', 'floor'].includes(name) && args[0].integer) {
+      throw new PrologError('type_error(float)', numericTerm(args[0]));
+    }
     const a = Number(args[0].value);
     if (name === 'abs' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -args[0].value : args[0].value };
     if (name === 'sign' && args[0].integer) return { integer: true, value: args[0].value < 0n ? -1n : args[0].value > 0n ? 1n : 0n };
@@ -105,6 +158,11 @@ function evaluateOperation(term, args) {
     if (x === 0 && y === 0) throw new PrologError('evaluation_error(undefined)');
     value = Math.atan2(x, y);
   }
+  else if ((name === '**' || name === '^') && x === 0 && y < 0) {
+    // 9.3.1.3(d) and Cor.2 9.3.10.3(d): zero to a negative power is
+    // undefined, not floating-point overflow.
+    throw new PrologError('evaluation_error(undefined)');
+  }
   else if (name === '+') value = x + y;
   else if (name === '-') value = x - y;
   else if (name === '*') value = x * y;
@@ -152,6 +210,22 @@ export function compareArithmeticValues(left, right) {
   if (right.integer) return -compareIntegerToFloat(b, a);
   return a < b ? -1 : a > b ? 1 : 0;
 }
+
+function compareStrictIsoArithmeticValues(left, right) {
+  if (left.integer === right.integer) return compareArithmeticValues(left, right);
+
+  // ISO/IEC 13211-1:1995 8.7 specifies mixed arithmetic comparisons by
+  // floatI->F conversion of the integer operand.  That conversion can round
+  // an otherwise exact integer and can itself overflow.  Normal EyeProlog
+  // deliberately keeps its later exact cross-type comparison extension; the
+  // strict profile follows the Part 1 operation table.
+  const leftValue = left.integer ? Number(left.value) : left.value;
+  const rightValue = right.integer ? Number(right.value) : right.value;
+  if (!Number.isFinite(leftValue) || !Number.isFinite(rightValue)) {
+    throw new PrologError('evaluation_error(float_overflow)');
+  }
+  return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
 export function* isBuiltin({ solver, goal, env }) {
   const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env, { isoStrict: solver?.isoStrict === true }));
   const next = env.clone();
@@ -162,7 +236,9 @@ export function arithmeticComparison(test) {
     const options = { isoStrict: solver?.isoStrict === true };
     const left = evaluateArithmetic(goal.args[0], env, options);
     const right = evaluateArithmetic(goal.args[1], env, options);
-    const cmp = compareArithmeticValues(left, right);
+    const cmp = solver?.isoStrict === true
+      ? compareStrictIsoArithmeticValues(left, right)
+      : compareArithmeticValues(left, right);
     if (test(cmp)) yield env;
   };
 }

package/src/iso.js

@@ -415,11 +415,19 @@ function* functorBuiltin({ goal, env }) {
 }
 
 function* argBuiltin({ goal, env }) {
-  const index = requireInteger(goal.args[0], env);
+  const indexTerm = deref(goal.args[0], env);
   const term = deref(goal.args[1], env);
+  // ISO 8.5.2.3 prescribes both instantiation checks before either type
+  // check.  In particular arg(a, X, _) is an instantiation error because
+  // the second argument is still a variable.
+  if (indexTerm.type === VAR) throw new PrologError('instantiation_error');
   if (term.type === VAR) throw new PrologError('instantiation_error');
+  if (indexTerm.type !== NUMBER || !isDecimalInteger(indexTerm.name)) {
+    throw new PrologError('type_error(integer)', indexTerm);
+  }
   if (term.type !== COMPOUND) throw new PrologError('type_error(compound)', term);
-  if (index < 0n) throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[0], env));
+  const index = BigInt(indexTerm.name);
+  if (index < 0n) throw new PrologError('domain_error(not_less_than_zero)', indexTerm);
   if (index === 0n || index > BigInt(term.arity)) return;
   const next = env.clone();
   if (unify(goal.args[2], term.args[Number(index) - 1], next)) yield next;
@@ -537,7 +545,7 @@ function* clauseBuiltin({ solver, goal, env }) {
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
   // ISO 8.8.1.3 places private-procedure access before Body callability.
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) ||
+  if (isProcessorStaticProcedure(solver, head) ||
       (solver.isoStrict && group && !group.dynamic)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
   }
@@ -581,9 +589,19 @@ function isGrammarRuleProcedure(solver, head) {
   return !solver.isoStrict && head.name === '-->' && head.arity === 2;
 }
 
+function isProcessorStaticProcedure(solver, head) {
+  // Conjunction is an ISO control construct (7.5/Table 9) but is executed
+  // directly by the solver rather than through the builtin registry.  Keep it
+  // in the same protected static/private family as the registered Part 1
+  // control constructs for runtime database operations.
+  return Boolean(solver.registry.get(head.name, head.arity)) ||
+    isGrammarRuleProcedure(solver, head) ||
+    (solver.isoStrict && head.name === ',' && head.arity === 2);
+}
+
 function assertModifiable(solver, head, module = 'user') {
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? module);
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) || (group && !group.dynamic)) {
+  if (isProcessorStaticProcedure(solver, head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
 }
@@ -610,7 +628,7 @@ function* retractBuiltin({ solver, goal, env }) {
   const parts = clauseParts(goal.args[0], env);
   requireClauseHead(parts.head);
   const group = solver.program.findGroup(parts.head.name, parts.head.arity, parts.head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(parts.head.name, parts.head.arity) || isGrammarRuleProcedure(solver, parts.head) || (group && !group.dynamic)) {
+  if (isProcessorStaticProcedure(solver, parts.head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(parts.head));
   }
   if (!group) return;
@@ -633,7 +651,7 @@ function* retractAllBuiltin({ solver, goal, env }) {
   const head = deref(goal.args[0], env);
   requireClauseHead(head);
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) || (group && !group.dynamic)) {
+  if (isProcessorStaticProcedure(solver, head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
   if (group) {
@@ -667,7 +685,7 @@ function* abolishBuiltin({ solver, goal, env }) {
   const target = predicateIndicatorParts(goal.args[0], env);
   const module = goal.module ?? 'user';
   const group = solver.program.findGroup(target.name, target.arity, module);
-  if (solver.registry.get(target.name, target.arity) || isGrammarRuleProcedure(solver, target) || (group && !group.dynamic)) {
+  if (isProcessorStaticProcedure(solver, target) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', target.indicator);
   }
   solver.program.abolishDynamicGroup(target.name, target.arity, module);
@@ -815,8 +833,14 @@ function conversionCharacter(term, env, current = false, solver = null) {
   return value;
 }
 function* charConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env, false, solver);
-  const output = conversionCharacter(goal.args[1], env, false, solver);
+  // ISO 8.14.5.3 checks both arguments for instantiation before testing
+  // either character representation.
+  const inputTerm = deref(goal.args[0], env);
+  const outputTerm = deref(goal.args[1], env);
+  if (inputTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (outputTerm.type === VAR) throw new PrologError('instantiation_error');
+  const input = conversionCharacter(inputTerm, env, false, solver);
+  const output = conversionCharacter(outputTerm, env, false, solver);
   if (input.name === output.name) solver.charConversions.delete(input.name);
   else solver.charConversions.set(input.name, output.name);
   yield env;
@@ -970,7 +994,7 @@ function* openBuiltin({ solver, goal, env }) {
   if (!['read', 'write', 'append'].includes(mode.name)) throw new PrologError('domain_error(io_mode)', mode);
   const options = goal.arity === 3 ? {} : openOptions(optionTerm, env);
   if (options.alias && solver.io.resolve(options.alias)) {
-    throw new PrologError('permission_error(open, source_sink)', atom(options.alias));
+    throw new PrologError('permission_error(open, source_sink)', compound('alias', [atom(options.alias)]));
   }
   let stream;
   try {
@@ -1689,11 +1713,16 @@ function* atomLengthBuiltin({ goal, env }) {
 }
 
 function* atomConcatBuiltin({ goal, env }) {
-  const first = resolvedOrVariable(goal.args[0], env, ATOM);
-  const second = resolvedOrVariable(goal.args[1], env, ATOM);
-  const whole = resolvedOrVariable(goal.args[2], env, ATOM);
+  const first = deref(goal.args[0], env);
+  const second = deref(goal.args[1], env);
+  const whole = deref(goal.args[2], env);
+  // ISO 8.16.2.3 puts the two under-instantiation modes ahead of all atom
+  // type diagnostics.
   if (first.type === VAR && whole.type === VAR) throw new PrologError('instantiation_error');
   if (second.type === VAR && whole.type === VAR) throw new PrologError('instantiation_error');
+  if (first.type !== VAR && first.type !== ATOM) throw new PrologError('type_error(atom)', first);
+  if (second.type !== VAR && second.type !== ATOM) throw new PrologError('type_error(atom)', second);
+  if (whole.type !== VAR && whole.type !== ATOM) throw new PrologError('type_error(atom)', whole);
 
   const candidates = [];
   if (whole.type === ATOM && first.type === VAR && second.type === VAR) {
@@ -1713,23 +1742,33 @@ function* atomConcatBuiltin({ goal, env }) {
   }
 }
 
-function optionalNonNegativeInteger(term, env) {
+function optionalInteger(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) return null;
   if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
-  const integer = BigInt(value.name);
-  if (integer < 0n) throw new PrologError('domain_error(not_less_than_zero)', value);
-  return integer;
+  return BigInt(value.name);
 }
 
 function* subAtomBuiltin({ goal, env }) {
   const source = deref(goal.args[0], env);
   if (source.type === VAR) throw new PrologError('instantiation_error');
   if (source.type !== ATOM) throw new PrologError('type_error(atom)', source);
-  const sub = resolvedOrVariable(goal.args[4], env, ATOM);
-  const before = optionalNonNegativeInteger(goal.args[1], env);
-  const length = optionalNonNegativeInteger(goal.args[2], env);
-  const after = optionalNonNegativeInteger(goal.args[3], env);
+  const sub = deref(goal.args[4], env);
+  if (sub.type !== VAR && sub.type !== ATOM) throw new PrologError('type_error(atom)', sub);
+  // ISO 8.16.3.3 prescribes all type checks before the non-negative domain
+  // checks, in Before/Length/After order.
+  const before = optionalInteger(goal.args[1], env);
+  const length = optionalInteger(goal.args[2], env);
+  const after = optionalInteger(goal.args[3], env);
+  if (before != null && before < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[1], env));
+  }
+  if (length != null && length < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[2], env));
+  }
+  if (after != null && after < 0n) {
+    throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[3], env));
+  }
   const chars = characters(source.name);
   for (let start = 0; start <= chars.length; start++) {
     if (before != null && before !== BigInt(start)) continue;
@@ -1770,9 +1809,14 @@ function validCharacterCode(value, solver = null) {
 }
 
 function listToAtomInput(list, env, kind, solver = null) {
+  const whole = deref(list, env);
   const { items, tail } = listElements(list, env);
-  if (tail.type === VAR || items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
-  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', list);
+  // Corrigendum 2 distinguishes a partial list from an improper one: only
+  // the former precedes the complete-list type check. Variables in a proper
+  // list prefix are checked after that list-shape diagnostic.
+  if (tail.type === VAR) throw new PrologError('instantiation_error');
+  if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', whole);
+  if (items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
   if (kind === 'chars') {
     const invalid = items.find((item) => !oneChar(item));
     if (invalid) throw new PrologError('type_error(character)', invalid);
@@ -1968,7 +2012,14 @@ function numberListText(list, env, kind, valueIsBound, solver = null) {
   const whole = deref(list, env);
   const { items, tail } = listElements(list, env);
   const proper = tail.type === ATOM && tail.name === '[]';
+  // Corrigendum 2 orders conversion-mode instantiation errors specially:
+  // a partial list is diagnosed before its fixed prefix, while an improper
+  // non-list is diagnosed before a variable element in that prefix.
+  if (!valueIsBound && tail.type === VAR) throw new PrologError('instantiation_error');
   if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
+  if (!valueIsBound && items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
 
   const invalid = items.find((item) => item.type !== VAR &&
     (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item, solver)));
@@ -1981,7 +2032,6 @@ function numberListText(list, env, kind, valueIsBound, solver = null) {
   }
 
   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

package/test/conformance/ISO-COMPLIANCE.md

@@ -33,15 +33,15 @@ error-ordering alternative to an individual executable assertion.
 | Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and strict ASCII PCS/collation boundary tests. The implementation-defined 6.5/6.6 character-model decisions are now closed; wider shall-by-shall lexical mapping remains open. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates, plus strict checks for the required `variable < float < integer < atom < compound` type order, PCS-based atom collation, and the finite `max_arity` representation boundary used by term construction. |
 | 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. Preparation-time `char_conversion/2` affects later unquoted source text and respects `char_conversion=off`. Strict preparation now enforces declaration-before-clause ordering for `dynamic/1`, `multifile/1`, and `discontiguous/1`, cross-text `multifile/1`, discontiguous clause grouping, empty declared procedures, include textual-replacement behavior, and one-time initialization per prepared program. The remaining shall-by-shall mapping is still open. |
-| 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; focused strict checks now cover `current_predicate/1`, `clause/2`, `asserta/1`, `assertz/1`, `retract/1`, Corrigendum 2 `retractall/1`, and `abolish/1` errors plus empty-procedure lifetime. The remaining clause-conversion shall-by-shall mapping is still open. |
+| 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; focused strict checks now cover `current_predicate/1`, `clause/2`, `asserta/1`, `assertz/1`, `retract/1`, Corrigendum 2 `retractall/1`, and `abolish/1` errors plus empty-procedure lifetime, including runtime protection of the solver-native conjunction control construct `','/2`. The remaining clause-conversion shall-by-shall mapping is still open. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. |
-| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
-| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The audit now also covers write-mode creation/truncation, append creation, repositioned overwrite, flushing, EOF actions, close/current-stream handling, strict stream-position terms, stream-property validation, stream-term requirements, and text-vs-binary permission errors. The full option/mode cross-product is still being mapped. |
+| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now also pins direct-variable precedence, arithmetic operand type errors, float-only rounding conversions, zero-to-negative-power undefined errors, and the Part 1 mixed integer/float comparison conversion rule. Exceptional-value/error-precedence mapping remains to be exhaustively enumerated. |
+| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The audit now also covers write-mode creation/truncation, append creation, repositioned overwrite, flushing, EOF actions, close/current-stream handling, strict stream-position terms, stream-property validation, stream-term requirements, text-vs-binary permission errors, and the prescribed `alias(A)` culprit for `open/4` alias collisions. The full option/mode cross-product is still being mapped. |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. Strict mode excludes the EyeProlog `occurs_check` extension. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Exact ISO 8.14.1-8.14.4 error precedence is covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors, Corrigendum 2 `keysort/2` errors, and arithmetic culprit reporting. A complete one-row-per-prescribed-error ordering map remains open. |
-| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, and closed 8.17 flags. The remaining mode/error matrix is not yet one-row-per-standard-row. |
-| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, and reports unknown zero-arity evaluables with the required `F/0` culprit shape. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
+| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Exact ISO 8.14.1-8.14.4 error precedence is covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors (including the complete `alias(A)` culprit for `open/4` alias collisions), Corrigendum 2 `keysort/2` errors, atomic-conversion list-shape precedence, `arg/3`, `atom_concat/3`, `sub_atom/5`, `char_conversion/2`, runtime control-construct database protection, and arithmetic culprit/precedence reporting. A complete one-row-per-prescribed-error ordering map remains open. |
+| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, closed 8.17 flags, and additional prescribed precedence for `arg/3`, `atom_concat/3`, `sub_atom/5`, number/atom list conversions, and `char_conversion/2`. The remaining mode/error matrix is not yet one-row-per-standard-row. |
+| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, enforces the Part 1 numeric/integer operand errors and float-only rounding modes, and uses the Part 1 integer-to-float conversion rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison extension. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -119,6 +119,22 @@ argument as the culprit of `type_error(list, List)`, as required by the
 Corrigendum 2 replacement error clauses. Dedicated strict-core regressions pin
 both behaviors.
 
+
+The following Part 1 pass tightens more of the still-open prescribed-error and
+arithmetic matrix. `arg/3`, `atom_concat/3`, `sub_atom/5`, `number_chars/2`,
+`number_codes/2`, and `char_conversion/2` now follow the standard ordering when
+multiple error conditions are simultaneously present. Corrigendum 2 partial
+versus improper list distinctions are applied consistently to atomic and
+number conversion. Clause 9 strict evaluation now gives the prescribed
+number/integer operand diagnostics, checks direct-variable instantiation first,
+enforces the float-only input modes of `floor/1`, `truncate/1`, `round/1`, and
+`ceiling/1`, and reports zero raised to a negative power as undefined. Finally,
+strict mixed integer/float arithmetic comparisons perform the Part 1
+integer-to-float conversion (including `float_overflow`); normal EyeProlog keeps
+its exact cross-type comparison as an extension. Dedicated strict regressions
+cover these distinctions without changing the normal-profile arithmetic error
+contract.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does

package/test/conformance/ISO-MATRIX.md

@@ -11,14 +11,14 @@ compliance audit and the remaining work before a full conformance claim.
 | Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, strict ASCII PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
-| 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `functor/3` / `=../2` error-order plus max-arity checks |
+| 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases, Corrigendum 2 `keysort/2` variable/non-pair errors, and strict `arg/3`, `functor/3` / `=../2` error-order plus max-arity checks |
 | 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors |
-| 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`, plus strict clause/database error and all-solutions precedence checks |
-| 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, strict 8.14.1-8.14.4 option/error-order tests, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, and open/close semantics |
+| 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`, plus strict clause/database error and all-solutions precedence checks, including runtime static/private protection for the solver-native conjunction control construct |
+| 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, strict 8.14.1-8.14.4 option/error-order tests, Corrigendum 3 variable metadata/write naming checks, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, open/close semantics, and the exact `alias(A)` collision culprit |
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus strict Corrigendum 2 resulting-goal `max_arity` error coverage |
-| 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, and strict Corrigendum 2 improper-list culprit checks for `atom_chars/2` and `atom_codes/2` |
-| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, and the strict complete-flag audit in `run-iso-strict.mjs` |
-| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension and zero-arity unknown-evaluable error checks |
+| 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, strict Corrigendum 2 partial/improper-list precedence for atom/number conversions, and prescribed `atom_concat/3` / `sub_atom/5` ordering checks |
+| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, strict `char_conversion/2` precedence, and the complete strict flag audit in `run-iso-strict.mjs` |
+| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and negative-power errors, float-only rounding modes, and Part 1 mixed integer/float comparison conversion |
 | Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
 | Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 

package/test/run-iso-strict.mjs

@@ -183,6 +183,15 @@ export function runIsoStrict(reporter = new TestReporter()) {
     includes(ignoredNonVariable.stdout, 'x', 'non-variable right side is permitted and ignored');
   });
 
+  reporter.test('reports the complete alias option in open/4 alias collisions', () => {
+    const error = capture(() => run('', {
+      isoStrict: true,
+      goal: 'open(dummy,write,_,[alias(user_input)])',
+    }));
+    equal(error.formal, 'permission_error(open, source_sink)', 'formal error');
+    includes(error.message, 'alias(user_input)', 'alias option culprit');
+  });
+
   reporter.test('follows the ISO 8.14.1.3 read_term/3 error order', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,[X])' })).formal,
       'instantiation_error', 'partial/variable option before stream domain');
@@ -243,6 +252,60 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'type_error(atom)', 'operator type');
   });
 
+  reporter.test('follows remaining Part 1 built-in error precedence', () => {
+    const cases = [
+      ['arg(a,X,_)', 'instantiation_error', 'arg/3 second-argument instantiation before index type'],
+      ['atom_concat(1,X,Y)', 'instantiation_error', 'atom_concat/3 second/whole under-instantiation before first type'],
+      ['atom_concat(X,1,Y)', 'instantiation_error', 'atom_concat/3 first/whole under-instantiation before second type'],
+      ['sub_atom(a,-1,bad,_,_)', 'type_error(integer)', 'sub_atom/5 integer type before non-negative domain'],
+      ['number_chars(N,[1|T])', 'instantiation_error', 'number_chars/2 partial list before element type'],
+      ['number_chars(N,[X,1])', 'instantiation_error', 'number_chars/2 variable element before later element type'],
+      ['number_codes(N,[foo|T])', 'instantiation_error', 'number_codes/2 partial list before element type'],
+      ['number_codes(N,[X,foo])', 'instantiation_error', 'number_codes/2 variable element before later element type'],
+      ['atom_chars(A,[X|foo])', 'type_error(list)', 'atom_chars/2 improper list before prefix variable'],
+      ['atom_codes(A,[X|foo])', 'type_error(list)', 'atom_codes/2 improper list before prefix variable'],
+      ['char_conversion(foo,X)', 'instantiation_error', 'char_conversion/2 output instantiation before input representation'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+  });
+
+  reporter.test('follows Part 1 arithmetic type and exceptional errors', () => {
+    const cases = [
+      ["X is '+'(foo,77)", 'type_error(number)', 'simple arithmetic atomic operand'],
+      ['X is mod(foo,77)', 'type_error(number)', 'integer arithmetic non-number operand'],
+      ['X is mod(7.5,2)', 'type_error(integer)', 'integer arithmetic numeric type'],
+      ['X is truncate(foo)', 'type_error(number)', 'rounding non-number operand'],
+      ['X is sin(foo)', 'type_error(number)', 'transcendental non-number operand'],
+      ['X is foo+Y', 'instantiation_error', 'direct variable before another operand error'],
+      ['X is floor(7)', 'type_error(float)', 'floor integer operand'],
+      ['X is truncate(7)', 'type_error(float)', 'truncate integer operand'],
+      ['X is round(7)', 'type_error(float)', 'round integer operand'],
+      ['X is ceiling(7)', 'type_error(float)', 'ceiling integer operand'],
+      ['X is 0 ** -1', 'evaluation_error(undefined)', 'power zero negative exponent'],
+      ['X is 0.0 ^ -1', 'evaluation_error(undefined)', 'Corrigendum 2 power zero negative exponent'],
+    ];
+    for (const [goal, formal, label] of cases) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal, formal, label);
+    }
+  });
+
+  reporter.test('uses the Part 1 mixed arithmetic comparison operations', () => {
+    // 8.7 converts the integer operand to float in mixed comparisons.
+    equal(run('', { isoStrict: true, goal: '18014398509481985 =:= 18014398509481984.0' }).stats.completed_goal_lists,
+      1, 'mixed equality after float conversion');
+    equal(run('', { isoStrict: true, goal: '\\+ (18014398509481985 > 18014398509481984.0)' }).stats.completed_goal_lists,
+      1, 'mixed ordering after float conversion');
+    const huge = `1${'0'.repeat(400)}`;
+    equal(capture(() => run('', { isoStrict: true, goal: `${huge} > 1.0` })).formal,
+      'evaluation_error(float_overflow)', 'mixed integer-to-float overflow');
+
+    // The normal profile retains EyeProlog's exact cross-type extension.
+    equal(run('', { goal: '9007199254740993 > 9007199254740992.0' }).stats.completed_goal_lists,
+      1, 'normal exact mixed ordering extension');
+  });
+
   reporter.test('follows ISO term-construction error types and precedence', () => {
     equal(capture(() => run('', { isoStrict: true, goal: 'functor(_,foo(a),1)' })).formal,
       'type_error(atomic)', 'functor compound name');
@@ -322,6 +385,21 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(answers.length, 1, 'answer count');
   });
 
+  reporter.test('protects conjunction as an ISO static/private control construct at runtime', () => {
+    for (const goal of [
+      "asserta(','(a,b))",
+      "assertz(','(a,b))",
+      "retract(','(a,b))",
+      "retractall(','(a,b))",
+      "abolish('/'(',',2))",
+    ]) {
+      equal(capture(() => run('', { isoStrict: true, goal })).formal,
+        'permission_error(modify, static_procedure)', goal);
+    }
+    equal(capture(() => run('', { isoStrict: true, goal: "clause(','(a,b),_)" })).formal,
+      'permission_error(access, private_procedure)', 'clause/2 conjunction access');
+  });
+
   reporter.test('covers ISO database predicate errors and empty-procedure lifetime', () => {
     const errors = [
       ['current_predicate(4)', '', 'type_error(predicate_indicator)'],