eyeprolog 1.3.67 → 1.3.69

package/src/lib/si.pl

@@ -0,0 +1,62 @@
+/** Sufficient-instantiation tests compatible with Scryer library(si). */
+
+:- module(si, [
+    atom_si/1,
+    integer_si/1,
+    atomic_si/1,
+    list_si/1,
+    character_si/1,
+    term_si/1,
+    chars_si/1,
+    dif_si/2,
+    not_si/1,
+    when_si/2
+]).
+
+:- meta_predicate(not_si(0)).
+:- meta_predicate(when_si(+, 0)).
+
+atom_si(A) :- ( var(A) -> throw(error(instantiation_error, atom_si/1)) ; atom(A) ).
+integer_si(I) :- ( var(I) -> throw(error(instantiation_error, integer_si/1)) ; integer(I) ).
+atomic_si(A) :- ( var(A) -> throw(error(instantiation_error, atomic_si/1)) ; atomic(A) ).
+
+list_si(List) :- si__list(List).
+si__list([]).
+si__list([_|Tail]) :- !, si__list(Tail).
+si__list(Term) :-
+    ( var(Term) -> throw(error(instantiation_error, list_si/1)) ; fail ).
+
+character_si(C) :-
+    ( var(C) -> throw(error(instantiation_error, character_si/1))
+    ; atom(C), atom_length(C, 1)
+    ).
+
+term_si(Term) :-
+    ( ground(Term) -> acyclic_term(Term)
+    ; throw(error(instantiation_error, term_si/1))
+    ).
+
+chars_si(Chars) :-
+    list_si(Chars),
+    si__chars(Chars).
+si__chars([]).
+si__chars([C|Cs]) :- character_si(C), si__chars(Cs).
+
+dif_si(X, Y) :-
+    X \== Y,
+    ( X \= Y -> true ; throw(error(instantiation_error, dif_si/2)) ).
+
+not_si(Goal) :- term_si(Goal), \+ Goal.
+
+when_si(Condition, Goal) :-
+    ( si__condition(Condition) ->
+        ( call(Condition) -> call(Goal)
+        ; throw(error(instantiation_error, when_si/2)) )
+    ; throw(error(domain_error(when_condition_si, Condition), when_si/2))
+    ).
+
+si__condition(Condition) :- var(Condition), !, throw(error(instantiation_error, when_si/2)).
+si__condition(ground(_)).
+si__condition(nonvar(_)).
+si__condition((A,B)) :- si__condition(A), si__condition(B).
+si__condition((A;B)) :- si__condition(A), si__condition(B).

package/src/lib/terms.pl

@@ -0,0 +1,18 @@
+/** Term helpers compatible with the Scryer library surface used by CLP(Z). */
+
+:- module(terms, [numbervars/3, copy_term_nat/2]).
+
+:- use_module(library(error), [must_be/2, can_be/2]).
+
+copy_term_nat(Term, Copy) :- copy_term(Term, Copy).
+
+numbervars(Term, N0, N) :-
+    must_be(integer, N0),
+    can_be(integer, N),
+    term_variables(Term, Variables),
+    terms__numbervars(Variables, N0, N).
+
+terms__numbervars([], N, N).
+terms__numbervars(['$VAR'(N0)|Variables], N0, N) :-
+    N1 is N0 + 1,
+    terms__numbervars(Variables, N1, N).

package/src/parser.js

@@ -1119,6 +1119,32 @@ class Parser {
         head = items.pop();
         while (items.length > 0) head = compound(',', [items.pop(), head]);
       }
+      // The clause grammar keeps priority-1200 neck/DCG tokens outside the
+      // initial head parse. A user-defined operator at priority 1199 or 1200,
+      // however, can itself be the outermost source term. Scryer's CLP(Z) uses
+      // exactly this shape for its private `++>` Duo-DCG rules. Fold such a
+      // custom low-strength infix operator back into the source term while
+      // leaving the processor-defined :-, -->, and ?- dispatch below intact.
+      const topLevelOperator = this.operatorTokenName();
+      const topLevelInfo = topLevelOperator == null ? null : this.infixOperators.get(topLevelOperator);
+      if (topLevelInfo && topLevelInfo.precedence < 3 &&
+          ![':-', '-->', '?-'].includes(topLevelOperator)) {
+        this.advance();
+        const right = this.parseTerm(
+          topLevelInfo.associativity === 'right' ? topLevelInfo.precedence : topLevelInfo.precedence + 1,
+          true,
+          true,
+          false,
+        );
+        head = compound(topLevelOperator, [head, right]);
+        if (topLevelInfo.associativity === 'none') {
+          const nextOperator = this.operatorTokenName();
+          if (this.infixOperators.get(nextOperator)?.precedence === topLevelInfo.precedence) {
+            throw new Error(`parse line ${this.token.line}: non-associative operator ${topLevelOperator} requires parentheses`);
+          }
+        }
+      }
+
       // Parentheses and other ordinary term syntax may hide the surface ?-
       // token from the program-level dispatch above.  Once the complete head
       // term has been parsed, recognize the same ?-/1 or ?-/2 structure here.

