eyeprolog 1.3.44 → 1.3.46

package/src/iso.js

@@ -14,6 +14,7 @@ import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import { INVALID_UTF8_SENTINEL } from './io.js';
 import { CharacterRepresentationError, isStrictIsoPcsCharacter, isStrictIsoPcsCodePoint } from './iso-character.js';
+import { ISO_MAX_ARITY } from './iso-limits.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -96,7 +97,7 @@ export const isoBuiltins = {
     registry.add('current_output', 1, currentOutputBuiltin, { deterministic: true });
     registry.add('set_input', 1, setCurrentStreamBuiltin('read'), { deterministic: true });
     registry.add('set_output', 1, setCurrentStreamBuiltin('write'), { deterministic: true });
-    registry.add('flush_output', 0, succeed, { deterministic: true });
+    registry.add('flush_output', 0, flushOutputBuiltin, { deterministic: true });
     registry.add('flush_output', 1, flushOutputBuiltin, { deterministic: true });
     registry.add('stream_property', 2, streamPropertyBuiltin);
     registry.add('set_stream_position', 2, setStreamPositionBuiltin, { deterministic: true });
@@ -346,10 +347,18 @@ function* keysortBuiltin({ goal, env }) {
   validateListOutput(goal.args[1], env);
   for (const item of items) {
     const resolved = deref(item, env);
+    if (resolved.type === VAR) throw new PrologError('instantiation_error');
     if (resolved.type !== COMPOUND || resolved.name !== '-' || resolved.arity !== 2) {
       throw new PrologError('type_error(pair)', resolved);
     }
   }
+  const { items: outputPrefix } = listElements(goal.args[1], env);
+  for (const item of outputPrefix) {
+    if (item.type === VAR) continue;
+    if (item.type !== COMPOUND || item.name !== '-' || item.arity !== 2) {
+      throw new PrologError('type_error(pair)', item);
+    }
+  }
   // Modern ECMAScript specifies a stable Array#sort, as required by keysort/2.
   // Keep one implementation-dependent variable order for this whole sorting
   // operation, as required by ISO 7.2.1.
@@ -381,18 +390,26 @@ function* functorBuiltin({ goal, env }) {
     if (unify(goal.args[1], name, next) && unify(goal.args[2], numberTerm(term.arity), next)) yield next;
     return;
   }
+
   const name = deref(goal.args[1], env);
-  const arity = requireInteger(goal.args[2], env);
-  if (arity < 0n) throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[2], env));
-  if (arity > BigInt(Number.MAX_SAFE_INTEGER)) throw new PrologError('representation_error(max_arity)');
+  const arityTerm = deref(goal.args[2], env);
+  // ISO 8.5.1.3 orders construction-mode diagnostics. A compound Name is an
+  // atomic type error (before an Arity type error); only an atomic non-atom
+  // used for positive arity receives type_error(atom,...).
+  if (name.type === VAR) throw new PrologError('instantiation_error');
+  if (arityTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (name.type === COMPOUND) throw new PrologError('type_error(atomic)', name);
+  if (arityTerm.type !== NUMBER || !isDecimalInteger(arityTerm.name)) {
+    throw new PrologError('type_error(integer)', arityTerm);
+  }
+  const arity = BigInt(arityTerm.name);
+  if (arity > 0n && name.type !== ATOM) throw new PrologError('type_error(atom)', name);
+  if (arity > BigInt(ISO_MAX_ARITY)) throw new PrologError('representation_error(max_arity)');
+  if (arity < 0n) throw new PrologError('domain_error(not_less_than_zero)', arityTerm);
   if (arity === 0n) {
-    if (name.type === VAR) throw new PrologError('instantiation_error');
-    if (name.type === COMPOUND) throw new PrologError('type_error(atomic)', name);
     if (unify(goal.args[0], name, next)) yield next;
     return;
   }
-  if (name.type === VAR) throw new PrologError('instantiation_error');
-  if (name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   const id = ++isoFresh;
   if (unify(goal.args[0], compound(name.name, Array.from({ length: Number(arity) }, (_, i) => variable(`__functor${id}_${i}`))), next)) yield next;
 }
@@ -412,6 +429,11 @@ function* univBuiltin({ goal, env }) {
   const term = deref(goal.args[0], env);
   const next = env.clone();
   if (term.type !== VAR) {
+    // 8.5.3.3(b) also applies in decomposition mode: a fixed second argument
+    // that is neither a list nor a partial list is an error, not failure.
+    if (listKind(goal.args[1], env) === 'nonlist') {
+      throw new PrologError('type_error(list)', deref(goal.args[1], env));
+    }
     const items = term.type === COMPOUND ? [atom(term.name), ...term.args] : [term];
     if (unify(goal.args[1], listFromItems(items), next)) yield next;
     return;
@@ -430,6 +452,7 @@ function* univBuiltin({ goal, env }) {
     return;
   }
   const name = requireAtom(items[0], env);
+  if (items.length - 1 > ISO_MAX_ARITY) throw new PrologError('representation_error(max_arity)');
   if (unify(goal.args[0], compound(name.name, items.slice(1)), next)) yield next;
 }
 
@@ -511,20 +534,15 @@ function* clauseBuiltin({ solver, goal, env }) {
   const head = deref(goal.args[0], env);
   if (head.type === VAR) throw new PrologError('instantiation_error');
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
-  callableOrVariable(goal.args[1], env);
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head)) {
-    throw new PrologError('permission_error(access, private_procedure)', indicator);
-  }
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  if (!group) return;
-  // ISO 7.5.3 makes dynamic procedures public and static user-defined
-  // procedures private by default.  EyeProlog's normal profile keeps static
-  // clauses inspectable for proof tooling; strict core mode restores the ISO
-  // access rule used by clause/2.
-  if (solver.isoStrict && !group.dynamic) {
+  // ISO 8.8.1.3 places private-procedure access before Body callability.
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) ||
+      (solver.isoStrict && group && !group.dynamic)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
   }
