IEnumerable <CutState> Prover(Structure goal)
{
if (goal == null)
{
return(CutStateSequencer.Succeed());
}
return(context.Prove(goal));
}
/// <summary>
/// Attempts to prove all woken goals, in the order they were woken.
///
/// </summary>
internal IEnumerable <CutState> ProveAllWokenGoals()
{
if (this.wokenStack == null || this.wokenStack.Count == 0)
{
return(CutStateSequencer.Succeed());
}
WokenGoal[] goals = wokenStack.ToArray();
wokenStack.Clear();
return(ProveWokenGoalsInternal(goals, 0));
}
internal static System.Collections.Generic.IEnumerable<CutState> Retract(object term, PrologContext context)
{
ELNode foundNode;
ELNodeEnumerator enumerator;
if (!TryQuery(term, context, out foundNode, out enumerator))
return CutStateSequencer.Fail();
if (foundNode != null)
{
foundNode.DeleteSelf();
return CutStateSequencer.Succeed();
}
return DeleteSuccessive(enumerator);
}
internal static IEnumerable <CutState> Retract(object term, PrologContext context)
{
ELNode foundNode;
ELNodeEnumerator enumerator;
if (!TryQuery(term, context, out foundNode, out enumerator))
{
return(CutStateSequencer.Fail());
}
if (foundNode != null)
{
foundNode.DeleteSelf();
return(CutStateSequencer.Succeed());
}
return(DeleteSuccessive(enumerator));
}
internal static IEnumerable <CutState> SetImplementation(object[] args, PrologContext context)
{
if (args.Length != 2)
{
throw new ArgumentCountException("set", args, new object[] { "Variable", "NewValue" });
}
object value = Term.CopyInstantiation(args[1]);
if (value is LogicVariable)
{
throw new UninstantiatedVariableException((LogicVariable)args[1], "Value argument should be a data object, not an uninstantiated (unbound) variable.");
}
var functor = Term.Deref(args[0]) as Symbol;
if (functor == null)
{
throw new ArgumentTypeException("set", "functor", args[0], typeof(Symbol));
}
List <KnowledgeBaseEntry> entries = context.KnowledgeBase.EntryListForStoring(new PredicateIndicator(functor, 1));
switch (entries.Count)
{
case 0:
entries.Add(new KnowledgeBaseVariable(value));
return(CutStateSequencer.Succeed());
case 1:
var v = entries[0] as KnowledgeBaseVariable;
if (v == null)
{
throw new ArgumentException("Functor is not a variable; it has another entry defined for it.");
}
v.CurrentValue = value;
return(CutStateSequencer.Succeed());
default:
throw new ArgumentException("Functor is not a variable; it has multiple entries defined for it.");
}
}
internal IEnumerable <CutState> FindClauses(Structure head, object body)
{
PredicateInfo i = CheckForPredicateInfo(head.PredicateIndicator);
return((i == null)?CutStateSequencer.Fail():i.FindClauses(head, body));
}
private IEnumerable <CutState> BinaryPrimitiveImplementation(object[] args, PrologContext context)
{
if (args.Length != 2)
{
throw new ArgumentCountException(Name, args, expectedArguments);
}
var arg1 = Term.Deref(args[0]);
var arg2 = Term.Deref(args[1]);
var arg1AsLogicVariable = arg1 as LogicVariable;
if (arg1AsLogicVariable != null)
{
var arg2AsLogicVariable = arg2 as LogicVariable;
if (arg2AsLogicVariable != null)
{
// Enumerating both arguments
if (doubleEnumerator == null)
{
throw new InstantiationException(
arg1AsLogicVariable,
"At least one argument to " + Name + "/2 must be instantiated.");
}
if (arg1AsLogicVariable == arg2AsLogicVariable)
{
throw new InvalidOperationException(Name + "(X,X) is not supported.");
}
return(EnumerateBothDriver(arg1AsLogicVariable, arg2AsLogicVariable, context));
}
if (!(arg2 is T2))
{
throw new ArgumentTypeException(this.Name, this.arg2Name, arg1, typeof(T1));
}
if (arg1Function != null)
{
// It's left-unique
T1 arg1Value;
if (arg1Function((T2)arg2, out arg1Value))
{
return(Term.UnifyAndReturnCutState(arg1, arg1Value));
}
return(PrologPrimitives.FailImplementation);
}
// It's not left-unique
if (arg1Enumerator == null)
{
throw new InstantiationException(arg1AsLogicVariable, Name + "/2: first argument must be instantiated.");
}
return(this.EnumerateArg1Driver(arg1AsLogicVariable, (T2)arg2, context));
}
var variable1 = arg2 as LogicVariable;
if (variable1 != null)
{
if (!(arg1 is T1))
{
throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1));
}
if (arg2Function != null)
{
// It's right-unique
T2 arg2Value;
if (arg2Function((T1)arg1, out arg2Value))
{
return(Term.UnifyAndReturnCutState(arg2, arg2Value));
}
return(PrologPrimitives.FailImplementation);
}
// It's not right-unqiue
if (arg2Enumerator == null)
{
throw new InstantiationException(variable1, Name + "/2: second argument must be instantiated.");
}
return(this.EnumerateArg2Driver((T1)arg1, variable1, context));
}
// Filtering
if (!(arg1 is T1))
{
throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1));
}
if (!(arg2 is T2))
{
throw new ArgumentTypeException(this.Name, this.arg1Name, arg1, typeof(T1));
}
if (filter == null)
{
throw new InstantiatedVariableException(null, Name + ": at least one argument must be uninstantiated.");
}
return(CutStateSequencer.FromBoolean(this.filter((T1)arg1, (T2)arg2)));
}
