package nova;
import java.util.*;
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
public final class Store {
public static final int UNDEF_INT = -2;
public static final Object UNDEF_OBJ = new Object();
public static final int MASK_PRED_PREHASH = 0x00000010;
public static final int MASK_PRED_ARITH = 0x00000008;
public static final int MASK_PRED_SPECIAL = 0x00000004;
public static final int MASK_PRED_TEST = 0x00000002;
public static final int MASK_PRED_DYNAMIC = 0x00000001;
public static final int MASK_TOUCH_PREHASH = 0x00000004;
public static final int MASK_TOUCH_BOTTOM = 0x00000002;
public static final int MASK_TOUCH_DYNAMIC = 0x00000001;
public static final int MASK_REMOVE_REVERSE = 0x00000001;
public static final int VAR_MASK_SEEN = 0x40000000;
public static final int VAR_MASK_EVEN = 0x20000000;
public static final int VAR_MASK_ODD = 0x10000000;
public static final int VAR_MASK_STATE = VAR_MASK_EVEN | VAR_MASK_ODD;
public static final int VAR_MASK_BITS = 28;
public static final int VAR_MASK_SERNO = (1 << VAR_MASK_BITS) - 1;
public static Map kb = new HashMap();
public static int stage = -1;
public static final int MAX_INDEX = 2;
private static final int ROPE_LOW = 24;
private static final int ROPE_HIGH = 40;
private static final int BOUQUET_LOW = 12;
private static final int BOUQUET_HIGH = 20;
/**
* Set the clause and predicate current stage.
*
* @param num The current stage.
*/
public static void set_stage(int num) {
stage = num;
}
/**
* Set the clause current partition.
*
* @param path The current partition.
*/
public static void set_partition(String path) {
engine.partition = path;
}
/**************************************************************/
/* Engine */
/**************************************************************/
public static final class Engine {
public Object signal;
public Runnable abort;
public int flags;
public runtime.Sink text_output;
public runtime.Sink text_error;
public runtime.Source text_input;
public int low;
public int high;
public int serno;
public Variable backtrail;
public String partition;
/**
* Create a slow state engine.
*/
public Engine() {
this.signal = UNDEF_OBJ;
this.abort = () -> {
};
this.flags = 0;
this.text_output = null;
this.text_error = null;
this.text_input = null;
this.low = 0;
this.high = 0;
this.serno = 0;
this.backtrail = null;
this.partition = (stage == -1 ? "system" : "user");
}
}
public static Engine engine = new Engine();
public static void set_engine(Engine ptr) {
engine = ptr;
}
/**************************************************************/
/* Variable & Compound */
/**************************************************************/
public static final class Variable {
public Object instantiated;
public int flags;
public Object tail;
/**
* Create a Prolog variable.
*/
public Variable() {
this.instantiated = UNDEF_OBJ;
this.flags = VAR_MASK_SERNO;
this.tail = null;
}
}
/**
* Check whether an object is a Prolog variable.
*
* @param obj The object.
* @return boolean True if the object is a variable, otherwise false.
*/
public static boolean is_variable(Object obj) {
return obj instanceof Variable;
}
/**
* Compute a variable serno.
*
* @param alpha The variable.
* @return The serno.
*/
public static int variable_serno(Variable alpha) {
int val = alpha.flags & VAR_MASK_SERNO;
if (val == VAR_MASK_SERNO) {
if (engine.low < engine.high) {
val = engine.low;
engine.low = val + 1;
} else {
val = engine.serno;
engine.serno = val + 1;
}
alpha.flags &= ~VAR_MASK_SERNO;
alpha.flags |= val;
}
return val;
}
public static class Element {
public Object functor;
public Object[] args;
/**
* Create an element.
*
* @param functor The functor.
* @param args The arguments.
*/
public Element(Object functor, Object[] args) {
this.functor = functor;
this.args = args;
}
}
/**
* Check whether an object is an element.
*
* @param obj The object.
* @return True if the object is an element, otherwise false.
*/
public static boolean is_element(Object obj) {
return obj instanceof Element;
}
public static class Structure extends Element {
/**
* Create a Prolog structure.
*
* @param functor The functor.
* @param args The arguments.
*/
public Structure(Object functor, Object[] args) {
super(functor, args);
}
}
/**
* Check whether an object is a Prolog structure.
*
* @param obj The object.
* @return True if the object is a compound, otherwise false.
*/
public static boolean is_structure(Object obj) {
return obj instanceof Structure;
}
public static final class Compound extends Structure {
public int walk;
/**
* Create a Prolog compound.
*
* @param functor The functor.
* @param args The arguments.
*/
public Compound(Object functor, Object[] args) {
super(functor, args);
this.walk = 0;
}
}
/**
* Check whether an object is a Prolog compound.
*
* @param obj The object.
* @return True if the object is a compound, otherwise false.
*/
public static boolean is_compound(Object obj) {
return obj instanceof Compound;
}
/**************************************************************/
/* Place & Skeleton */
/**************************************************************/
public static final class Place {
public final int index;
/**
* Create a Albufeira Code place.
*/
public Place(int index) {
this.index = index;
}
}
/**
* Check whether an object is a place.
*
* @param obj The object.
* @return boolean True if the object is a place, otherwise false.
*/
public static boolean is_place(Object obj) {
return obj instanceof Place;
}
public static final class Skeleton extends Element {
/**
* Create a Albufeira Code skeleton.
*
* @param functor The functor.
* @param args The arguments.
*/
public Skeleton(Object functor, Object[] args) {
super(functor, args);
}
}
/**
* Check whether an object is a skeleton.
*
* @param obj The object.
* @return boolean True if the object is a skeleton, otherwise false.
*/
public static boolean is_skeleton(Object obj) {
return obj instanceof Skeleton;
}
/**************************************************************/
/* deref() and copy_term() */
/**************************************************************/
/**
* Dereference a Prolog term.
*
* @param term The Prolog term.
* @return any The dereferenced Prolog term.
*/
public static Object deref(Object term) {
while (is_variable(term) &&
((Variable) term).instantiated != UNDEF_OBJ)
term = ((Variable) term).instantiated;
return term;
}
/**
* Copy a Prolog term.
* Can handle cyclic terms and deep recursion.
*
* @param first The Prolog term.
* @return The copy.
*/
public static Object copy_term(Object first) {
Object res;
try {
res = walk_copy(first);
} finally {
walk_uncopy(first);
}
return res;
}
private static Object walk_copy(Object first) {
List stack = null;
for (; ; ) {
first = Store.deref(first);
if (Store.is_variable(first)) {
if (((Store.Variable) first).tail == null) {
Store.Variable peek = new Store.Variable();
((Store.Variable) first).tail = peek;
first = peek;
} else {
first = ((Store.Variable) first).tail;
}
} else if (Store.is_compound(first)) {
if (!Store.is_compound(((Store.Structure) first).functor)) {
((Store.Structure) first).functor = new Store.Compound(((Store.Structure) first).functor,
new Object[((Store.Structure) first).args.length]);
((Store.Compound) first).walk &= ~Store.VAR_MASK_SERNO;
stack = Store.stack_push(stack, first);
first = ((Store.Structure) first).args[0];
continue;
} else {
first = ((Store.Structure) first).functor;
}
}
Store.Compound item = (Store.Compound) Store.stack_peek(stack);
while (item != null &&
(item.walk & Store.VAR_MASK_SERNO) == item.args.length - 1) {
((Store.Structure) item.functor).args[item.walk & Store.VAR_MASK_SERNO] = first;
first = item.functor;
Store.stack_pop(stack);
item = (Store.Compound) Store.stack_peek(stack);
}
if (item == null) {
return first;
} else {
((Store.Structure) item.functor).args[item.walk & Store.VAR_MASK_SERNO] = first;
item.walk++;
first = item.args[item.walk & Store.VAR_MASK_SERNO];
}
}
}
private static void walk_uncopy(Object first) {
List stack = null;
for (; ; ) {
first = Store.deref(first);
if (Store.is_variable(first)) {
if (((Store.Variable) first).tail != null)
((Store.Variable) first).tail = null;
} else if (Store.is_compound(first)) {
if (Store.is_compound(((Store.Structure) first).functor)) {
((Store.Structure) first).functor = ((Store.Structure) ((Store.Structure) first).functor).functor;
if (0 != ((Store.Structure) first).args.length - 1) {
((Store.Compound) first).walk &= ~Store.VAR_MASK_SERNO;
stack = Store.stack_push(stack, first);
}
first = ((Store.Structure) first).args[0];
continue;
}
}
Store.Compound item = (Store.Compound) Store.stack_peek(stack);
if (item == null) {
return;
} else {
item.walk++;
first = item.args[item.walk & Store.VAR_MASK_SERNO];
if ((item.walk & Store.VAR_MASK_SERNO) == item.args.length - 1)
Store.stack_pop(stack);
}
}
}
/**************************************************************/
/* Binary Work */
/**************************************************************/
public static final class Item {
public final Structure first;
public Object second;
public int idx;
/**
* Create a binary work item.
*
* @param first The first Prolog term.
* @param second The second Prolog term.
* @param idx The index.
*/
public Item(Structure first, Object second, int idx) {
this.first = first;
this.second = second;
this.idx = idx;
}
}
/**************************************************************/
/* Stack Array */
/**************************************************************/
/**
* The function returns the same stack extended by a work item.
*
* @param stack The stack.
* @param elem The work item.
* @return The new stack.
*/
public static List stack_push(List stack, Object elem) {
if (stack == null)
stack = new ArrayList();
stack.add(elem);
return stack;
}
/**
* The function returns the top work item or null.
*
* @param stack The stack.
* @return The work item.
*/
public static Object stack_peek(List stack) {
if (stack == null)
return null;
if (stack.size() == 0)
return null;
return stack.get(stack.size() - 1);
}
/**
* The routine removes the top work item from the stack.
*
* @param stack The stack.
*/
public static void stack_pop(List stack) {
stack.remove(stack.size() - 1);
}
/**************************************************************/
/* Clauses Lifecycle */
/**************************************************************/
public static final class Goal {
public final int size;
public final Object[] body;
public final int cutvar;
public Goal(int size, Object[] body, int cutvar) {
this.size = size;
this.body = body;
this.cutvar = cutvar;
}
}
/**
* Check whether the object is a goal.
*
* @param obj The object.
* @return boolean if the object is a goal, otherwise false.
*/
public static boolean is_goal(Object obj) {
return obj instanceof Goal;
}
public static final class Clause {
public final int size;
public final Object functor;
public final Object[] head;
public final Object[] body;
public final int cutvar;
public int creator;
public int remover;
public String shard;
public Clause(int size, Object functor, Object[] head,
Object[] body, int cutvar) {
this.size = size;
this.functor = functor;
this.head = head;
this.body = body;
this.cutvar = cutvar;
this.creator = UNDEF_INT;
this.remover = UNDEF_INT;
this.shard = "";
}
}
/**
* Check whether the object is a clause.
*
* @param obj The object.
* @return boolean if the object is a clause, otherwise false.
*/
public static boolean is_clause(Object obj) {
return obj instanceof Clause;
}
public static final class Logical {
public Clause[] cache;
public int count;
public SequencedCollection data;
/**
* Create a logical.
*
* @param cache The cache of non-deleted clauses.
* @param count The counter of non-deleted clauses.
* @param data The clause list.
*/
public Logical(Clause[] cache, int count, SequencedCollection data) {
this.cache = cache;
this.count = count;
this.data = data;
}
}
/**
* Check whether an object is a logical.
*
* @param obj The object.
* @return boolean if the object is a logical, otherwise false.
*/
public static boolean is_logical(Object obj) {
return obj instanceof Logical;
}
public static final class Stick {
public Logical rope;
public Object[] guards;
public Map[] maps;
/**
* Create a stick.
*
* @param rope The rope.
* @param guards The variable guards.
* @param maps The index map.
*/
public Stick(Logical rope, Object[] guards, Map[] maps) {
this.rope = rope;
this.guards = guards;
this.maps = maps;
}
}
/**
* Check whether an object is a stick.
*
* @param obj The object.
* @return boolean if the object is a stick, otherwise false.
*/
public static boolean is_stick(Object obj) {
return obj instanceof Stick;
}
public static Object index_value(Object temp, Object[] body, int flags) {
int j = 0;
for (;;) {
if (!is_place(temp)) {
if ((flags & MASK_PRED_PREHASH) != 0) {
if (Machine.is_frozen(temp)) {
temp = Integer.valueOf(((Machine.Frozen) temp).hash);
} else if (!is_skeleton(temp)) {
temp = Integer.valueOf(Objects.hashCode(temp));
} else {
temp = UNDEF_OBJ;
}
} else {
if (is_element(temp))
temp = ((Element) temp).functor;
}
break;
}
if (temp != UNDEF_OBJ &&
(flags & MASK_PRED_DYNAMIC) == 0 &&
j < body.length) {
Object peek = body[j];
j++;
if (is_element(peek) &&
"=".equals(site_name(((Element) peek).functor)) &&
((Element) peek).args.length == 2) {
if (temp.equals(((Element) peek).args[0])) {
temp = ((Element) peek).args[1];
} else if (temp.equals(((Element) peek).args[1])) {
temp = ((Element) peek).args[0];
}
continue;
} else if (is_element(peek) &&
"nonvar".equals(site_name(((Element) peek).functor)) &&
((Element) peek).args.length == 1) {
continue;
}
}
temp = UNDEF_OBJ;
break;
}
return temp;
}
private static Object site_name(Object obj) {
if (is_cache(obj)) {
return ((Cache)obj).name;
} else {
return obj;
}
}
/**************************************************************/
/* Knowledgebase */
/**************************************************************/
public static final class Provable {
public int flags;
public Object func;
public int creator;
public int remover;
public Provable overlay;
/**
* Create a provable.
*/
public Provable() {
this.flags = 0;
this.func = null;
this.creator = stage;
this.remover = UNDEF_INT;
this.overlay = null;
}
}
/**
* Check whether an object is a provable.
*
* @param obj The object.
* @return boolean True if the object is a provable, otherwise false.
*/
public static boolean is_provable(Object obj) {
return obj instanceof Provable;
}
public static final class Cache {
public Provable link;
public String name;
/**
* Create a cache node.
*
* @param name The functor.
*/
public Cache(String name) {
this.link = null;
this.name = name;
}
}
/**
* Check whether an object is a cache.
*
* @param obj The object.
* @return boolean True if the object is a cache, otherwise false.
*/
public static boolean is_cache(Object obj) {
return obj instanceof Cache;
}
/******************************************************************/
/* Snapshot Data */
/******************************************************************/
public static Clause[] snapshot_peek(Object func) {
if (is_stick(func)) {
return snapshot_rope(((Stick)func).rope);
} else {
return snapshot_rope((Logical)func);
}
}
/**
* Make snapshot of a logical.
*
* @param rope The logical.
* @return array The clause list snapshot.
*/
public static Clause[] snapshot_rope(Logical rope) {
Clause[] res = rope.cache;
if (res == null) {
res = new Clause[rope.count];
copy_rope(res, rope);
rope.cache = res;
}
return res;
}
private static void copy_rope(Clause[] res, Logical rope) {
if (rope.data instanceof List) {
List data = (List) rope.data;
int j = 0;
for (int i = 0; i < data.size(); i++) {
Clause clause = (Clause) data.get(i);
if (clause.remover == UNDEF_INT)
res[j++] = clause;
}
} else {
Set data = (Set) rope.data;
Iterator it = data.iterator();
int j = 0;
while (it.hasNext()) {
Clause clause = (Clause) it.next();
if (clause.remover == UNDEF_INT)
res[j++] = clause;
}
}
}
/******************************************************************/
/* Linked Provables */
/******************************************************************/
/**
* Retrieve a provable from monomorphic cache.
*
* @param cache The cache.
* @param arity The arity.
* @return The provable or null.
*/
public static Provable ensure_link(Cache cache, int arity) {
Provable peek = cache.link;
if (peek == null || peek.remover != UNDEF_INT) {
peek = pred_link(cache.name, arity);
cache.link = peek;
}
return peek;
}
public static Provable pred_link(String functor, int arity) {
if (arity < 0)
return null;
List temp = (List) kb.get(functor);
if (temp == null)
return null;
Provable peek = (arity < temp.size() ? (Provable) temp.get(arity) : null);
if (peek == null || peek.remover != UNDEF_INT)
return null;
return peek;
}
public static Provable resolve_link(Object functor, int arity) {
if (is_cache(functor)) {
return ensure_link((Cache) functor, arity);
} else if (Machine.is_atom(functor)) {
return pred_link((String) functor, arity);
} else if (is_provable(functor)) {
return (Provable) functor;
} else {
check_nonvar(functor);
functor = copy_term(functor);
throw Machine.make_error(new Compound("type_error",
new Object[]{"callable", functor}));
}
}
/**
* Assure that the object is a nonvar.
*
* @param beta The object.
*/
public static void check_nonvar(Object beta) {
if (is_variable(beta))
throw Machine.make_error("instantiation_error");
}
/******************************************************************/
/* Dynamic Predicates */
/******************************************************************/
/**
* Retrieve or create a provable from monomorphic cache.
*
* @param cache The cache.
* @param arity The arity.
* @return The provable.
*/
public static Provable ensure_touch(Cache cache, int arity, int flags) {
Provable peek = cache.link;
if (peek == null || peek.remover != UNDEF_INT) {
peek = pred_touch(cache.name, arity, flags);
cache.link = peek;
}
return peek;
}
public static Provable pred_touch(String functor, int arity, int flags) {
List temp = (List) kb.get(functor);
if (temp == null) {
temp = new Handler.Rope();
kb.put(functor, temp);
}
Provable peek = (arity < temp.size() ? (Provable) temp.get(arity) : null);
if (peek == null || peek.remover != UNDEF_INT) {
Provable res = make_defined(Machine.VOID_ARGS);
if (peek != null)
res.overlay = peek;
if ((flags & MASK_TOUCH_DYNAMIC) != 0)
res.flags |= MASK_PRED_DYNAMIC;
while (arity >= temp.size())
temp.add(null);
temp.set(arity, res);
peek = res;
} else {
if (!is_logical(peek.func) && !is_stick(peek.func))
throw Machine.make_error(new Compound("permission_error",
new Object[]{"modify", "static_procedure",
Machine.make_indicator(functor, arity)}));
if ((flags & MASK_TOUCH_DYNAMIC) != 0)
if ((peek.flags & MASK_PRED_DYNAMIC) == 0)
throw Machine.make_error(new Compound("permission_error",
new Object[]{"modify", "static_procedure",
Machine.make_indicator(functor, arity)}));
}
if ((flags & MASK_TOUCH_PREHASH) != 0) {
if ((peek.flags & MASK_PRED_PREHASH) == 0) {
if (is_stick(peek.func))
peek.func = ((Stick)peek.func).rope;
peek.flags |= MASK_PRED_PREHASH;
}
}
return peek;
}
private static Provable resolve_touch(Object functor, int arity, int flags) {
if (is_cache(functor)) {
return ensure_touch((Cache) functor, arity, flags);
} else if (Machine.is_atom(functor)) {
return pred_touch((String) functor, arity, flags);
} else if (is_provable(functor)) {
return (Provable) functor;
} else {
check_nonvar(functor);
functor = copy_term(functor);
throw Machine.make_error(new Compound("type_error",
new Object[]{"callable", functor}));
}
}
/******************************************************************/
/* Index Extension */
/******************************************************************/
/**
* The function returns an anonymous predicate for the given clauses.
* The index is not yet built, so only a logical is stored.
*
* @param data The clauses.
* @return Provable predicate.
*/
public static Provable make_defined(Object[] data) {
Provable peek = new Provable();
peek.func = new_rope();
for (int i = 0; i < data.length; i++)
add_peek(peek.func, 0, (Clause)data[i], MASK_TOUCH_BOTTOM, peek.flags);
return peek;
}
private static Logical new_rope() {
return new Logical(null, 0, new Handler.Rope());
}
public static Stick new_bouquet(Logical rope, int width) {
Object[] guards = new Object[width];
Map[] maps = new Map[width];
return new Stick(rope, guards, maps);
}
public static void extend_bouquet(Stick peek, int j, int offset, Logical rope, int flags) {
peek.guards[j] = new_rope();
peek.maps[j] = new Handler.ArrayMap();
if (rope.data instanceof List) {
List data = (List) rope.data;
for (int i = 0; i < data.size(); i++) {
Clause clause = (Clause) data.get(i);
if (clause.remover == UNDEF_INT)
add_map(peek, j, offset, clause, MASK_TOUCH_BOTTOM, flags);
}
} else {
Set data = (Set) rope.data;
Iterator it = data.iterator();
while (it.hasNext()) {
Clause clause = (Clause) it.next();
if (clause.remover == UNDEF_INT)
add_map(peek, j, offset, clause, MASK_TOUCH_BOTTOM, flags);
}
}
}
/**************************************************************/
/* Clauses Retrieval */
/**************************************************************/
/**
* Retrieve a logical from a provable possibly using an index.
* If only a logical is stored, build an index before retrieval.
*
* @param peek The provable.
* @param args The actual arguments.
* @return The logical.
*/
public static Logical defined_pred(Object peek, Object[] args) {
int width = Math.min(MAX_INDEX, args.length);
int offset = 0;
Object func = ((Provable)peek).func;
int flags = ((Provable)peek).flags;
Object val = null;
int k = 0;
for (;;) {
Logical rope;
if (is_stick(func)) {
rope = ((Stick) func).rope;
} else {
rope = (Logical) func;
}
if (rope.count < 2)
return rope;
int i = 0;
for (; i < width; i++) {
Object key = key_value(args[i+offset], flags);
if (key == UNDEF_OBJ)
continue;
if (!is_stick(func)) {
func = new_bouquet(rope, width);
if (is_stick(peek)) {
if (val == UNDEF_OBJ) {
((Stick)peek).guards[k] = func;
} else {
((Stick)peek).maps[k].put(val, func);
}
} else {
((Provable)peek).func = func;
}
}
peek = func;
if (((Stick)peek).maps[i] == null)
extend_bouquet((Stick) peek, i, offset, rope, flags);
if (((Stick)peek).maps[i].size() == 0)
continue;
func = ((Stick)peek).maps[i].get(key);
if (func == null) {
func = ((Stick)peek).guards[i];
val = UNDEF_OBJ;
} else {
val = key;
}
k = i;
width = width-i-1;
offset = i+offset+1;
i = -1;
break;
}
if (!(i < width))
return rope;
}
}
private static Object key_value(Object term, int flags) {
term = deref(term);
if (!is_variable(term)) {
if ((flags & MASK_PRED_PREHASH) != 0) {
if (Machine.is_frozen(term)) {
term = Integer.valueOf(((Machine.Frozen) term).hash);
} else if (!is_compound(term)) {
term = Integer.valueOf(Objects.hashCode(term));
} else {
term = UNDEF_OBJ;
}
} else {
if (is_structure(term))
term = ((Structure) term).functor;
}
} else {
term = UNDEF_OBJ;
}
return term;
}
/*********************************************************************/
/* Destroy Provable */
/*********************************************************************/
/**
* Remove a predicate from the knowledge base.
*
* @param functor The functor.
* @param arity The arity.
*/
public static void pred_destroy(String functor, int arity) {
List temp = (List) kb.get(functor);
if (temp == null)
return;
Provable peek = (arity < temp.size() ? (Provable) temp.get(arity) : null);
if (peek == null || peek.remover != UNDEF_INT)
return;
if (peek.creator == stage) {
peek = clear_pop(peek);
temp.set(arity, peek);
if (peek == null && trim_arities(temp))
kb.remove(functor);
} else {
peek.remover = stage;
}
}
/**
* Clear and pop a provable.
*
* @param peek The provable.
* @return The parent provable.
*/
private static Provable clear_pop(Provable peek) {
peek.remover = stage;
peek.func = null;
Provable back = peek;
peek = back.overlay;
back.overlay = null;
return peek;
}
/**
* Trim the arities array.
*
* @param peek The arities array.
* @return boolean True if empty, otherwise fale.
*/
private static boolean trim_arities(List peek) {
int pos = peek.size();
while (pos > 0 && peek.get(pos - 1) == null)
pos--;
if (pos == 0)
return true;
if (pos != peek.size())
((Handler.Rope) peek).removeRange(pos, peek.size());
return false;
}
/**************************************************************/
/* Clauses Transactions */
/**************************************************************/
/**
* Rollback the clauses.
*/
public static void clear() {
Iterator it = kb.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
List temp = (List) entry.getValue();
for (int i = 0; i < temp.size(); i++) {
Provable peek = (Provable) temp.get(i);
if (peek == null)
continue;
if (peek.creator == stage) {
peek = clear_pop(peek);
temp.set(i, peek);
if (peek == null)
continue;
}
if (peek.remover == stage)
peek.remover = UNDEF_INT;
if (is_logical(peek.func) || is_stick(peek.func))
rollback_peek(peek.func, true);
}
if (trim_arities(temp))
it.remove();
}
}
private static void rollback_peek(Object func, boolean update) {
if (is_stick(func)) {
Stick peek = (Stick)func;
if (!has_action(peek.rope))
return;
for (int i = 0; i < peek.maps.length; i++) {
Map temp = peek.maps[i];
if (temp == null)
continue;
Iterator it = temp.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Object val = entry.getValue();
rollback_peek(val, false);
if (size_peek(val) == 0)
it.remove();
}
rollback_peek(peek.guards[i], false);
if (temp instanceof HashMap &&
temp.size() < BOUQUET_LOW)
peek.maps[i] = new Handler.ArrayMap(temp);
}
rollback_rope(peek.rope, update);
} else {
if (!has_action((Logical)func))
return;
rollback_rope((Logical)func, update);
}
}
public static int size_peek(Object func) {
Logical rope;
if (is_stick(func)) {
rope = ((Stick)func).rope;
} else {
rope = (Logical)func;
}
if (rope.data instanceof List) {
return rope.data.size();
} else {
return rope.data.size();
}
}
/**
* Check whether a logical has some action.
*
* @param rope The logical.
* @return boolean if the logical has some action, false otherwise.
*/
private static boolean has_action(Logical rope) {
if (rope.data instanceof List) {
List data = (List) rope.data;
for (int i = 0; i < data.size(); i++) {
Clause clause = (Clause) data.get(i);
if (clause.creator == stage)
return true;
if (clause.remover == stage)
return true;
}
return false;
} else {
Set data = (Set) rope.data;
Iterator it = data.iterator();
while (it.hasNext()) {
Clause clause = (Clause) it.next();
if (clause.creator == stage)
return true;
if (clause.remover == stage)
return true;
}
return false;
}
}
/**
* Rollback clauses from a logical.
*
* @param rope The logical.
* @param update The update flag.
*/
private static void rollback_rope(Logical rope, boolean update) {
if (rope.data instanceof List) {
List data = (List) rope.data;
int j = 0;
for (int i = 0; i < data.size(); i++) {
Clause clause = (Clause) data.get(i);
if (clause.creator == stage) {
rope.count--;
} else {
if (clause.remover == stage) {
if (update)
clause.remover = UNDEF_INT;
rope.count++;
}
data.set(j++, clause);
}
}
((Handler.Rope) data).removeRange(j, data.size());
rope.cache = null;
} else {
Set data = (Set) rope.data;
Iterator it = data.iterator();
while (it.hasNext()) {
Clause clause = (Clause) it.next();
if (clause.creator == stage) {
rope.count--;
it.remove();
} else {
if (clause.remover == stage) {
if (update)
clause.remover = UNDEF_INT;
rope.count++;
}
}
}
rope.cache = null;
}
}
/******************************************************************/
/* Provable Addition */
/******************************************************************/
/**
* Enhance the knowledge base by a provable.
*
* @param functor The functor.
* @param arity The arity.
* @param pred The provable.
*/
public static void set(String functor, int arity,
Provable pred) {
List temp = (Handler.Rope) kb.get(functor);
if (temp == null) {
temp = new Handler.Rope();
kb.put(functor, temp);
}
Provable peek = (arity < temp.size() ? (Provable) temp.get(arity) : null);
if (peek == null || peek.remover != UNDEF_INT) {
if (peek != null)
pred.overlay = peek;
while (arity >= temp.size())
temp.add(null);
temp.set(arity, pred);
} else {
throw Machine.make_error(new Compound("permission_error",
new Object[]{"coerce", "procedure",
Machine.make_indicator(functor, arity)}));
}
}
/******************************************************************/
/* Clause Addition */
/******************************************************************/
/**
* Enhance the knowledge base by a clause.
*
* @param clause The clause.
*/
public static void add(Clause clause) {
add_clause(clause, MASK_TOUCH_BOTTOM);
}
public static void add_clause(Clause clause, int flags) {
if (clause.remover != UNDEF_INT)
throw Machine.make_error(new Compound("permission_error",
new Object[]{"modify", "static_procedure",
Machine.make_indicator(clause.functor, clause.head.length)}));
if (clause.creator != UNDEF_INT)
return;
Provable peek = resolve_touch(clause.functor, clause.head.length, flags);
add_peek(peek.func, 0, clause, flags, peek.flags);
clause.creator = stage;
if ((flags & MASK_TOUCH_DYNAMIC) == 0)
clause.shard = engine.partition;
}
private static void add_peek(Object func, int offset, Clause clause, int flags, int flags2) {
if (is_stick(func)) {
Stick peek = (Stick) func;
add_rope(peek.rope, clause, flags);
for (int i = 0; i < peek.maps.length; i++)
if (peek.maps[i] != null)
add_map(peek, i, offset, clause, flags, flags2);
} else {
add_rope((Logical)func, clause, flags);
}
}
private static void add_map(Stick peek, int i, int offset, Clause clause, int flags, int flags2) {
Object key = index_value(clause.head[i+offset], clause.body, flags2);
Map temp = peek.maps[i];
if (key == UNDEF_OBJ) {
Iterator it = temp.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
add_peek(entry.getValue(), i+offset+1, clause, flags, flags2);
}
add_peek(peek.guards[i], i+offset+1, clause, flags, flags2);
} else {
Object val = temp.get(key);
if (val == null) {
val = clone_peek(peek.guards[i]);
temp.put(key, val);
}
add_peek(val, i+offset+1, clause, flags, flags2);
}
if (temp instanceof Handler.ArrayMap &&
temp.size() >= BOUQUET_HIGH)
peek.maps[i] = new HashMap(temp);
}
private static void add_rope(Logical rope, Clause clause, int flags) {
if (rope.data instanceof List) {
List data = (List) rope.data;
if ((flags & MASK_TOUCH_BOTTOM) != 0) {
data.add(clause);
} else {
data.add(0, clause);
}
if (data.size() >= ROPE_HIGH)
rope.data = new LinkedHashSet(data);
rope.count++;
rope.cache = null;
} else {
Set data = (Set) rope.data;
if ((flags & MASK_TOUCH_BOTTOM) != 0) {
data.add(clause);
} else {
((SequencedSet) data).addFirst(clause);
}
rope.count++;
rope.cache = null;
}
}
private static Logical clone_peek(Object func) {
Logical rope;
if (is_stick(func)) {
rope = ((Stick)func).rope;
} else {
rope = (Logical)func;
}
if (rope.data instanceof List) {
List data = (List) rope.data;
return new Logical(rope.cache, rope.count,
(SequencedCollection) ((Handler.Rope) data).clone());
} else {
Set data = (Set) rope.data;
return new Logical(rope.cache, rope.count,
(SequencedCollection) ((LinkedHashSet) data).clone());
}
}
/******************************************************************/
/* Clause Removal */
/******************************************************************/
/**
* Remove a clause from the knowledge base.
*
* @param clause The clause.
* @param flags The flags.
* @return boolean True if the clause was removed, false otherwise.
*/
public static boolean remove_clause(Clause clause, int flags) {
if (clause.remover != UNDEF_INT)
return false;
if (clause.creator == UNDEF_INT)
return false;
Provable peek = resolve_link(clause.functor, clause.head.length);
if (peek == null)
return false;
if (!is_logical(peek.func) && !is_stick(peek.func))
throw Machine.make_error(new Compound("permission_error",
new Object[]{"modify", "static_procedure",
Machine.make_indicator(clause.functor, clause.head.length)}));
remove_peek(peek.func, 0, clause, flags, peek.flags);
if (clause.creator != stage) {
clause.remover = stage;
} else {
clause.creator = UNDEF_INT;
}
return true;
}
private static void remove_peek(Object func, int offset, Clause clause, int flags, int flags2) {
if (is_stick(func)) {
Stick peek = (Stick) func;
remove_rope(peek.rope, clause, flags);
for (int i = 0; i < peek.maps.length; i++) {
Map temp = peek.maps[i];
if (temp == null)
continue;
Object key = index_value(clause.head[i+offset], clause.body, flags2);
if (key == UNDEF_OBJ) {
Iterator it = temp.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Object val = entry.getValue();
remove_peek(val, i+offset+1, clause, flags, flags2);
if (size_peek(val) == 0)
it.remove();
}
remove_peek(peek.guards[i], i+offset+1, clause, flags, flags2);
} else {
Object val = temp.get(key);
remove_peek(val, i+offset+1, clause, flags, flags2);
if (size_peek(val) == 0)
temp.remove(key);
}
if (temp instanceof HashMap &&
temp.size() < BOUQUET_LOW)
peek.maps[i] = new Handler.ArrayMap(temp);
}
} else {
remove_rope((Logical) func, clause, flags);
}
}
private static void remove_rope(Logical rope, Clause clause, int flags) {
if (rope.data instanceof List) {
List data = (List) rope.data;
int index;
if ((flags & MASK_REMOVE_REVERSE) == 0) {
index = data.indexOf(clause);
} else {
index = data.lastIndexOf(clause);
}
if (clause.creator == stage) {
if (index == -1)
throw new Error("rope corrupted");
data.remove(index);
} else {
if (index == -1)
throw new Error("rope corrupted");
}
rope.count--;
rope.cache = null;
} else {
Set data = (Set) rope.data;
if (clause.creator == stage) {
if (!data.remove(clause))
throw new Error("rope corrupted");
} else {
if (!data.contains(clause))
throw new Error("rope corrupted");
}
if (data.size() < ROPE_LOW)
rope.data = new Handler.Rope(data);
rope.count--;
rope.cache = null;
}
}
}