eyeprolog 1.3.55 → 1.3.57

package/package.json

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

package/src/iso.js

@@ -393,9 +393,9 @@ function* functorBuiltin({ goal, env }) {
 
   const name = deref(goal.args[1], env);
   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,...).
+  // Keep EyeProlog's deterministic construction-mode diagnostics aligned with
+  // the individual 8.5.1.3 conditions. Under 7.12, a call satisfying several
+  // error conditions at once does not acquire a globally mandated table order.
   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);
@@ -562,7 +562,9 @@ function* clauseBuiltin({ solver, goal, env }) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
   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.
+  // EyeProlog selects private-procedure access before Body callability when both
+  // conditions hold. ISO 7.12 permits an implementation-dependent choice when
+  // more than one error condition is simultaneously satisfied.
   if (isProcessorStaticProcedure(solver, head) ||
       (solver.isoStrict && group && !group.dynamic)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
@@ -590,12 +592,22 @@ function requireClauseHead(head) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
 }
 
-function convertAssertedBody(term) {
+export function convertClauseBodyTerm(term, culprit = term) {
   if (term.type === VAR) return compound('call', [term]);
-  if (term.type === COMPOUND && term.name === ',' && term.arity === 2) {
-    return compound(',', [convertAssertedBody(term.args[0]), convertAssertedBody(term.args[1])]);
+  // ISO 7.6.2 converts each argument of conjunction, disjunction, and if-then
+  // recursively when a term is converted to a clause body. This matters for
+  // variables (which become call(Var)) and for invalid nested terms, which
+  // must be rejected while assert[az]/1 performs the conversion rather than
+  // being stored and failing only if that branch is later executed.
+  if (term.type === COMPOUND && [',', ';', '->'].includes(term.name) && term.arity === 2) {
+    return compound(term.name, [
+      convertClauseBodyTerm(term.args[0], culprit),
+      convertClauseBodyTerm(term.args[1], culprit),
+    ]);
+  }
+  if (term.type !== ATOM && term.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', culprit);
   }
-  if (term.type !== ATOM && term.type !== COMPOUND) throw new PrologError('type_error(callable)', term);
   return term;
 }
 
@@ -633,7 +645,7 @@ function assertBuiltin(atStart) {
   return function* ({ solver, goal, env }) {
     const parts = clauseParts(goal.args[0], env);
     requireClauseHead(parts.head);
-    const body = convertAssertedBody(parts.body);
+    const body = convertClauseBodyTerm(parts.body);
     assertModifiable(solver, parts.head, goal.module ?? 'user');
     const copied = freshCopy(compound('$clause', [parts.head, body]), env);
     solver.program.insertDynamicClause({
@@ -772,9 +784,9 @@ function* opBuiltin({ solver, goal, env }) {
   const priorityTerm = deref(goal.args[0], env);
   const specifierTerm = deref(goal.args[1], env);
 
-  // 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.
+  // Keep EyeProlog's selected 8.14.3.3 overlap order deterministic. Each
+  // individual condition remains observable; ISO 7.12 leaves the choice
+  // implementation dependent when several error conditions hold at once.
   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);
@@ -933,12 +945,11 @@ 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.
+// Keep read_term/3 and write_term/3 diagnostics deterministic and make every
+// 8.14 error condition independently testable. ISO 7.12 leaves the choice
+// implementation dependent when several error conditions hold simultaneously,
+// so this preflight order is an EyeProlog processor choice rather than a claim
+// that the textual order of an error table is globally mandatory.
 function preflightOptionList(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
@@ -1007,9 +1018,9 @@ function* openBuiltin({ solver, goal, 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.
+  // ISO 8.11.5.3 + Corrigenda 2/3. Keep each required condition observable
+  // on its own. When several conditions hold, the order below is EyeProlog's
+  // deterministic 7.12 processor choice unless a procedural rule constrains it.
   if (source.type === VAR) throw new PrologError('instantiation_error');
   if (mode.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
@@ -1173,16 +1184,21 @@ function isStreamPropertyPattern(value) {
 function* streamPropertyBuiltin({ solver, goal, env }) {
   const reference = deref(goal.args[0], env);
   const propertyPattern = deref(goal.args[1], env);
+  let fixedStreamId = null;
   if (reference.type !== VAR) {
-    const id = streamTermReference(goal.args[0], env);
-    if (!solver.io.resolve(id)) throw new PrologError('domain_error(stream)', reference);
+    // 8.11.8.1 enumerates (Stream, Property) pairs for currently open
+    // streams. A ground term with the implementation's stream-term shape is
+    // still a stream-term even when its stream is no longer open; in that
+    // case the enumeration simply has no matching pair. domain_error(stream)
+    // is reserved for a term which is not a stream-term at all.
+    fixedStreamId = streamTermReference(goal.args[0], env);
   }
   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))];
+    : [solver.io.resolve(fixedStreamId)].filter(Boolean);
   for (const stream of streams) {
     for (const property of streamProperties(stream)) {
       const next = env.clone();
@@ -1222,11 +1238,10 @@ function preflightInputUnitTarget(name, target, env, solver) {
       throw new PrologError('type_error(in_character)', value);
     }
   } else if (name.endsWith('code')) {
-    // ISO 8.12.1.3/8.12.2.3 puts the integer type check before stream
-    // diagnostics, but the integer-is-not-an-in-character-code
-    // representation error comes after the stream existence/mode/type/EOF
-    // conditions.  Defer that range/repertoire check until the input entity
-    // itself has been inspected below.
+    // Keep the selected 8.12 overlap behavior stable: integer type validation
+    // is done here, while the in-character-code repertoire check is deferred
+    // until after stream/entity diagnostics. ISO 7.12 permits this processor
+    // choice when those error conditions overlap.
     if (value.type !== VAR && (value.type !== NUMBER || !isDecimalInteger(value.name))) {
       throw new PrologError('type_error(integer)', value);
     }
@@ -1280,10 +1295,9 @@ function inputUnitBuiltin(name) {
     if (!binary && unit != null && solver.isoStrict && !isStrictIsoPcsCharacter(unit)) {
       throw new PrologError('representation_error(character)');
     }
-    // For get_code/peek_code the published error table places an invalid
-    // in-character-code target after stream and input-entity errors.  Doing
-    // this here prevents a fixed bad Code from masking (for example) an
-    // output-stream, binary-stream, past-EOF, or invalid-character error.
+    // EyeProlog deliberately defers this representation check until after
+    // stream and input-entity diagnostics. ISO 7.12 permits that deterministic
+    // choice when several 8.12 error conditions hold simultaneously.
     const targetValue = deref(target, env);
     if (name.endsWith('code') && targetValue.type !== VAR &&
         !validStrictInputCharacterCode(targetValue, solver)) {
@@ -1586,9 +1600,9 @@ function* readTermBuiltin({ solver, goal, env }) {
   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.
+  // EyeProlog's selected 8.14.1.3 overlap order. Each listed error condition
+  // is covered independently; 7.12 makes simultaneous-error selection
+  // implementation dependent unless another procedural requirement constrains it.
   if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
   if (goal.arity === 3) streamReference(goal.args[0], env);
@@ -1702,9 +1716,9 @@ function* writeTermBuiltin({ solver, goal, env }) {
   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.
+  // EyeProlog's selected 8.14.2.3 overlap order. Each listed error condition
+  // is covered independently; 7.12 makes simultaneous-error selection
+  // implementation dependent unless another procedural requirement constrains it.
   if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
   const preflight = preflightOptionList(optionTerm, env);
   const optionItems = requireProperOptionList(preflight);
@@ -2177,7 +2191,9 @@ 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.
+  // EyeProlog validates Goal before Instances when both are erroneous. ISO 7.12
+  // makes simultaneous-error selection implementation dependent; this order is
+  // a documented/tested processor choice, not a blanket table-order rule.
   const invoked = callable(innerGoal, env);
   assertListOrPartial(bag, env);
   const collector = solver.cloneForInnerGoal(10000000);
@@ -2242,7 +2258,9 @@ function sortedUnique(items) {
 
 function allSolutionsBuiltin(asSet) {
   return function* ({ solver, goal, env }) {
-    // ISO 8.10.2.3/8.10.3.3 diagnose the iterated goal before Instances.
+    // EyeProlog validates the iterated goal before Instances. ISO 7.12 makes
+    // simultaneous-error selection implementation dependent; keep this stable as
+    // a processor choice rather than describing it as mandatory table ordering.
     const { iterated, quantified } = bagGoalParts(goal.args[1], env);
     assertListOrPartial(goal.args[2], env);
     const free = freeVariables(iterated, goal.args[0], quantified, env);

package/src/program.js

@@ -1,6 +1,6 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
+import { ATOM, COMPOUND, STRING, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
@@ -12,7 +12,7 @@ import {
   parseGoalText,
   tryParseClausesFastInto,
 } from './parser.js';
-import { PrologError, getStrictIsoRegistry } from './iso.js';
+import { PrologError, convertClauseBodyTerm, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import {
   standardLibrarySources,
@@ -33,6 +33,21 @@ import {
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
+
+function termContainsStringExtension(term, seen = new Set()) {
+  if (term == null || typeof term !== 'object' || seen.has(term)) return false;
+  seen.add(term);
+  if (term.type === STRING) return true;
+  if (term.type === COMPOUND) return term.args.some((arg) => termContainsStringExtension(arg, seen));
+  return false;
+}
+
+function clauseContainsStringExtension(clause) {
+  if (clause == null) return false;
+  if (clause.head0Type === STRING || clause.head1Type === STRING) return true;
+  if (termContainsStringExtension(clause.head) || termContainsStringExtension(clause.query)) return true;
+  return Array.isArray(clause.body) && clause.body.some((goal) => termContainsStringExtension(goal));
+}
 export class Program {
   constructor(clauses = [], options = {}) {
     this.clauses = [];
@@ -574,6 +589,12 @@ class ProgramBuilder {
     let lastGroup = this.lastGroup;
 
     for (const clause of clauses) {
+      if (program.strictIso && clauseContainsStringExtension(clause)) {
+        // Programmatic clauses are part of the public embedding surface.  The
+        // normal profile permits its host string term extension, but the Part 1
+        // strict profile must reject that implementation-specific sixth type.
+        throw new PrologError('representation_error(term)');
+      }
       if (clause?.kind === 'quad') {
         const module = clause.module ?? 'user';
         annotateGoalModule(clause.query, module);
@@ -606,6 +627,14 @@ class ProgramBuilder {
       }
 
       if (!isDirectiveClause(clause)) {
+        if (program.strictIso && Array.isArray(clause.body) && clause.body.length > 0) {
+          // ISO 7.6.2 applies when source text is prepared as well as when a
+          // clause term is asserted dynamically. Keep the original variable
+          // objects while wrapping variable goals in call/1 so sharing with
+          // the head (and recursively through ;/2 and ->/2) is preserved for
+          // later clause/2 and retract/1 conversion back to terms.
+          clause.body = clause.body.map((goal) => convertClauseBodyTerm(goal));
+        }
         assertHeadIsDefinable(clause.head, program.strictIso);
         const head = clause.head;
         if (head.type !== ATOM && head.type !== COMPOUND) continue;

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -45,6 +45,26 @@ function raiseOccursCheckError(left, right, env) {
   throw error;
 }
 
+
+function rejectStrictIsoStringTerms(terms, env) {
+  const seen = new Set();
+  const visit = (term) => {
+    const resolved = deref(term, env);
+    if (resolved == null || seen.has(resolved)) return;
+    seen.add(resolved);
+    if (resolved.type === STRING) {
+      // `stringTerm()` is a normal-profile host/API term extension.  It has no
+      // Part 1 abstract/token syntax, so strict execution must reject it rather
+      // than silently introducing a sixth term type through the embedding API.
+      throw new PrologError('representation_error(term)');
+    }
+    if (resolved.type === COMPOUND) {
+      for (const arg of resolved.args) visit(arg);
+    }
+  };
+  for (const term of terms) visit(term);
+}
+
 export class Solver {
   constructor(program, options = {}) {
     this.program = program;
@@ -301,6 +321,7 @@ export class Solver {
   *solve(goals, env = new Env(), depth = 0) {
     if (!Array.isArray(goals)) goals = [goals];
     env.setOccursCheckHandler(this.occursCheckHandler);
+    if (this.isoStrict) rejectStrictIsoStringTerms(goals, env);
 
     const writeVariableState = this.writeVariableState;
     if (writeVariableState.depth === 0) {