package/src/program.js

@@ -21,6 +21,7 @@ import {
   eyePrologInteropLibraryModules,
 } from './standard-library.js';
 import { expandDcgRuleClause } from './dcg.js';
+import { expandClauseGoals, expandSourceClause } from './source-expansion.js';
 import {
   CompactBinaryClause, clauseBodyLength, clauseHasCut, compactHeadArgName, compactHeadArgType, modulePredicateKey,
   indexCompactOne, indexOne, isCompactBinaryClause, makeArgumentIndex, rebuildGroupIndexes, termContainsCut, termHasNoVariables,
@@ -1069,18 +1070,56 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     builder.addClauses(batch);
     batch.length = 0;
   };
-  const accept = (clause) => {
+
+  const processClause = (inputClause) => {
+    let clause = inputClause;
     if (clause?.kind === 'quad') {
       flush();
       clause.module = context.module;
       builder.addClauses([clause]);
       return;
     }
+
+    // User source expansion is a normal-profile compile-time facility. Hooks
+    // execute against the clauses that have already been prepared, matching
+    // Prolog's left-to-right source loading model. Strict ISO Part 1 keeps its
+    // processor-defined preparation semantics unchanged.
+    if (!builder.program.strictIso) {
+      const expansion = expandSourceClause(builder.program, clause, context.module, {
+        module: context.module,
+        filename: options.filename ?? '<input>',
+      });
+      if (expansion.expanded) {
+        for (const generated of expansion.clauses) processPreparedClause(generated);
+        return;
+      }
+    }
+    processPreparedClause(clause);
+  };
+
+  const processPreparedClause = (inputClause) => {
+    let clause = inputClause;
+    const lexicalModule = context.module;
+
     // Grammar-rule expansion belongs to ISO/IEC TS 13211-3 rather than the
     // Part 1 strict-core language.  In strict core mode -->/2 remains the
     // ordinary predefined operator term from Table 7 and is not rewritten.
-    const grammarClause = builder.program.strictIso ? null : expandDcgRuleClause(clause, context.module);
+    const grammarClause = builder.program.strictIso ? null : expandDcgRuleClause(clause, lexicalModule);
     if (grammarClause) clause = grammarClause;
+
+    // A source module qualifier on a clause head selects the procedure owner,
+    // while unqualified calls in the body retain the lexical module of the
+    // source text. This distinction is essential for conventional hooks such
+    // as user:term_expansion/2 defined from library modules.
+    clause = normalizeQualifiedClauseHead(clause, lexicalModule);
+
+    if (!builder.program.strictIso && !isDirectiveClause(clause)) {
+      expandClauseGoals(builder.program, clause, lexicalModule, {
+        module: lexicalModule,
+        filename: options.filename ?? '<input>',
+      });
+    }
+
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
       flush();
@@ -1121,10 +1160,20 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       clause.module ??= context.module;
       clause.textUnit ??= context.textUnit;
       if (!isDirectiveClause(clause)) {
-        for (const goal of clause.body) annotateGoalModule(goal, clause.module);
+        const bodyModule = clause.lexicalModule ?? lexicalModule;
+        for (const goal of clause.body) annotateGoalModule(goal, bodyModule);
+      }
+      const isExpansionHook = !isDirectiveClause(clause) &&
+        clause.head?.arity === 2 && ['term_expansion', 'goal_expansion'].includes(clause.head?.name);
+      if (isExpansionHook) {
+        // A hook becomes visible to the very next source term, so it cannot
+        // wait in the large streaming build batch.
+        flush();
+        builder.addClauses([clause]);
+      } else {
+        batch.push(clause);
+        if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
       }
-      batch.push(clause);
-      if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
       return;
     }
     flush();
@@ -1152,15 +1201,32 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       batch[batch.length - 1].textUnit = context.textUnit;
       if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
     };
-    const parsed = tryParseClausesFastInto(source, accept, acceptBinary, options);
+    const parsed = tryParseClausesFastInto(source, processClause, acceptBinary, options);
     if (parsed) flush();
     return parsed;
   }
