private bool InvokePredicate(Type type, MethodInfo methodInfo, AMForeignPredicate fp, AbstractMachineState state, Assembly loadedAssembly, ArrayList methodArguments)
{
object[] arguments = methodArguments.ToArray();
object returnedResult = null;
object baseObject = null;
baseObject = Activator.CreateInstance(type);
returnedResult = type.InvokeMember(_methodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
baseObject,
arguments);
int registerIndex = 0;
foreach (AMForeignPredicateArgument fArgument in fp.Arguments)
{
if (fArgument.PassingType == AMForeignPredicateArgument.PASS_OUT ||
fArgument.PassingType == AMForeignPredicateArgument.PASS_INOUT)
{
AbstractTerm term = ((AbstractTerm)state["X" + registerIndex.ToString()]).Dereference();
if (fArgument.Type == AMForeignPredicateArgument.T_TERM)
{
ConstantTerm argumentVariable = new ConstantTerm(arguments[registerIndex]);
term.Assign(argumentVariable);
}
else
{
if (fArgument.Type == AMForeignPredicateArgument.T_STRING)
{
if (term.IsReference)
{
term.Assign(new ConstantTerm(arguments[registerIndex]));
}
}
}
registerIndex++;
}
}
bool returnValue = false;
if (fp.ReturnType == AMForeignPredicate.R_BOOL)
{
if (returnedResult == null)
{
return(true);
}
else
{
returnValue = (bool)returnedResult;
}
}
return(returnValue);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm goal = ((AbstractTerm)state["X0"]).Dereference();
if (goal.IsReference || goal.IsList)
{
throw new Exception("call/1: cannot call list or unbound term");
}
if (goal.IsConstant)
{
program.P = program[(string)goal.Data() + "/0"];
}
else if (goal.IsStructure)
{
for (int i = 0; i < goal.Arity; i++)
{
AbstractTerm Xn = (AbstractTerm)state["X" + i.ToString()];
Xn.Assign(goal[i]);
}
program.P = program[goal.Name + "/" + goal.Arity];
}
}
public override void Execute(AbstractMachineState state)
{
AMHeap heap = (AMHeap)state.DataArea;
AMProgram program = (AMProgram)state.Program;
if (_vn[0] == 'Y')
{
if (state.E[_vn] == null)
{
throw new Exception("INTERNAL ERROR: Yn variable is null in E");
}
AbstractTerm Ai = (AbstractTerm)state[_ai];
AbstractTerm Vn = (AbstractTerm)state.E[_vn];
Ai.Assign(Vn);
program.Next();
}
else
{
heap.Push(new AbstractTerm());
AbstractTerm x = (AbstractTerm)state[_vn];
AbstractTerm a = (AbstractTerm)state[_ai];
x.Assign((AbstractTerm)heap.Top());
a.Assign((AbstractTerm)heap.Top());
program.Next();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = ((AbstractTerm)state[_vn]).Dereference();
if (state.IsReadMode)
{
state.Fail = !Vn.Unify((AbstractTerm)state.S);
}
else
{
AbstractTerm newVariable = new AbstractTerm();
newVariable.Assign(Vn);
heap.Push(newVariable);
}
state.S = state.S.Next;
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = ((AbstractTerm)state[_vn]).Dereference();
if (state.IsReadMode)
{
state.Fail = !Vn.Unify((AbstractTerm)state.S);
}
else
{
AbstractTerm newVariable = new AbstractTerm();
newVariable.Assign(Vn);
heap.Push(newVariable);
}
state.S = state.S.Next;
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public void lessthan_2()
{
AbstractMachineState state = SetupMachine();
AMProgram program = (AMProgram)state.Program;
_p = new LessThanPredicate();
Verify("<", 2);
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
Choicepoint b = new Choicepoint();
ProgramClause nextClause = new ProgramClause();
state.B = new Choicepoint(0, null, null, b, nextClause, 2, null);
X0.Assign(new ConstantTerm("5"));
X1.Assign(new ConstantTerm("1"));
// X0 < X1
_p.Execute(state);
Assert.AreSame(nextClause, program.P);
}
public void call_1()
{
AbstractMachineState state = SetupMachine();
AMProgram program = (AMProgram)state.Program;
_p = new CallPredicate();
Verify("call", 1);
AbstractTerm X0 = (AbstractTerm)state["X0"];
StructureTerm goal = new StructureTerm("male", 1);
goal.Next = new ConstantTerm("ali");
program.AddLabel("male/1", new ProgramClause("male", 1));
X0.Assign(goal);
_p.Execute(state);
Assert.AreEqual(X0.Data(), "ali");
ProgramClause p = (ProgramClause)program.P;
Assert.AreEqual(p.Name, "male");
Assert.AreEqual(p.Arity, 1);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm Ai = ((AbstractTerm)state[_ai]).Dereference();
if (Ai.IsReference)
{
Ai.Assign(new ConstantTerm(_constant));
AMTrail trail = (AMTrail)state.Trail;
trail.Trail(Ai);
}
else if (Ai.IsConstant)
{
state.Fail = ((string)Ai.Data() != _constant);
}
else
{
state.Fail = true;
}
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public void ExecuteVar()
{
AbstractMachineState state = SetupMachine();
ExecuteVariableInstruction i = new ExecuteVariableInstruction();
i.Process(new string[] { "X0" });
AMProgram program = (AMProgram)state.Program;
ProgramClause x = new ProgramClause("male", 1);
program.AddLabel("male/1", x);
AbstractTerm X0 = (AbstractTerm)state["X0"];
StructureTerm s = new StructureTerm("male", 1);
s.Next = new ConstantTerm("ali");
X0.Assign(s);
i.Execute(state);
Assert.AreSame(program.P, x);
Assert.AreEqual("executevar", i.Name());
Assert.AreEqual(1, i.NumberOfArguments());
}
public void Call()
{
ArrayList prog = new ArrayList();
prog.Add(new NopInstruction());
prog.Add(new HaltInstruction());
AbstractMachineState state = new AbstractMachineState(new AMFactory());
state.Initialize(prog);
AMProgram program = (AMProgram)state.Program;
ArrayList predicateCode = new ArrayList();
AMInstructionSet iset = new AMInstructionSet();
// say_hello(X) :- write(X).
predicateCode.Add(iset.CreateInstruction("bcall", "write/1"));
predicateCode.Add(iset.CreateInstruction("proceed"));
AbstractTerm X0 = (AbstractTerm)state["X0"];
X0.Assign(new ConstantTerm("Hello, World!"));
program.AssertFirst("say_hello", 1, predicateCode);
Assert.IsTrue(state.Call("say_hello", 1, new object[] { "Hello man" }));
}
public void Unify_after_assignment()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("test");
term.Assign(con);
Assert.AreEqual(term.Unify(con), con.Unify(term));
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm Ai = (AbstractTerm)state[_ai];
Ai.Assign(new ConstantTerm(_c));
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm Vn = (AbstractTerm)state[_vn];
AbstractTerm Ai = (AbstractTerm)state[_ai];
Vn.Assign(Ai);
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMHeap heap = (AMHeap)state.DataArea;
AMProgram program = (AMProgram)state.Program;
AbstractTerm Vn = (AbstractTerm)state[vn];
AbstractTerm Ai = (AbstractTerm)state[ai];
Ai.Assign(Vn);
program.Next();
}
public void Unbind()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("ali");
term.Assign(con);
term.Unbind();
Assert.AreNotSame(term.Reference(), con.Reference());
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Yn = state.E[_yn].Dereference();
AbstractTerm Ai = (AbstractTerm)state[_ai];
if (!IsEnvironmentVariable(Yn, state))
{
Ai.Assign(Yn);
}
else
{
heap.Push(new AbstractTerm());
Yn.Bind((AbstractTerm)heap.Top());
Ai.Assign(Yn);
}
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Ai = (AbstractTerm)state[_ai];
heap.Push(new ListTerm());
Ai.Assign((AbstractTerm)heap.Top());
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = (AbstractTerm)state[_vn];
if (state.IsReadMode)
{
Vn.Assign((AbstractTerm)state.S);
}
else
{
heap.Push(new AbstractTerm());
Vn.Assign((AbstractTerm)heap.Top());
}
if (state.S != null)
{
state.S = state.S.Next;
}
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMHeap heap = (AMHeap)state.DataArea;
AMProgram program = (AMProgram)state.Program;
heap.Push(new StructureTerm(structureName, arity));
AbstractTerm Ai = (AbstractTerm)state[ai];
Ai.Assign((AbstractTerm)heap.Top());
program.Next();
}
public void put_1()
{
AbstractMachineState state = SetupMachine();
_p = new PutPredicate();
AbstractTerm x0 = (AbstractTerm)state["X0"];
x0.Assign(new ConstantTerm("61"));
Verify("put", 1);
_p.Execute(state);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = new AbstractTerm();
AbstractTerm reg = (AbstractTerm)state[_vn];
Vn.Assign(reg.Dereference());
heap.Push(Vn);
program.Next();
}
private bool CreateObject(string classType, AbstractTerm netObject, AbstractMachineState state)
{
Assembly asm = GetRequiredAssembly(classType, state);
Type[] types = asm.GetTypes();
Type type = null;
type = asm.GetType(fullTypeName);
if (type == null)
{
return(false);
}
netObject.Assign(new ObjectTerm(Activator.CreateInstance(type)));
return(true);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = new AbstractTerm();
AbstractTerm reg = (AbstractTerm)state[_vn];
Vn.Assign(reg.Dereference());
heap.Push(Vn);
program.Next();
}
public void Assign()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("ali");
term.Assign(con);
Assert.AreSame(term.Dereference(), con);
Assert.AreSame(term.Dereference(), con.Dereference());
Assert.AreEqual(term.Data(), con.Data());
Assert.AreSame(term.Reference(), con.Reference());
Assert.IsFalse(term.IsList);
Assert.IsFalse(term.IsObject);
Assert.IsFalse(term.IsReference);
Assert.IsFalse(term.IsStructure);
Assert.IsTrue(term.IsConstant);
}
public void unify_2()
{
AbstractMachineState state = SetupMachine();
_p = new UnifyPredicate();
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
X1.Assign(new ConstantTerm("ali"));
Verify("=", 2);
_p.Execute(state);
Assert.AreEqual(X0.Data(), X1.Data());
Assert.AreEqual("ali", X0.Data());
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = (AbstractTerm)state[_vn];
if (state.IsReadMode)
{
state.Fail = !Vn.Unify((AbstractTerm)state.S);
}
else
{
AbstractTerm addr = Vn.Dereference();
if (IsEnvironmentVariable(addr, state))
{
// Push a new variable on the heap
AbstractTerm newVariable = new AbstractTerm();
heap.Push(newVariable);
addr.Bind((AbstractTerm)heap.Top());
}
else
{
AbstractTerm newHeapItem = new AbstractTerm();
newHeapItem.Assign(addr);
heap.Push(newHeapItem);
}
}
if (state.S != null)
{
state.S = state.S.Next;
}
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = (AbstractTerm)state[_vn];
if (state.IsReadMode)
{
state.Fail = !Vn.Unify((AbstractTerm)state.S);
}
else
{
AbstractTerm addr = Vn.Dereference();
if (IsEnvironmentVariable(addr, state))
{
// Push a new variable on the heap
AbstractTerm newVariable = new AbstractTerm();
heap.Push(newVariable);
addr.Bind((AbstractTerm)heap.Top());
}
else
{
AbstractTerm newHeapItem = new AbstractTerm();
newHeapItem.Assign(addr);
heap.Push(newHeapItem);
}
}
if (state.S != null)
{
state.S = state.S.Next;
}
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
AbstractTerm term1 = new AbstractTerm();
AbstractTerm term2 = new AbstractTerm();
term1.Assign(X0);
term2.Assign(X1);
if (!term1.Unify(term2))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public void GetValue()
{
AbstractMachineState state = SetupMachine();
GetValueInstruction i = new GetValueInstruction();
object[] args = { "X1", "X0" };
i.Process(args);
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
X0.Assign(new ConstantTerm("ali"));
i.Execute(state);
Assert.AreEqual("get_value", i.Name());
Assert.AreEqual(2, i.NumberOfArguments());
Assert.AreEqual(X1.Data(), "ali");
}
public void assertz_1()
{
AMPredicateSet set = AMPredicateSet.Instance;
AbstractMachineState state = SetupMachine();
IAbstractMachinePredicate pred = set.CreatePredicate("assertz/1");
AbstractTerm X0 = (AbstractTerm)state["X0"];
X0.Assign(new ConstantTerm("it_is_sunny"));
Assert.AreEqual("assertz", pred.Name());
Assert.AreEqual(1, pred.Arity());
pred.Execute(state);
AMProgram program = (AMProgram)state.Program;
Assert.IsNotNull(program["it_is_sunny/0"]);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
AbstractTerm term1 = new AbstractTerm();
AbstractTerm term2 = new AbstractTerm();
term1.Assign(X0);
term2.Assign(X1);
if (!term1.Unify(term2))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public void var_1_bound()
{
AbstractMachineState state = SetupMachine();
AMProgram program = (AMProgram)state.Program;
_p = new VarPredicate();
AbstractTerm X0 = (AbstractTerm)state["X0"];
X0.Assign(new ConstantTerm("ali"));
Choicepoint b = new Choicepoint();
ProgramClause nextClause = new ProgramClause();
state.B = new Choicepoint(0, null, null, b, nextClause, 2, null);
Verify("var", 1);
_p.Execute(state);
Assert.AreSame(nextClause, program.P);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AMTrail trail = (AMTrail)state.Trail;
if (state.IsReadMode)
{
AbstractTerm addr = ((AbstractTerm)state.S).Dereference();
state.S = state.S.Next;
if (addr.IsReference)
{
addr.Assign(new ConstantTerm(_constant));
trail.Trail(addr);
}
else if (addr.IsConstant)
{
state.Fail = !_constant.Equals(addr.Data());
}
else
{
state.Fail = true;
}
}
else
{
heap.Push(new ConstantTerm(_constant));
}
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Vn = ((AbstractTerm)state[_vn]).Dereference();
if (IsEnvironmentVariable(Vn,state))
{
// Push a new variable on the heap
AbstractTerm newVariable = new AbstractTerm();
heap.Push(newVariable);
Vn.Bind((AbstractTerm)heap.Top());
}
else
{
AbstractTerm newHeapItem = new AbstractTerm();
newHeapItem.Assign(Vn);
heap.Push(newHeapItem);
}
program.Next();
}
public void atom_1_struct()
{
AbstractMachineState state = SetupMachine();
AMProgram program = (AMProgram)state.Program;
_p = new AtomPredicate();
AbstractTerm X0 = (AbstractTerm)state["X0"];
X0.Assign(new StructureTerm("f", 1));
Choicepoint b = new Choicepoint();
ProgramClause nextClause = new ProgramClause();
state.B = new Choicepoint(0, null, null, b, nextClause, 2, null);
Verify("atom", 1);
_p.Execute(state);
Assert.AreSame(nextClause, program.P);
}
