eyeprolog 1.3.43 → 1.3.44

package/README.md

@@ -218,6 +218,13 @@ raise representation errors in strict parsing and character operations. Normal
 mode retains Unicode scalar character data as an implementation-specific
 extension.
 
+Strict term I/O likewise keeps the standardized option boundary: `read_term/2-3`
+and `write_term/2-3` accept the Part 1 plus Corrigendum 3 options, while the
+normal-profile `write_term(...,[double_quotes(...)])` option remains an
+EyeProlog extension. The strict gate also checks the prescribed ISO error
+precedence for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`, and
+the complete Part 1 flag defaults/value domains/changeability rules.
+
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
 The ISO 5.4 implementation-defined/implementation-specific decision index is

package/package.json

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

package/src/iso.js

@@ -690,44 +690,49 @@ function* setPrologFlagBuiltin({ solver, goal, env }) {
 
 const operatorSpecifiers = new Set(['fx', 'fy', 'xf', 'yf', 'xfx', 'xfy', 'yfx']);
 
-function operatorPriority(term, env) {
+function opListPreflight(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
-  const priority = BigInt(value.name);
-  if (priority < 0n || priority > 1200n) throw new PrologError('domain_error(operator_priority)', value);
-  return Number(priority);
+  if (value.type === ATOM) return { value, items: [value], proper: true, atom: true };
+  const { items, tail } = listElements(value, env);
+  if (tail.type === VAR || items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
+  const proper = tail.type === ATOM && tail.name === '[]';
+  return { value, items, proper, atom: false };
 }
 
-function operatorSpecifier(term, env) {
-  const value = deref(term, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
-  if (!operatorSpecifiers.has(value.name)) throw new PrologError('domain_error(operator_specifier)', value);
-  return value.name;
-}
+function* opBuiltin({ solver, goal, env }) {
+  const priorityTerm = deref(goal.args[0], env);
+  const specifierTerm = deref(goal.args[1], env);
 
-function operatorNames(term, env) {
-  const value = deref(term, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type === ATOM) return [value];
-  const items = properListItems(value, env);
-  if (items == null) {
-    if (isPartialList(value, env)) throw new PrologError('instantiation_error');
-    throw new PrologError('type_error(list)', value);
+  // ISO 8.14.3.3 prescribes the ordering below.  In particular, all three
+  // instantiation cases precede type/domain errors, and Operator list-shape
+  // errors precede priority/specifier domain errors.
+  if (priorityTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (specifierTerm.type === VAR) throw new PrologError('instantiation_error');
+  const operator = opListPreflight(goal.args[2], env);
+
+  if (priorityTerm.type !== NUMBER || !isDecimalInteger(priorityTerm.name)) {
+    throw new PrologError('type_error(integer)', priorityTerm);
   }
-  for (const item of items) {
-    const resolved = deref(item, env);
-    if (resolved.type === VAR) throw new PrologError('instantiation_error');
-    if (resolved.type !== ATOM) throw new PrologError('type_error(atom)', resolved);
+  if (specifierTerm.type !== ATOM) throw new PrologError('type_error(atom)', specifierTerm);
+  if (!operator.atom && !operator.proper) throw new PrologError('type_error(list)', operator.value);
+  for (const item of operator.items) {
+    if (item.type !== ATOM) throw new PrologError('type_error(atom)', item);
   }
-  return items.map((item) => deref(item, env));
-}
 
-function* opBuiltin({ solver, goal, env }) {
-  const priority = operatorPriority(goal.args[0], env);
-  const specifier = operatorSpecifier(goal.args[1], env);
-  for (const name of operatorNames(goal.args[2], env)) {
+  const priorityBig = BigInt(priorityTerm.name);
+  if (priorityBig < 0n || priorityBig > 1200n) {
+    throw new PrologError('domain_error(operator_priority)', priorityTerm);
+  }
+  if (!operatorSpecifiers.has(specifierTerm.name)) {
+    throw new PrologError('domain_error(operator_specifier)', specifierTerm);
+  }
+
+  const priority = Number(priorityBig);
+  const specifier = specifierTerm.name;
+  for (const name of operator.items) {
     if (name.name === ',') {
       throw new PrologError('permission_error(modify, operator)', name);
     }
@@ -755,19 +760,16 @@ function* currentOpBuiltin({ solver, goal, env }) {
   const priority = deref(goal.args[0], env);
   const specifier = deref(goal.args[1], env);
   const name = deref(goal.args[2], env);
-  if (priority.type !== VAR) {
-    if (priority.type !== NUMBER || !isDecimalInteger(priority.name)) {
-      throw new PrologError('type_error(integer)', priority);
-    }
-    if (BigInt(priority.name) < 0n || BigInt(priority.name) > 1200n) {
-      throw new PrologError('domain_error(operator_priority)', priority);
-    }
+  // ISO 8.14.4.3 defines the first two argument errors by domain, not by
+  // their underlying atom/integer representation type.
+  if (priority.type !== VAR &&
+      (priority.type !== NUMBER || !isDecimalInteger(priority.name) ||
+       BigInt(priority.name) < 0n || BigInt(priority.name) > 1200n)) {
+    throw new PrologError('domain_error(operator_priority)', priority);
   }
-  if (specifier.type !== VAR) {
-    if (specifier.type !== ATOM) throw new PrologError('type_error(atom)', specifier);
-    if (!operatorSpecifiers.has(specifier.name)) {
-      throw new PrologError('domain_error(operator_specifier)', specifier);
-    }
+  if (specifier.type !== VAR &&
+      (specifier.type !== ATOM || !operatorSpecifiers.has(specifier.name))) {
+    throw new PrologError('domain_error(operator_specifier)', specifier);
   }
   if (name.type !== VAR && name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   for (const definition of solver.program.operators.values()) {
@@ -849,6 +851,28 @@ function optionList(term, env) {
   return items.map((item) => deref(item, env));
 }
 
+// read_term/3 and write_term/3 have prescribed error ordering in ISO 8.14.
+// In particular, a partial option list (or a variable option element) is
+// diagnosed before several stream errors, while the relative order of a
+// non-list Options term and an invalid stream-or-alias differs between the
+// read and write predicates.  Split list-shape inspection from full option
+// validation so those predicates can follow the standard order exactly.
+function preflightOptionList(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  const { items, tail } = listElements(value, env);
+  if (tail.type === VAR || items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
+  const proper = tail.type === ATOM && tail.name === '[]';
+  return { value, items, proper };
+}
+
+function requireProperOptionList(preflight) {
+  if (!preflight.proper) throw new PrologError('type_error(list)', preflight.value);
+  return preflight.items;
+}
+
 function optionAtom(option, name) {
   if (option.type !== COMPOUND || option.name !== name || option.arity !== 1) return null;
   return option.args[0];
@@ -1306,17 +1330,38 @@ function* readBuiltin({ solver, goal, env }) {
   const { term } = readTermFromStream(stream, solver);
   if (unify(goal.args[goal.arity - 1], term, next)) yield next;
 }
+function validateReadOptions(options) {
+  for (const option of options) {
+    if (option.type !== COMPOUND || option.arity !== 1 ||
+        !['variables', 'variable_names', 'singletons'].includes(option.name)) {
+      throw new PrologError('domain_error(read_option)', option);
+    }
+  }
+}
+
 function* readTermBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
+  const optionTerm = goal.args[goal.arity - 1];
+  const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
+
+  // ISO 8.14.1.3 error order:
+  // a) variable stream; b) partial/options-variable; c) bad stream-or-alias;
+  // d) non-list options; e) invalid read option; then stream existence/mode.
+  if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  if (goal.arity === 3) streamReference(goal.args[0], env);
+  const options = requireProperOptionList(preflight);
+  validateReadOptions(options);
+
+  const stream = goal.arity === 2
+    ? solver.io.resolve(solver.io.currentInput)
+    : requireStream(solver, goal.args[0], env, 'read');
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
-  const options = optionList(goal.args[goal.arity - 1], env);
+
   const target = goal.args[goal.arity - 2];
   const { term, variables } = readTermFromStream(stream, solver);
   const next = env.clone();
   if (!unify(target, term, next)) return;
   for (const option of options) {
-    if (option.type === VAR) throw new PrologError('instantiation_error');
-    if (option.type !== COMPOUND || option.arity !== 1) throw new PrologError('domain_error(read_option)', option);
     let value;
     if (option.name === 'variables') {
       value = listFromItems(variables.map((item) => item.term));
@@ -1324,12 +1369,10 @@ function* readTermBuiltin({ solver, goal, env }) {
       value = listFromItems(variables
         .filter((item) => !item.anonymous)
         .map((item) => compound('=', [atom(item.sourceName), item.term])));
-    } else if (option.name === 'singletons') {
+    } else {
       value = listFromItems(variables
         .filter((item) => !item.anonymous && item.count === 1)
         .map((item) => compound('=', [atom(item.sourceName), item.term])));
-    } else {
-      throw new PrologError('domain_error(read_option)', option);
     }
     if (!unify(option.args[0], value, next)) return;
   }
@@ -1378,23 +1421,26 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptions(term, env, mode = 'write_term') {
+function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null) {
   const result = defaultTermWriteOptions(mode);
-  for (const option of optionList(term, env)) {
-    if (option.type === VAR) throw new PrologError('instantiation_error');
+  for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
       throw new PrologError('domain_error(write_option)', option);
     }
     if (option.name === 'quoted') result.quoted = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'ignore_ops') result.ignoreOps = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'numbervars') result.numbervars = writeOptionBoolean(option.args[0], env, option);
-    else if (option.name === 'double_quotes') result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'variable_names') result.variableNames = writeVariableNames(option.args[0], env, option);
-    else throw new PrologError('domain_error(write_option)', option);
+    else if (option.name === 'double_quotes' && !solver?.isoStrict) {
+      result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
+    } else {
+      throw new PrologError('domain_error(write_option)', option);
+    }
   }
   return result;
 }
 
+
 function writeBuiltin(mode) {
   return function* ({ solver, goal, env }) {
     const stream = outputStreamFor(solver, goal, env);
@@ -1410,9 +1456,22 @@ function writeBuiltin(mode) {
   };
 }
 function* writeTermBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentOutput) : requireStream(solver, goal.args[0], env, 'write');
+  const optionTerm = goal.args[goal.arity - 1];
+  const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
+
+  // ISO 8.14.2.3 error order:
+  // a) variable stream; b) partial/options-variable; c) non-list options;
+  // d) bad stream-or-alias; e) invalid write option; then stream errors.
+  if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  const optionItems = requireProperOptionList(preflight);
+  if (goal.arity === 3) streamReference(goal.args[0], env);
+  const options = termWriteOptionsFromItems(optionItems, env, 'write_term', solver);
+
+  const stream = goal.arity === 2
+    ? solver.io.resolve(solver.io.currentOutput)
+    : requireStream(solver, goal.args[0], env, 'write');
   if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
-  const options = termWriteOptions(goal.args[goal.arity - 1], env);
   if (options.doubleQuotes === true) {
     options.doubleQuotes = solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars';
   } else {

package/src/solver.js

@@ -951,12 +951,12 @@ const ISO_CORE_FLAG_NAMES = new Set([
 
 function defaultPrologFlags(unknown = 'error', strictIso = false) {
   const flags = new Map([
-    ['bounded', { value: compound('false', []), allowed: ['false'], changeable: false }],
-    ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['toward_zero'], changeable: false }],
+    ['bounded', { value: compound('false', []), allowed: ['true', 'false'], changeable: false }],
+    ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['down', 'toward_zero'], changeable: false }],
     ['char_conversion', { value: compound('on', []), allowed: ['on', 'off'], changeable: true }],
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
-    ['max_integer', { value: null, allowed: ['unbounded'], changeable: false }],
-    ['min_integer', { value: null, allowed: ['unbounded'], changeable: false }],
+    ['max_integer', { value: null, allowed: [], changeable: false }],
+    ['min_integer', { value: null, allowed: [], changeable: false }],
     ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],

package/test/conformance/ISO-COMPLIANCE.md

@@ -37,10 +37,10 @@ error-ordering alternative to an individual executable assertion.
 | 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, Corrigendum 3 writer cases. Full option cross-product remains open. |
-| 7.11 — flags | audit | Required Part 1 flags implemented. Normal and strict modes use the ISO `unknown=error` default; strict mode excludes the EyeProlog `occurs_check` extension. With `bounded=false`, `max_integer` and `min_integer` correctly have no current value. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Complete prescribed-error ordering 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. Mode/error matrix is not yet one-row-per-standard-row. |
+| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The Part 1/Corrigendum 3 `read_term/2-3` and `write_term/2-3` option surfaces and ISO 8.14.1-8.14.2 prescribed error ordering now have dedicated strict tests; the wider stream/open/close option cross-product remains open. |
+| 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 now covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; prescribed ordering for the remaining built-in families is still being mapped. |
+| 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 8.14 term-I/O/operator subfamily now has dedicated strict option-surface and prescribed-error-order assertions, and 8.17 flag behavior is closed; 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. Host floating-point representation choices remain documented implementation-defined behavior. |
 | 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. |
@@ -69,6 +69,18 @@ normal profile retains Unicode scalar character data as an explicit extension.
 The complete WG17 syntax matrix remains green under this narrower strict
 boundary.
 
+A further issue #65 audit closes the Part 1 flag family and tightens the 8.14
+term-I/O/operator error rules. The strict flag registry now distinguishes a
+standard value that is valid but not selectable from a value outside the
+standard domain: attempts to change fixed `bounded` or
+`integer_rounding_function` to another standard value therefore reach the
+required permission error. `read_term/3`, `write_term/3`, `op/3`, and
+`current_op/3` now follow their prescribed error precedence, including cases
+where more than one argument is erroneous. Strict `write_term/2-3` accepts only
+the Part 1 plus Corrigendum 3 option surface; the normal-profile
+`double_quotes/1` write option remains an explicitly documented EyeProlog
+extension.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -58,10 +58,10 @@ Status values are:
 | 7.10.2.11 | Default `eof_action` | Newly opened file streams default to `error`. The predefined standard streams use `reset`. | **defined** — `src/io.js`. |
 | 7.10.2.13 | `eof_action(Action)` property when the stream uses its default action | Reports the same selected action: `error` for ordinary opened files and `reset` for the predefined standard streams. | **defined** — `streamProperties()` in `src/iso.js`, defaults in `src/io.js`. |
 | 7.10.2.11 | Whether `reposition(false)` streams may nevertheless be repositioned | No. `set_stream_position/2` raises a permission error unless the stream was created with `reposition(true)`. | **defined** — `src/iso.js`. |
-| 7.11.1.1 | Default `bounded` flag | `false`: EyeProlog's Prolog integer model uses arbitrary-precision `BigInt`, subject to host resources. | **defined** — `defaultPrologFlags()` in `src/solver.js`. |
+| 7.11.1.1 | Default `bounded` flag | `false`: EyeProlog's Prolog integer model uses arbitrary-precision `BigInt`, subject to host resources. The standard values remain `true` and `false`; because this flag is fixed, selecting either value through `set_prolog_flag/2` reaches the standard non-changeable-flag rule rather than narrowing the value domain to the current choice. | **defined** — `defaultPrologFlags()` in `src/solver.js`; strict flag tests. |
 | 7.11.1.2 | Default `max_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(max_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
 | 7.11.1.3 | Default `min_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(min_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
-| 7.11.1.4 | Default `integer_rounding_function` flag | `toward_zero`; `//` uses truncation toward zero. `div` is provided separately with downward/floor division semantics. | **defined** — `src/solver.js`, `src/iso-arithmetic.js`. |
+| 7.11.1.4 | Default `integer_rounding_function` flag | `toward_zero`; `//` uses truncation toward zero. The standard flag values are `down` and `toward_zero`, but the selected flag is non-changeable; an attempt to select the other valid value is therefore a permission error. `div` is provided separately with downward/floor division semantics. | **defined** — `src/solver.js`, `src/iso-arithmetic.js`; strict flag tests. |
 | 9.1.3.1 | Integer division rounding function `rndI` | Truncation toward zero, matching the `integer_rounding_function=toward_zero` flag. | **defined** — BigInt division for `//` in `src/iso-arithmetic.js`. |
 | 7.11.2.1 | Whether preparation-time `Convc` affects execution-time `Convc` | Yes: mappings created while Prolog text is prepared are retained and initialize the solver's execution-time conversion map. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`. |
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
@@ -69,7 +69,7 @@ Status values are:
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
 | 7.12.1 | Second argument of `error/2` | The default context term is the atom `eyeprolog`. A few implementation-specific diagnostics may deliberately supply a more specific context term. | **defined** — `formalErrorTerm()` in `src/iso.js`. |
 | 7.12.2(f) | Implementation-defined representation limits | Strict character and character-code operations are limited to the selected ASCII PCS/collating integers 0..127. Normal mode extends characters to Unicode scalar values. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
-| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag. With `bounded=false`, `max_integer` and `min_integer` have no current value and their `current_prolog_flag/2` queries fail. | **defined** — strict registry/flag filtering in `src/solver.js`. |
+| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag. With `bounded=false`, `max_integer` and `min_integer` have no current or selectable value and their `current_prolog_flag/2` queries fail. Valid alternative values of fixed standard flags are distinguished from invalid values so `set_prolog_flag/2` reports permission versus domain errors as prescribed. | **defined** — strict registry/flag filtering in `src/solver.js`; strict flag tests. |
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |
 | 8.17.4 | Meaning/effects of `halt(Status)` | Integer `Status` is converted to the host process/runner halt code; it produces no Prolog solution. | **defined** — `haltBuiltin()`, `src/execute.js`, `src/cli.js`. |
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso-arithmetic.js`, `src/number-value.js`. |
@@ -116,7 +116,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Library/runtime extensions when registered outside the strict core | Strict arithmetic registry is the Part 1 + Corrigenda set. |
 | 5.5.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Strict core accepts the standard option names implemented for Part 1; invalid options follow Corrigendum 3 validation. |
+| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` option `double_quotes(true|false)`. Strict core excludes that extension and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/conformance/ISO-MATRIX.md

@@ -14,10 +14,10 @@ compliance audit and the remaining work before a full conformance claim.
 | 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 |
 | 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` |
-| 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.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, plus strict 8.14.1-8.14.4 option-surface/error-precedence tests for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3` |
 | 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, 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 |
+| 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` |
 | 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/conformance/README.md

@@ -21,7 +21,9 @@ predicate indicators listed in Appendix B of the book across the Part 1 strict-c
 target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
 processor-requirement ledger for the Part 1 strict-core audit. This suite is
 still not an independent certification of every processor requirement, lexical
-edge, option combination, or prescribed error precedence. Cases under `iso/`
+edge, or option combination. Selected prescribed-error sequences are now
+checked exactly (including ISO 8.14.1-8.14.4), while the remaining built-in
+error-order matrix is tracked in the compliance ledger. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core

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

@@ -1 +1 @@
-error(type_error(integer), 1.2)
+error(domain_error(operator_priority), 1.2)

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

@@ -1 +1 @@
-error(type_error(integer), x)
+error(domain_error(operator_priority), x)

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

@@ -1 +1 @@
-error(type_error(atom), 1)
+error(domain_error(operator_specifier), 1)

package/test/run-iso-strict.mjs

@@ -46,6 +46,41 @@ export function runIsoStrict(reporter = new TestReporter()) {
   });
 
 
+  reporter.test('covers the Part 1 flag defaults, value domains, and changeability', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    for (const goalText of [
+      'current_prolog_flag(bounded,false)',
+      'current_prolog_flag(integer_rounding_function,toward_zero)',
+      'current_prolog_flag(char_conversion,on)',
+      'current_prolog_flag(debug,off)',
+      'current_prolog_flag(max_arity,unbounded)',
+      'current_prolog_flag(unknown,error)',
+      'current_prolog_flag(double_quotes,chars)',
+    ]) equal(answers(goalText), 1, goalText);
+
+    for (const goalText of [
+      'set_prolog_flag(char_conversion,off)',
+      'set_prolog_flag(debug,on)',
+      'set_prolog_flag(unknown,fail)',
+      'set_prolog_flag(double_quotes,codes)',
+    ]) run('', { isoStrict: true, goal: goalText });
+
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(bounded,true)' })).formal,
+      'permission_error(modify, flag)', 'bounded valid-but-fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(integer_rounding_function,down)' })).formal,
+      'permission_error(modify, flag)', 'rounding valid-but-fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,unbounded)' })).formal,
+      'permission_error(modify, flag)', 'max_arity fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_integer,unbounded)' })).formal,
+      'domain_error(flag_value)', 'max_integer has no value when unbounded');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(unknown,maybe)' })).formal,
+      'domain_error(flag_value)', 'unknown value domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(not_a_flag,on)' })).formal,
+      'domain_error(prolog_flag)', 'unsupported flag');
+  });
+
   reporter.test('preparation-time char_conversion affects later unquoted source only', () => {
     const program = Program.parse(
       ":- char_conversion(x,y).\np(x).\nquoted('x').\n:- set_prolog_flag(char_conversion,off).\nraw(x).\n",
@@ -107,6 +142,77 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(result.stdout, "char_code('é', 233).\n", 'normal Unicode char_code/2');
   });
 
+  reporter.test('keeps the strict write-option surface to Part 1 plus Corrigendum 3', () => {
+    const strictError = capture(() => run('', {
+      isoStrict: true,
+      goal: 'write_term(a,[double_quotes(true)])',
+    }));
+    equal(strictError.formal, 'domain_error(write_option)', 'strict extension rejection');
+
+    const normal = run('', { goal: 'write_term("ab",[double_quotes(true)])' });
+    includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
+  });
+
+  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');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,foo)' })).formal,
+      'domain_error(stream_or_alias)', 'stream domain before non-list options');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(user_output,_,foo)' })).formal,
+      'type_error(list)', 'non-list options before stream permission');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(user_output,_,[bogus])' })).formal,
+      'domain_error(read_option)', 'invalid option before stream permission');
+    equal(capture(() => run('', { isoStrict: true, goal: "read_term('$stream'(999),_,[bogus])" })).formal,
+      'domain_error(read_option)', 'invalid option before stream existence');
+
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true, ioOptions: { input: 'a.' } });
+    const error = capture(() => [...solver.solve([
+      parseGoalText('read_term(user_input,_,[bogus])', { isoStrict: true }),
+    ], new Env(), 0)]);
+    equal(error.formal, 'domain_error(read_option)', 'invalid read option');
+    equal(solver.io.resolve('user_input').position, 0, 'invalid options are rejected before input');
+  });
+
+  reporter.test('follows the ISO 8.14.2.3 write_term/3 error order', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,[X])' })).formal,
+      'instantiation_error', 'partial/variable option before stream domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,foo)' })).formal,
+      'type_error(list)', 'non-list options before stream domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,[bogus])' })).formal,
+      'domain_error(stream_or_alias)', 'stream domain before invalid option');
+    equal(capture(() => run('', { isoStrict: true, goal: "write_term('$stream'(999),a,[bogus])" })).formal,
+      'domain_error(write_option)', 'invalid option before stream existence');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(user_input,a,[bogus])' })).formal,
+      'domain_error(write_option)', 'invalid option before stream permission');
+  });
+
+  reporter.test('follows the ISO 8.14.3.3 op/3 error order', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,X,0)' })).formal,
+      'instantiation_error', 'specifier variable before priority type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,xfy,[X])' })).formal,
+      'instantiation_error', 'operator variable element before priority type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,1,0)' })).formal,
+      'type_error(integer)', 'priority type before specifier type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1,1,0)' })).formal,
+      'type_error(atom)', 'specifier type before operator-list type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1300,xfy,[1])' })).formal,
+      'type_error(atom)', 'operator element type before priority domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1300,foo,a)' })).formal,
+      'domain_error(operator_priority)', 'priority domain before specifier domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(100,foo,a)' })).formal,
+      'domain_error(operator_specifier)', 'specifier domain');
+  });
+
+  reporter.test('uses ISO 8.14.4.3 domain errors for current_op/3 filters', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(a,_,_)' })).formal,
+      'domain_error(operator_priority)', 'priority domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(1,1,_)' })).formal,
+      'domain_error(operator_specifier)', 'specifier domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(1,fx,1)' })).formal,
+      'type_error(atom)', 'operator type');
+  });
+
   reporter.test('uses the Part 1 predefined operator table', () => {
     const program = Program.parse('', { isoStrict: true });
     equal(program.operators.has('fx\u0000?-'), true, 'fx ?-');

package/the-art-of-eyeprolog.md

@@ -5425,7 +5425,10 @@ emitted compactly when no lexical ambiguity would arise. For example,
 still retained where adjacent graphic tokens would otherwise merge, as in
 `a+ -b`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
-`variable_names/1`.
+`variable_names/1`. Normal mode additionally accepts the EyeProlog extension
+`double_quotes(true|false)`: `true` lets eligible character/code lists use the
+current `double_quotes` representation, while strict ISO mode rejects this
+non-standard write option.
 
 Character operations are `get_char`, `peek_char`, `put_char`, `get_code`,
 `peek_code`, and `put_code`; byte streams use the corresponding byte
@@ -7646,8 +7649,11 @@ conformance audit; it does **not** yet claim that every processor requirement
 has been independently certified. `test/conformance/ISO-COMPLIANCE.md` tracks
 the remaining normative audit work. The executable examples are mostly
 EyeProlog-profile programs using host-supplied goals, character lists, explicit
-integrity relations, automatic tabling, and the EyeProlog library. The
-remaining qualifications are:
+integrity relations, automatic tabling, and the EyeProlog library. The strict audit also exercises the complete Part 1 flag
+set and the prescribed 8.14 error precedence for `read_term/3`, `write_term/3`,
+`op/3`, and `current_op/3`; these checks distinguish invalid values from
+valid-but-fixed flag values and reject normal-profile write options at the
+strict boundary. The remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
@@ -7655,8 +7661,11 @@ remaining qualifications are:
 - variables cannot occupy functor or predicate position;
 - double-quoted text follows `double_quotes` exactly; the default `chars` value
   matches Trealla and Scryer and may be changed to `codes` or `atom`;
-- `write_term/2-3` implements `quoted/1`, `ignore_ops/1`, `numbervars/1`,
-  and `variable_names/1`, including Corrigendum 3 option validation and traversal rules;
+- `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
+  `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
+  including option validation and traversal rules; normal mode also offers
+  `double_quotes(true|false)` as an explicitly non-standard extension, which
+  strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.