-  parseClausesInto(source, options, accept);
+  parseClausesInto(source, options, processClause);
   flush();
   return true;
 }
 
+function normalizeQualifiedClauseHead(clause, lexicalModule = 'user') {
+  if (clause == null || clause.kind === 'quad' || isDirectiveClause(clause)) return clause;
+  const head = clause.head;
+  if (head?.type !== COMPOUND || head.name !== ':' || head.arity !== 2) return clause;
+  const qualifier = head.args[0];
+  const qualifiedHead = head.args[1];
+  if (qualifier.type === VAR) throw new PrologError('instantiation_error');
+  if (qualifier.type !== ATOM) throw new PrologError('type_error(atom)', qualifier);
+  if (qualifiedHead.type !== ATOM && qualifiedHead.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', qualifiedHead);
+  }
+  clause.head = qualifiedHead;
+  clause.module = qualifier.name;
+  clause.lexicalModule = lexicalModule;
+  return clause;
+}
+
 function includeDirective(clause) {
   if (isCompactBinaryClause(clause) || !isDirectiveClause(clause)) return null;
   const directive = clause.head.args[0];

package/src/scryer-compat.js

@@ -0,0 +1,39 @@
+// Small host primitives needed by Scryer-style declarative libraries.
+//
+// Keep these facilities generic: they are not part of the CLP(Z) engine. The
+// backtrackable blackboard lives in Env so ordinary Prolog choice points undo
+// writes automatically.
+
+import { ATOM, NUMBER, STRING, deref, unify } from './term.js';
+import { PrologError } from './errors.js';
+
+function blackboardKey(term, env) {
+  const value = deref(term, env);
+  if (value.type === ATOM) return `a:${value.name}`;
+  if (value.type === NUMBER) return `n:${value.name}`;
+  if (value.type === STRING) return `s:${value.name}`;
+  if (value.type === 'var') throw new PrologError('instantiation_error');
+  throw new PrologError('type_error(atomic)', value);
+}
+
+function* bbGetBuiltin({ goal, env }) {
+  const key = blackboardKey(goal.args[0], env);
+  const stored = env.getBacktrackableBlackboard(key);
+  if (stored === undefined) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stored, next)) yield next;
+}
+
+function* bbPutBuiltin({ goal, env }) {
+  const next = env.clone();
+  const key = blackboardKey(goal.args[0], next);
+  next.putBacktrackableBlackboard(key, deref(goal.args[1], next));
+  yield next;
+}
+
+export const scryerCompatibilityBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__bb_get', 2, bbGetBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__bb_b_put', 2, bbPutBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};

package/src/solver.js

