eyeprolog 1.3.43 → 1.3.45

package/README.md

@@ -218,6 +218,18 @@ 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
+ongoing issue #65 audit additionally tightens Prolog-text declaration ordering,
+initialization lifetime, stream/open/close behavior, character/byte stream
+errors, `keysort/2` error cases, and strict arithmetic-extension boundaries.
+Those additions improve the Part 1 surface without turning the remaining audit
+rows into a blanket conformance claim.
+
 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.45",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/io.js

@@ -88,8 +88,13 @@ export class StreamManager {
       const raw = fs.readFileSync(path);
       if (type === 'binary') content = raw;
       else { content = decodeUtf8ForTextStream(raw); strictUtf8 = true; }
-    } else if (mode === 'append' && fs.existsSync(path)) {
-      content = fs.readFileSync(path, type === 'binary' ? null : 'utf8');
+    } else if (mode === 'write') {
+      // ISO 7.10.1.1: opening an existing sink in write mode empties it,
+      // while a missing sink is created at open time (not deferred to close).
+      fs.writeFileSync(path, type === 'binary' ? BufferCtor.from([]) : '');
+    } else if (mode === 'append') {
+      if (fs.existsSync(path)) content = fs.readFileSync(path, type === 'binary' ? null : 'utf8');
+      else fs.writeFileSync(path, type === 'binary' ? BufferCtor.from([]) : '');
     }
     if (BufferCtor?.isBuffer(content)) content = [...content];
     return this.add({
@@ -100,13 +105,18 @@ export class StreamManager {
       pastEnd: false,
     });
   }
-  close(stream) {
-    if (!stream.standard && stream.mode !== 'read') {
-      fs.writeFileSync(stream.path, stream.type === 'binary' ? BufferCtor.from(stream.content) : stream.content);
-    }
+  flush(stream) {
+    if (!stream || stream.standard || stream.mode === 'read') return;
+    fs.writeFileSync(stream.path, stream.type === 'binary' ? BufferCtor.from(stream.content) : stream.content);
+  }
+  discard(stream) {
     if (stream.alias) this.aliases.delete(stream.alias);
     this.streams.delete(stream.id);
   }
+  close(stream) {
+    this.flush(stream);
+    this.discard(stream);
+  }
   readUnit(stream, peek = false) {
     if (stream.position >= stream.content.length) return null;
     if (stream.type === 'binary') {
@@ -126,9 +136,22 @@ export class StreamManager {
     return value;
   }
   writeUnit(stream, value) {
-    if (stream.standard && stream.write) stream.write(String(value));
-    else if (stream.type === 'binary') stream.content.push(value);
-    else stream.content += value;
-    stream.position = stream.content.length;
+    if (stream.standard && stream.write) {
+      stream.write(String(value));
+      return;
+    }
+    // 7.10.2.8: output after repositioning overwrites the existing sink
+    // contents at the selected stream position rather than always appending.
+    if (stream.type === 'binary') {
+      if (stream.position < stream.content.length) stream.content[stream.position] = value;
+      else stream.content.push(value);
+      stream.position++;
+      return;
+    }
+    const text = String(value);
+    const content = String(stream.content);
+    const end = Math.min(content.length, stream.position + text.length);
+    stream.content = `${content.slice(0, stream.position)}${text}${content.slice(end)}`;
+    stream.position += text.length;
   }
 }

package/src/iso-arithmetic.js

@@ -5,7 +5,7 @@ import {
 } from './term.js';
 import { PrologError } from './errors.js';
 
-function evaluate(term, env) {
+function evaluate(term, env, options = {}) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
   if (term.type === NUMBER) {
@@ -16,10 +16,11 @@ function evaluate(term, env) {
   }
   if (term.type === ATOM) {
     if (term.name === 'pi') return { integer: false, value: Math.PI };
-    if (term.name === 'e') return { integer: false, value: Math.E };
+    if (term.name === 'e' && options.isoStrict !== true) return { integer: false, value: Math.E };
+    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));
+  const args = term.args.map((arg) => evaluate(arg, env, options));
   return evaluateOperation(term, args);
 }
 function evaluateOperation(term, args) {
@@ -120,8 +121,8 @@ export function arithmeticValueTerm(value) {
 function numericTerm(value) {
   return arithmeticValueTerm(value);
 }
-export function evaluateArithmetic(term, env) {
-  return evaluate(term, env);
+export function evaluateArithmetic(term, env, options = {}) {
+  return evaluate(term, env, options);
 }
 function compareIntegerToFloat(integerValue, floatValue) {
   if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
@@ -151,15 +152,16 @@ export function compareArithmeticValues(left, right) {
   if (right.integer) return -compareIntegerToFloat(b, a);
   return a < b ? -1 : a > b ? 1 : 0;
 }
-export function* isBuiltin({ goal, env }) {
-  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));
+export function* isBuiltin({ solver, goal, env }) {
+  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env, { isoStrict: solver?.isoStrict === true }));
   const next = env.clone();
   if (unify(goal.args[0], result, next)) yield next;
 }
 export function arithmeticComparison(test) {
-  return function* ({ goal, env }) {
-    const left = evaluateArithmetic(goal.args[0], env);
-    const right = evaluateArithmetic(goal.args[1], env);
+  return function* ({ solver, goal, env }) {
+    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);
     if (test(cmp)) yield env;
   };