+  callableOrVariable(goal.args[1], env);
+  if (!group) return;
   for (const clause of group.clauses) {
     const pair = compound('$clause', [clause.head, clauseBodyTerm(clause.body)]);
     const copied = freshCopy(pair, new Env());
@@ -641,7 +659,7 @@ function predicateIndicatorParts(term, env) {
   if (name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   const integer = BigInt(arity.name);
   if (integer < 0n) throw new PrologError('domain_error(not_less_than_zero)', arity);
-  if (integer > BigInt(Number.MAX_SAFE_INTEGER)) throw new PrologError('representation_error(max_arity)');
+  if (integer > BigInt(ISO_MAX_ARITY)) throw new PrologError('representation_error(max_arity)');
   return { name: name.name, arity: Number(integer), indicator };
 }
 
@@ -680,7 +698,8 @@ function* setPrologFlagBuiltin({ solver, goal, env }) {
   if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
   const definition = solver.prologFlags.get(flag.name);
   if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
-  if (value.type !== ATOM || !definition.allowed.includes(value.name)) {
+  const expectedType = definition.valueType ?? ATOM;
+  if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
     throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
   }
   if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
@@ -830,6 +849,16 @@ function streamReference(term, env) {
   throw new PrologError('domain_error(stream_or_alias)', value);
 }
 
+function streamTermReference(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) return null;
+  if (value.type === COMPOUND && value.name === '$stream' && value.arity === 1 &&
+      value.args[0].type === NUMBER && isDecimalInteger(value.args[0].name)) {
+    return Number(value.args[0].name);
+  }
+  throw new PrologError('domain_error(stream)', value);
+}
+
 function requireStream(solver, term, env, mode = null) {
   const culprit = deref(term, env);
   const stream = solver.io.resolve(streamReference(term, env));
@@ -886,13 +915,14 @@ function openOptions(term, env) {
     if ((value = optionAtom(option, 'type'))) {
       value = deref(value, env);
       if (value.type === VAR) throw new PrologError('instantiation_error');
-      if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
-      if (!['text', 'binary'].includes(value.name)) throw new PrologError('domain_error(stream_option)', option);
+      if (value.type !== ATOM || !['text', 'binary'].includes(value.name)) {
+        throw new PrologError('domain_error(stream_option)', option);
+      }
       result.type = value.name;
     } else if ((value = optionAtom(option, 'alias'))) {
       value = deref(value, env);
       if (value.type === VAR) throw new PrologError('instantiation_error');
-      if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
+      if (value.type !== ATOM) throw new PrologError('domain_error(stream_option)', option);
       result.alias = value.name;
     } else if ((value = optionAtom(option, 'reposition'))) {
       value = deref(value, env);
@@ -911,19 +941,45 @@ function openOptions(term, env) {
   return result;
 }
 
+function streamOptionHasRequiredVariable(option, env) {
+  option = deref(option, env);
+  if (option.type !== COMPOUND || option.arity !== 1 ||
+      !['type', 'alias', 'reposition', 'eof_action'].includes(option.name)) return false;
+  return deref(option.args[0], env).type === VAR;
+}
+
 function* openBuiltin({ solver, goal, env }) {
-  const path = requireAtom(goal.args[0], env);
-  const mode = requireAtom(goal.args[1], env);
-  if (!['read', 'write', 'append'].includes(mode.name)) throw new PrologError('domain_error(io_mode)', mode);
+  const source = deref(goal.args[0], env);
+  const mode = deref(goal.args[1], env);
   const streamTarget = deref(goal.args[2], env);
+  const optionTerm = goal.arity === 3 ? emptyList() : goal.args[3];
+
+  // ISO 8.11.5.3 + Corrigenda 2/3.  Keep each prescribed condition
+  // observable on its own and apply the published ordering for deterministic
+  // diagnostics when several arguments are erroneous.
+  if (source.type === VAR) throw new PrologError('instantiation_error');
+  if (mode.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  if (preflight.items.some((option) => streamOptionHasRequiredVariable(option, env))) {
+    throw new PrologError('instantiation_error');
+  }
+  if (mode.type !== ATOM) throw new PrologError('type_error(atom)', mode);
+  const optionItems = requireProperOptionList(preflight);
   if (streamTarget.type !== VAR) throw new PrologError('uninstantiation_error', streamTarget);
-  const options = goal.arity === 3 ? {} : openOptions(goal.args[3], env);
-  if (options.alias && solver.io.resolve(options.alias)) throw new PrologError('permission_error(open, source_sink)', atom(options.alias));
+  if (source.type !== ATOM) throw new PrologError('domain_error(source_sink)', source);
+  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));
+  }
   let stream;
   try {
-    stream = solver.io.open(path.name, mode.name, options);
-  } catch (_) {
-    throw new PrologError('existence_error(source_sink)', path);
+    stream = solver.io.open(source.name, mode.name, options);
+  } catch (error) {
+    if (error?.code === 'ENOENT' && mode.name === 'read') {
+      throw new PrologError('existence_error(source_sink)', source);
+    }
+    throw new PrologError('permission_error(open, source_sink)', source);
   }
   const next = env.clone();
   if (unify(goal.args[2], streamHandle(stream.id), next)) yield next;
@@ -931,22 +987,35 @@ function* openBuiltin({ solver, goal, env }) {
 }
 
 function* closeBuiltin({ solver, goal, env }) {
-  if (goal.arity === 2) {
-    for (const option of optionList(goal.args[1], env)) {
-      if (option.type === VAR) throw new PrologError('instantiation_error');
-      const force = optionAtom(option, 'force');
-      const value = force && deref(force, env);
-      if (value?.type === VAR) throw new PrologError('instantiation_error');
-      if (!value || value.type !== ATOM || !['true', 'false'].includes(value.name)) {
-        throw new PrologError('domain_error(close_option)', option);
-      }
+  const reference = deref(goal.args[0], env);
+  if (reference.type === VAR) throw new PrologError('instantiation_error');
+  const optionTerm = goal.arity === 2 ? goal.args[1] : emptyList();
+  const preflight = preflightOptionList(optionTerm, env);
+  if (preflight.items.some((option) => {
+    const force = optionAtom(option, 'force');
+    return force != null && deref(force, env).type === VAR;
+  })) throw new PrologError('instantiation_error');
+  const options = requireProperOptionList(preflight);
+  streamReference(goal.args[0], env);
+  let forceClose = false;
+  for (const option of options) {
+    const force = optionAtom(option, 'force');
+    const value = force && deref(force, env);
+    if (!value || value.type !== ATOM || !['true', 'false'].includes(value.name)) {
+      throw new PrologError('domain_error(close_option)', option);
     }
+    forceClose = value.name === 'true'; // rightmost contradictory option applies
   }
   const stream = requireStream(solver, goal.args[0], env);
   if (!stream.standard) {
+    try {
+      solver.io.close(stream);
+    } catch (_) {
+      if (!forceClose) throw new PrologError('system_error');
+      solver.io.discard(stream);
+    }
     if (solver.io.currentInput === stream.id) solver.io.currentInput = 0;
     if (solver.io.currentOutput === stream.id) solver.io.currentOutput = 1;
-    solver.io.close(stream);
   }
   yield env;
 }
@@ -954,7 +1023,8 @@ function* closeBuiltin({ solver, goal, env }) {
 function* currentInputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
-    const stream = solver.io.resolve(streamReference(goal.args[0], env));
+    const id = streamTermReference(goal.args[0], env);
+    const stream = solver.io.resolve(id);
     if (!stream) throw new PrologError('domain_error(stream)', value);
     if (stream.id === solver.io.currentInput) yield env;
     return;
@@ -965,7 +1035,8 @@ function* currentInputBuiltin({ solver, goal, env }) {
 function* currentOutputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
-    const stream = solver.io.resolve(streamReference(goal.args[0], env));
+    const id = streamTermReference(goal.args[0], env);
+    const stream = solver.io.resolve(id);
     if (!stream) throw new PrologError('domain_error(stream)', value);
     if (stream.id === solver.io.currentOutput) yield env;
     return;
@@ -973,6 +1044,7 @@ function* currentOutputBuiltin({ solver, goal, env }) {
   const next = env.clone();
   if (unify(goal.args[0], streamHandle(solver.io.currentOutput), next)) yield next;
 }
+
 function setCurrentStreamBuiltin(mode) {
   return function* ({ solver, goal, env }) {
     const stream = requireStream(solver, goal.args[0], env, mode);
@@ -982,7 +1054,14 @@ function setCurrentStreamBuiltin(mode) {
   };
 }
 function* flushOutputBuiltin({ solver, goal, env }) {
-  requireStream(solver, goal.args[0], env, 'write');
+  const stream = goal.arity === 0
+    ? solver.io.resolve(solver.io.currentOutput)
+    : requireStream(solver, goal.args[0], env, 'write');
+  try {
+    solver.io.flush(stream);
+  } catch (_) {
+    throw new PrologError('system_error');
+  }
   yield env;
 }
 
@@ -1003,23 +1082,51 @@ function streamProperties(stream) {
   return properties;
 }
 function* setStreamPositionBuiltin({ solver, goal, env }) {
-  const stream = requireStream(solver, goal.args[0], env);
-  if (!stream.reposition) throw new PrologError('permission_error(reposition, stream)', deref(goal.args[0], env));
+  const reference = deref(goal.args[0], env);
+  if (reference.type === VAR) throw new PrologError('instantiation_error');
   let position = deref(goal.args[1], env);
-  if (position.type === COMPOUND && position.name === 'position' && position.arity === 1) {
+  if (position.type === VAR) throw new PrologError('instantiation_error');
+  streamReference(goal.args[0], env);
+  if (!solver.isoStrict && position.type === COMPOUND && position.name === 'position' && position.arity === 1) {
+    // Historical EyeProlog convenience form.  Strict Part 1 mode uses only
+    // the implementation-defined integer stream-position terms returned by
+    // stream_property/2.
     position = deref(position.args[0], env);
   }
-  if (position.type === VAR) throw new PrologError('instantiation_error');
-  if (position.type !== NUMBER || !isDecimalInteger(position.name)) throw new PrologError('domain_error(stream_position)', position);
+  if (position.type === VAR || position.type !== NUMBER || !isDecimalInteger(position.name)) {
+    throw new PrologError('domain_error(stream_position)', position);
+  }
   const offset = BigInt(position.name);
-  if (offset < 0n || offset > BigInt(stream.content.length)) throw new PrologError('domain_error(stream_position)', position);
+  if (offset < 0n) throw new PrologError('domain_error(stream_position)', position);
+  const stream = requireStream(solver, goal.args[0], env);
+  if (!stream.reposition) throw new PrologError('permission_error(reposition, stream)', reference);
+  if (offset > BigInt(stream.content.length)) throw new PrologError('domain_error(stream_position)', position);
   stream.position = Number(offset);
   stream.pastEnd = false;
   yield env;
 }
+
+function isStreamPropertyPattern(value) {
+  if (value.type === VAR) return true;
+  if (value.type === ATOM) return value.name === 'input' || value.name === 'output';
+  return value.type === COMPOUND && value.arity === 1 && [
+    'file_name', 'mode', 'alias', 'position', 'end_of_stream', 'eof_action', 'reposition', 'type',
+  ].includes(value.name);
+}
+
 function* streamPropertyBuiltin({ solver, goal, env }) {
   const reference = deref(goal.args[0], env);
-  const streams = reference.type === VAR ? [...solver.io.streams.values()] : [requireStream(solver, goal.args[0], env)];
+  const propertyPattern = deref(goal.args[1], env);
+  if (reference.type !== VAR) {
+    const id = streamTermReference(goal.args[0], env);
+    if (!solver.io.resolve(id)) throw new PrologError('domain_error(stream)', reference);
+  }
+  if (!isStreamPropertyPattern(propertyPattern)) {
+    throw new PrologError('domain_error(stream_property)', propertyPattern);
+  }
+  const streams = reference.type === VAR
+    ? [...solver.io.streams.values()]
+    : [solver.io.resolve(streamTermReference(goal.args[0], env))];
   for (const stream of streams) {
     for (const property of streamProperties(stream)) {
       const next = env.clone();
@@ -1035,27 +1142,69 @@ function outputStreamFor(solver, goal, env) {
   return goal.arity === 1 ? solver.io.resolve(solver.io.currentOutput) : requireStream(solver, goal.args[0], env, 'write');
 }
 function* atEndBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 0 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
-  if (stream.position >= stream.content.length) yield env;
+  // at_end_of_stream/1 is bootstrapped in Part 1 from the end_of_stream/1
+  // stream property and therefore accepts any open stream-or-alias; it is not
+  // an input-only operation.
+  const stream = goal.arity === 0 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env);
+  if (stream.pastEnd || stream.position >= stream.content.length) yield env;
+}
+function validStrictInputCharacterCode(value, solver) {
+  if (value.type !== NUMBER || !isDecimalInteger(value.name)) return false;
+  const code = BigInt(value.name);
+  if (code === -1n) return true;
+  if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return false;
+  return !solver.isoStrict || isStrictIsoPcsCodePoint(Number(code));
+}
+
+function preflightInputUnitTarget(name, target, env, solver) {
+  const value = deref(target, env);
+  if (name.endsWith('char')) {
+    if (value.type !== VAR && !(oneChar(value) || (value.type === ATOM && value.name === 'end_of_file'))) {
+      throw new PrologError('type_error(in_character)', value);
+    }
+    if (value.type === ATOM && oneChar(value) && solver.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+      throw new PrologError('type_error(in_character)', value);
+    }
+  } else if (name.endsWith('code')) {
+    if (value.type !== VAR && (value.type !== NUMBER || !isDecimalInteger(value.name))) {
+      throw new PrologError('type_error(integer)', value);
+    }
+    if (value.type !== VAR && !validStrictInputCharacterCode(value, solver)) {
+      throw new PrologError('representation_error(in_character_code)');
+    }
+  } else {
+    if (value.type !== VAR) {
+      if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(in_byte)', value);
+      const byte = BigInt(value.name);
+      if (byte !== -1n && (byte < 0n || byte > 255n)) throw new PrologError('type_error(in_byte)', value);
+    }
+  }
+  return value;
 }
+
 function inputUnitBuiltin(name) {
   return function* ({ solver, goal, env }) {
+    const explicit = goal.arity === 2;
+    if (explicit && deref(goal.args[0], env).type === VAR) throw new PrologError('instantiation_error');
+    const target = goal.args[goal.arity - 1];
+    preflightInputUnitTarget(name, target, env, solver);
     const stream = inputStreamFor(solver, goal, env);
     const binary = name.endsWith('byte');
-    if (binary !== (stream.type === 'binary')) throw new PrologError('permission_error(input, stream)', streamHandle(stream.id));
+    if (binary && stream.type !== 'binary') {
+      throw new PrologError('permission_error(input, text_stream)', streamHandle(stream.id));
+    }
+    if (!binary && stream.type !== 'text') {
+      throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
+    }
     if (stream.pastEnd && stream.eofAction === 'error') {
       throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));
     }
     if (stream.pastEnd && stream.eofAction === 'reset') {
-      // A terminal EOF (Ctrl-D) is local to one input operation. The next
-      // operation should wait for fresh terminal input rather than rewinding
-      // and replaying the already-consumed interactive buffer.
       if (typeof stream.interactiveReadUnit !== 'function') stream.position = 0;
       stream.pastEnd = false;
     }
     const peek = name.startsWith('peek');
-    if (stream.position >= stream.content.length &&
-        typeof stream.interactiveReadUnit === 'function') {
+    if (stream.position >= stream.content.length && typeof stream.interactiveReadUnit === 'function') {
       const text = stream.interactiveReadUnit();
       if (text != null) {
         stream.content += String(text);
@@ -1066,50 +1215,68 @@ function inputUnitBuiltin(name) {
     try {
       unit = solver.io.readUnit(stream, peek);
     } catch (error) {
-      if (error?.name === 'InvalidCharacterEncodingError') {
-        throw new PrologError('representation_error(character)');
-      }
+      if (error?.name === 'InvalidCharacterEncodingError') throw new PrologError('representation_error(character)');
       throw error;
     }
     if (unit == null && !peek) stream.pastEnd = true;
     if (!binary && unit != null && solver.isoStrict && !isStrictIsoPcsCharacter(unit)) {
       throw new PrologError('representation_error(character)');
     }
-    const result = unit == null ? (binary ? numberTerm(-1) : name.endsWith('code') ? numberTerm(-1) : atom('end_of_file'))
+    const result = unit == null
+      ? (binary ? numberTerm(-1) : name.endsWith('code') ? numberTerm(-1) : atom('end_of_file'))
       : binary ? numberTerm(unit) : name.endsWith('code') ? numberTerm(unit.codePointAt(0)) : atom(unit);
-    const target = goal.args[goal.arity - 1];
     const next = env.clone();
     if (unify(target, result, next)) yield next;
   };
 }
+
+function preflightOutputUnitValue(name, target, env) {
+  const value = deref(target, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (name === 'put_char') {
+    if (!oneChar(value)) throw new PrologError('type_error(character)', value);
+    return value;
+  }
+  if (name === 'put_byte') {
+    if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(byte)', value);
+    const byte = BigInt(value.name);
+    if (byte < 0n || byte > 255n) throw new PrologError('type_error(byte)', value);
+    return value;
+  }
+  if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
+  return value;
+}
+
 function outputUnitBuiltin(name) {
   return function* ({ solver, goal, env }) {
+    const explicit = goal.arity === 2;
+    if (explicit && deref(goal.args[0], env).type === VAR) throw new PrologError('instantiation_error');
+    const value = preflightOutputUnitValue(name, goal.args[goal.arity - 1], env);
     const stream = outputStreamFor(solver, goal, env);
-    const value = deref(goal.args[goal.arity - 1], env);
-    if (value.type === VAR) throw new PrologError('instantiation_error');
     if (name === 'put_char') {
       if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
-      if (!oneChar(value)) throw new PrologError('type_error(character)', value);
       if (solver.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
         throw new PrologError('representation_error(character)', value);
       }
       solver.io.writeUnit(stream, value.name);
+    } else if (name === 'put_byte') {
+      if (stream.type !== 'binary') throw new PrologError('permission_error(output, text_stream)', streamHandle(stream.id));
+      solver.io.writeUnit(stream, Number(value.name));
     } else {
-      if ((name === 'put_byte') !== (stream.type === 'binary')) {
-        throw new PrologError('permission_error(output, stream)', streamHandle(stream.id));
-      }
-      if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
+      if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
       const code = BigInt(value.name);
-      const max = name === 'put_byte' ? 255n : 0x10ffffn;
-      if (code < 0n || code > max) throw new PrologError(name === 'put_byte' ? 'type_error(byte)' : 'representation_error(character_code)');
-      if (name === 'put_code' && solver.isoStrict && !isStrictIsoPcsCodePoint(Number(code))) {
+      if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) {
         throw new PrologError('representation_error(character_code)');
       }
-      solver.io.writeUnit(stream, name === 'put_byte' ? Number(code) : String.fromCodePoint(Number(code)));
+      if (solver.isoStrict && !isStrictIsoPcsCodePoint(Number(code))) {
+        throw new PrologError('representation_error(character_code)');
+      }
+      solver.io.writeUnit(stream, String.fromCodePoint(Number(code)));
     }
     yield env;
   };
 }
+
 function* nlBuiltin({ solver, goal, env }) {
   const stream = goal.arity === 0
     ? solver.io.resolve(solver.io.currentOutput)
@@ -1274,6 +1441,13 @@ export function isCompleteReadTermText(text, solver) {
 }
 
 function readTermFromStream(stream, solver) {
+  if (stream.pastEnd && stream.eofAction === 'error') {
+    throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));
+  }
+  if (stream.pastEnd && stream.eofAction === 'reset') {
+    if (typeof stream.interactiveReadTerm !== 'function') stream.position = 0;
+    stream.pastEnd = false;
+  }
   let requestedInteractiveTerm = false;
   while (true) {
     let sawCandidate = false;
@@ -1317,6 +1491,7 @@ function readTermFromStream(stream, solver) {
     stream.position = source.length;
     if (!sawCandidate) {
       if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
+      stream.pastEnd = true;
       return { term: atom('end_of_file'), variables: [] };
     }
     throw new PrologError('syntax_error(read_term)');
@@ -1789,14 +1964,14 @@ function canonicalNumberText(value) {
   return text;
 }
 
-function numberListText(list, env, kind, valueIsBound) {
+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 === '[]';
   if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
 
   const invalid = items.find((item) => item.type !== VAR &&
-    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item)));
+    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item, solver)));
   if (invalid) {
     if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
     if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
@@ -1816,12 +1991,12 @@ function numberListText(list, env, kind, valueIsBound) {
 const numberSyntaxError = new PrologError('syntax_error(number)');
 
 function numberListBuiltin(kind) {
-  return function* ({ goal, env }) {
+  return function* ({ solver, goal, env }) {
     const value = deref(goal.args[0], env);
     if (value.type !== VAR && value.type !== NUMBER) throw new PrologError('type_error(number)', value);
     const list = deref(goal.args[1], env);
     if (value.type === VAR && list.type === VAR) throw new PrologError('instantiation_error');
-    const text = numberListText(list, env, kind, value.type === NUMBER);
+    const text = numberListText(list, env, kind, value.type === NUMBER, solver);
     if (value.type === NUMBER) {
       if (text != null) {
         const parsed = parseIsoNumber(text);
@@ -1908,11 +2083,13 @@ function flatFindallTemplate(template) {
 
 function* findallBuiltin({ solver, goal, env }) {
   const [template, innerGoal, bag] = goal.args;
+  // ISO 8.10.1.3 diagnoses Goal before Instances when both are erroneous.
+  const invoked = callable(innerGoal, env);
   assertListOrPartial(bag, env);
   const collector = solver.cloneForInnerGoal(10000000);
   let compact = flatFindallTemplate(template);
   let collected = compact == null ? [] : null;
-  for (const answerEnv of collector.solve([callable(innerGoal, env)], env.clone(), 0)) {
+  for (const answerEnv of collector.solve([invoked], env.clone(), 0)) {
     if (compact != null && compact.push(template, answerEnv)) continue;
     if (compact != null) {
       collected = compact.materialize();
@@ -1971,8 +2148,9 @@ function sortedUnique(items) {
 
 function allSolutionsBuiltin(asSet) {
   return function* ({ solver, goal, env }) {
-    assertListOrPartial(goal.args[2], env);
+    // ISO 8.10.2.3/8.10.3.3 diagnose the iterated goal before Instances.
     const { iterated, quantified } = bagGoalParts(goal.args[1], env);
+    assertListOrPartial(goal.args[2], env);
     const free = freeVariables(iterated, goal.args[0], quantified, env);
     const collector = solver.cloneForInnerGoal(10000000);
     const groups = [];

package/src/parser.js

@@ -3,6 +3,7 @@
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
 import { CharacterRepresentationError, isStrictIsoPcsCodePoint } from './iso-character.js';
+import { ISO_MAX_ARITY } from './iso-limits.js';
 
 
 export class NumberRepresentationError extends Error {
@@ -723,6 +724,7 @@ class Parser {
     }
     while (true) {
       args.push(this.parseTerm(ARG_MIN_PRECEDENCE, false, false, true));
+      if (args.length > ISO_MAX_ARITY) throw new NumberRepresentationError('representation_error(max_arity)');
       if (this.token.type !== TOK.COMMA) break;
       this.advance();
     }