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 override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
if (X0.IsConstant)
{
string constantData = (string)X0.Data();
int v;
if (Int32.TryParse(constantData, out v))
{
program.Next();
}
else
{
state.Backtrack();
return;
}
}
else
{
state.Backtrack();
}
}
public void RetryMeElse()
{
AbstractMachineState state = SetupMachine();
RetryMeElseInstruction i = new RetryMeElseInstruction();
AMProgram program = (AMProgram)state.Program;
AMTrail trail = (AMTrail)state.Trail;
Choicepoint b = new Choicepoint();
b.CE = new EnvironmentFrame();
b.B = new Choicepoint();
b.CP = new ProgramNode();
b.TR = 1;
b.NextClause = new ProgramClause();
state.B = b;
program.AddLabel("foobar/2", new ProgramClause());
object[] args = { "foobar/2" };
i.Process(args);
i.Execute(state);
Assert.AreEqual("retry_me_else", i.Name());
Assert.AreEqual(1, i.NumberOfArguments());
Assert.AreSame(state.E, b.CE);
Assert.AreEqual(b.TR, trail.TR);
Assert.AreEqual(state.B.NextClause, program["foobar/2"]);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
ExecuteForeignPredicate(state);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
int op1;
int op2;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
AbstractTerm X1 = ((AbstractTerm)state["X1"]).Dereference();
if (!Int32.TryParse((string)X0.Data(), out op1) || !Int32.TryParse((string)X1.Data(), out op2))
{
throw new Exception("==/2: Cannot compare two non-numeric terms.");
}
op1 = Int32.Parse((string)X0.Data());
op2 = Int32.Parse((string)X1.Data());
if (op1 != op2)
{
program.Next();
}
else
{
state.Backtrack();
}
}
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;
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 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 prog = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
AbstractTerm X1 = ((AbstractTerm)state["X1"]).Dereference();
if (!X0.IsConstant)
{
Console.WriteLine("Invalid class type of object/2");
state.Backtrack();
}
if (X1.IsConstant)
{
Console.WriteLine("object/2: object instantiation error.");
state.Backtrack();
}
if (CreateObject(X0.Data() as string, X1, state))
{
prog.Next();
}
else
{
state.Backtrack();
}
}
public void AddLabel_2()
{
ArrayList p = new ArrayList();
HaltInstruction hi = new HaltInstruction();
p.Add(hi);
AMProgram program = new AMProgram();
program.Initialize(p);
program.AddLabel("male/1", new ProgramClause("male", 1));
program.AddLabel("male/1", new ProgramClause("male", 1));
ProgramClause male1 = program["male/1"];
ProgramClause male2 = male1.NextPredicate;
Assert.AreEqual(male1.Name, "male");
Assert.AreEqual(male1.Arity, 1);
Assert.AreEqual(male1.Instruction.Name(), "try_me_else");
Assert.AreEqual(male2.Name, "male%1/1");
Assert.AreEqual(male2.Arity, 1);
Assert.AreEqual(male2.Instruction.Name(), "trust_me");
}
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 AssertFirst_2()
{
ArrayList p = new ArrayList();
HaltInstruction hi = new HaltInstruction();
p.Add(hi);
AMProgram program = new AMProgram();
program.Initialize(p);
program.AssertFirst("male", 1, p);
ProgramClause oldFirst = program["male/1"];
program.AssertFirst("male", 1, p);
ProgramClause newFirst = program["male/1"];
Assert.AreEqual(newFirst.Name, "male");
Assert.AreEqual(newFirst.Arity, 1);
Assert.AreEqual(newFirst.Instruction.Name(), "try_me_else");
Assert.AreEqual(oldFirst.Name, "male%1/1");
Assert.AreEqual(oldFirst.Arity, 1);
Assert.AreEqual(oldFirst.Instruction.Name(), "trust_me");
}
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 override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
if (X0.IsReference || X0.IsList || X0.IsStructure)
{
state.Backtrack();
return;
}
else if (X0.IsConstant)
{
string constantData = (string)X0.Data();
double v;
int u;
if (Int32.TryParse(constantData, out u) || double.TryParse(constantData, out v))
{
state.Backtrack();
return;
}
}
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm Ai = ((AbstractTerm)state[_ai]).Dereference();
if (Ai.IsReference)
{
heap.Push(new ListTerm());
Ai.Bind((AbstractTerm)heap.Top());
state.IsWriteMode = true;
}
else if (Ai.IsList)
{
state.S = Ai.Next;
state.IsReadMode = true;
}
else
{
state.Fail = true;
}
if (state.Fail)
{
state.Backtrack();
}
else
{
program.Next();
}
}
public void TrustMe()
{
AbstractMachineState state = SetupMachine();
TrustMeInstruction i = new TrustMeInstruction();
i.Process(null);
AMProgram program = (AMProgram)state.Program;
AMTrail trail = (AMTrail)state.Trail;
Choicepoint b = new Choicepoint();
b.CE = new EnvironmentFrame();
Choicepoint old = new Choicepoint();
b.B = old;
b.CP = new ProgramNode();
b.TR = 1;
b.NextClause = new ProgramClause();
state.B = b;
i.Execute(state);
Assert.AreEqual("trust_me", i.Name());
Assert.AreEqual(0, i.NumberOfArguments());
Assert.AreSame(state.E, b.CE);
Assert.AreSame(program.CP, b.CP);
Assert.AreEqual(b.TR, trail.TR);
Assert.AreSame(state.B, old);
}
public void Execute()
{
AbstractMachineState state = new AbstractMachineState(new AMFactory());
ArrayList prog = new ArrayList();
prog.Add(new PutConstantInstruction());
prog.Add(new HaltInstruction());
state.Initialize(prog);
AMProgram program = (AMProgram)state.Program;
ProgramClause clause = new ProgramClause("male", 2);
program.AddLabel("male/2", clause);
ExecuteInstruction i = new ExecuteInstruction();
object[] args = { "male", "2" };
i.Process(args);
i.Execute(state);
Assert.AreEqual("execute", i.Name());
Assert.AreEqual(2, i.NumberOfArguments());
Assert.AreSame(clause, program.P);
}
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 void TryMeElse()
{
AbstractMachineState state = SetupMachine();
AMProgram program = (AMProgram)state.Program;
AMTrail trail = (AMTrail)state.Trail;
program.AddLabel("foobar/2", new ProgramClause());
TryMeElseInstruction i = new TryMeElseInstruction();
object[] args = { "foobar/2" };
i.Process(args);
program.NumberOfArguments = 2;
i.Execute(state);
Assert.AreEqual("try_me_else", i.Name());
Assert.AreEqual(1, i.NumberOfArguments());
Assert.AreEqual(2, state.B.Arity);
Assert.IsNull(state.B.B);
Assert.AreSame(state.B.CE, state.E);
Assert.AreSame(state.B.CP, program.CP);
Assert.AreSame(state.B.NextClause, program["foobar/2"]);
Assert.AreEqual(state.B.TR, trail.TR);
}
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;
Console.WriteLine("");
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
program.CP = state.E.CP;
state.E = state.E.CE;
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
heap.Push(new ConstantTerm(_constant));
program.Next();
}
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)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AbstractTerm X0 = (AbstractTerm)state["X0"];
Console.Write(X0.ToString());
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 override void Execute(AbstractMachineState state)
{
AMHeap heap = (AMHeap)state.DataArea;
AMProgram program = (AMProgram)state.Program;
for (int i = 0; i < _n; i++)
{
heap.Push(new AbstractTerm());
}
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
AMTrail trail = (AMTrail)state.Trail;
state.B = state.E.B0;
// tidy trail here?
program.Next();
}
public void Stop()
{
ArrayList p = new ArrayList();
p.Add(new HaltInstruction());
AMProgram program = new AMProgram();
program.Initialize(p);
Assert.IsTrue(program.Stop());
}