@@ -8,7 +8,7 @@ import {
 import { numberValueKey, sameNumberValue } from './number-value.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
-import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
+import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
 import { clpzStateConsistent } from './clpz.js';
 import { hardHeapLimit, softHeapLimit, usedHeapSize } from './platform.js';

package/src/source-expansion.js

@@ -0,0 +1,173 @@
+// User-defined source expansion for the normal EyeProlog profile.
+//
+// This deliberately sits beside program preparation rather than inside the
+// term kernel. A small, fresh Solver executes already-loaded expansion hooks
+// against the partially built Program. The solver itself imports clause-index
+// helpers directly, so this compiler service does not introduce a module cycle.
+
+import {
+  ATOM, COMPOUND, Env, Term, VAR, atom, compound, deref, variable, variantTerms,
+} from './term.js';
+import { modulePredicateKey } from './program-indexing.js';
+import { Solver } from './solver.js';
+import { clauseToSourceTerm, sourceTermToClauses } from './expansion-builtins.js';
+import { PrologError } from './errors.js';
+
+let expansionFresh = 0;
+const MAX_EXPANSION_DEPTH = 64;
+const MAX_EXPANSION_INFERENCES = 1_000_000;
+
+function exactHookGroup(program, module, name) {
+  return program.groups.get(modulePredicateKey(module, name, 2)) ?? null;
+}
+
+function hookModules(module) {
+  return module === 'user' ? ['user'] : [module, 'user'];
+}
+
+function inputVariableNames(term) {
+  const names = new Set();
+  const stack = [term];
+  const seen = new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current == null || seen.has(current)) continue;
+    seen.add(current);
+    if (current.type === VAR) {
+      names.add(current.name);
+      continue;
+    }
+    if (current.type === COMPOUND) {
+      for (const arg of current.args) stack.push(arg);
+    }
+  }
+  return names;
+}
+
+function copyHookResult(term, env, inputNames) {
+  const rootNames = new Map();
+  for (const name of inputNames) {
+    const root = deref(variable(name), env);
+    if (root.type === VAR && !rootNames.has(root.name)) rootNames.set(root.name, name);
+  }
+  const copy = (value) => {
+    const resolved = deref(value, env);
+    if (resolved.type === VAR) return variable(rootNames.get(resolved.name) ?? resolved.name);
+    const copied = resolved.type === COMPOUND && resolved.arity === 0
+      ? atom(resolved.name)
+      : new Term(resolved.type, resolved.name, resolved.args.map(copy));
+    if (resolved.module != null) copied.module = resolved.module;
+    return copied;
+  };
+  return copy(term);
+}
+
+function runHook(program, module, name, input, loadContext = null) {
+  for (const owner of hookModules(module)) {
+    const group = exactHookGroup(program, owner, name);
+    if (group == null || group.clauses.length === 0) continue;
+
+    const output = variable(`\u0000source-expansion:${++expansionFresh}`);
+    const goal = compound(name, [input, output]);
+    goal.module = owner;
+    const solver = new Solver(program, {
+      solutionLimit: 1,
+      maxInferences: MAX_EXPANSION_INFERENCES,
+      sourceLoadContext: loadContext,
+    });
+    const inputNames = inputVariableNames(input);
+    for (const answer of solver.solve([goal], new Env())) {
+      return copyHookResult(output, answer, inputNames);
+    }
+  }
+  return null;
+}
+
+function sourceTermsAreVariants(left, right) {
+  return variantTerms(left, new Env(), right, new Env());
+}
+
+function expandTermRecursively(program, module, term, loadContext, depth) {
+  if (depth > MAX_EXPANSION_DEPTH) throw new PrologError('resource_error(source_expansion)');
+  const expanded = runHook(program, module, 'term_expansion', term, loadContext);
+  if (expanded == null) return sourceTermToClauses(term);
+
+  const clauses = sourceTermToClauses(expanded);
+  if (clauses.length === 1 && sourceTermsAreVariants(term, clauseToSourceTerm(clauses[0]))) return clauses;
+  const result = [];
+  for (const clause of clauses) {
+    const generatedTerm = clauseToSourceTerm(clause);
+    result.push(...expandTermRecursively(program, module, generatedTerm, loadContext, depth + 1));
+  }
+  return result;
+}
+
+export function expandSourceClause(program, clause, module = 'user', loadContext = null) {
+  const sourceTerm = clauseToSourceTerm(clause);
+  if (sourceTerm == null) return { expanded: false, clauses: [clause] };
+  if (exactHookGroup(program, module, 'term_expansion') == null &&
+      (module === 'user' || exactHookGroup(program, 'user', 'term_expansion') == null)) {
+    return { expanded: false, clauses: [clause] };
+  }
+  const first = runHook(program, module, 'term_expansion', sourceTerm, loadContext);
+  if (first == null) return { expanded: false, clauses: [clause] };
+
+  const firstClauses = sourceTermToClauses(first);
+  if (firstClauses.length === 1 && sourceTermsAreVariants(sourceTerm, clauseToSourceTerm(firstClauses[0]))) {
+    return { expanded: false, clauses: [clause] };
+  }
+  const result = [];
+  for (const generated of firstClauses) {
+    const generatedTerm = clauseToSourceTerm(generated);
+    result.push(...expandTermRecursively(program, module, generatedTerm, loadContext, 1));
+  }
+  return { expanded: true, clauses: result };
+}
+
+function isCallable(term) {
+  return term?.type === ATOM || term?.type === COMPOUND;
+}
+
+function expandGoalChildren(program, goal, module, loadContext, depth) {
+  if (goal.type !== COMPOUND) return goal;
+
+  if (goal.name === ':' && goal.arity === 2) {
+    const qualifier = deref(goal.args[0], new Env());
+    if (qualifier.type === VAR) return goal;
+    if (qualifier.type !== ATOM) return goal;
+    const child = expandGoalRecursively(program, goal.args[1], qualifier.name, loadContext, depth + 1);
+    return compound(':', [goal.args[0], child]);
+  }
+
+  if ([',', ';', '->'].includes(goal.name) && goal.arity === 2) {
+    return compound(goal.name, [
+      expandGoalRecursively(program, goal.args[0], module, loadContext, depth + 1),
+      expandGoalRecursively(program, goal.args[1], module, loadContext, depth + 1),
+    ]);
+  }
+  if (goal.name === '\\+' && goal.arity === 1) {
+    return compound('\\+', [expandGoalRecursively(program, goal.args[0], module, loadContext, depth + 1)]);
+  }
+  return goal;
+}
+
+function expandGoalRecursively(program, goal, module, loadContext, depth = 0) {
+  if (depth > MAX_EXPANSION_DEPTH) throw new PrologError('resource_error(source_expansion)');
+  const resolved = deref(goal, new Env());
+  if (!isCallable(resolved)) return resolved;
+
+  const expanded = runHook(program, module, 'goal_expansion', resolved, loadContext);
+  if (expanded != null) {
+    if (!isCallable(expanded)) throw new PrologError('type_error(callable)', expanded);
+    if (sourceTermsAreVariants(resolved, expanded)) return expandGoalChildren(program, resolved, module, loadContext, depth);
+    return expandGoalRecursively(program, expanded, module, loadContext, depth + 1);
+  }
+  return expandGoalChildren(program, resolved, module, loadContext, depth);
+}
+
+export function expandClauseGoals(program, clause, lexicalModule = 'user', loadContext = null) {
+  if (!Array.isArray(clause.body) || clause.body.length === 0) return clause;
+  clause.body = clause.body.map((goal) =>
+    expandGoalRecursively(program, goal, lexicalModule, loadContext));
+  return clause;
+}

package/src/standard-library.js

@@ -5,23 +5,36 @@
 import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { clpzBuiltins } from './clpz.js';
 import { attsBuiltins } from './atts.js';
+import { expansionBuiltins } from './expansion-builtins.js';
+import { scryerCompatibilityBuiltins } from './scryer-compat.js';
 import { registerCleanupBuiltins } from './cleanup.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
 import { ATOM, VAR, atom, deref, numberTerm, unify } from './term.js';
 
 const moduleFiles = Object.freeze({
   aggregate: 'aggregate.pl',
+  arithmetic: 'arithmetic.pl',
+  assoc: 'assoc.pl',
   atts: 'atts.pl',
+  between: 'between.pl',
   clpz: 'clpz.pl',
   comparison: 'comparison.pl',
   dates: 'dates.pl',
+  dcgs: 'dcgs.pl',
+  debug: 'debug.pl',
+  error: 'error.pl',
+  format: 'format.pl',
+  freeze: 'freeze.pl',
   iso_ext: 'iso_ext.pl',
   lambda: 'lambda.pl',
   lists: 'lists.pl',
+  pairs: 'pairs.pl',
   primes: 'primes.pl',
   prologue: 'prologue.pl',
   random: 'random.pl',
+  si: 'si.pl',
   strings: 'strings.pl',
+  terms: 'terms.pl',
   uuid: 'uuid.pl',
 });
 
@@ -188,6 +201,8 @@ export function createEyePrologRegistry() {
   registerCleanupBuiltins(registry);
   eyePrologLibraryBuiltins.register(registry);
   attsBuiltins.register(registry);
+  expansionBuiltins.register(registry);
+  scryerCompatibilityBuiltins.register(registry);
   clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;
   return registry;

package/src/term.js

@@ -109,6 +109,9 @@ export class Env {
     this._prologAttributes = null;
     this._attributeHookRunner = null;
     this._pendingAttributeGoals = null;
+    // Backtrackable blackboard entries used by Scryer-compatible libraries.
+    // Values are logical terms and the map is copy-on-write across Env clones.
+    this._backtrackableBlackboard = null;
     this._clpz = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
@@ -127,6 +130,7 @@ export class Env {
     clone._prologAttributes = this._prologAttributes;
     clone._attributeHookRunner = this._attributeHookRunner;
     clone._pendingAttributeGoals = this._pendingAttributeGoals;
+    clone._backtrackableBlackboard = this._backtrackableBlackboard;
     clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
@@ -148,12 +152,21 @@ export class Env {
     this._variableAnnotations = other._variableAnnotations;
     this._prologAttributes = other._prologAttributes;
     this._pendingAttributeGoals = other._pendingAttributeGoals;
+    this._backtrackableBlackboard = other._backtrackableBlackboard;
     this._clpz = other._clpz;
     // Execution callbacks belong to the Solver driving this Env, not to the
     // logical branch being adopted from an inner attribute-hook call.
     this._localVariables = other._localVariables;
     return this;
   }
+  getBacktrackableBlackboard(key) {
+    return this._backtrackableBlackboard?.get(key);
+  }
+  putBacktrackableBlackboard(key, value) {
+    const next = new Map(this._backtrackableBlackboard ?? []);
+    next.set(key, value);
+    this._backtrackableBlackboard = next;
+  }
   hasLocalVariables() {
     return this._localVariables != null && this._localVariables.size !== 0;
   }