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 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 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;
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)
{
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 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 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 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 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 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)
{
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 override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMTrail trail = (AMTrail)state.Trail;
AMHeap heap = (AMHeap)state.DataArea;
ProgramClause nextClause = program[_label];
Choicepoint B = new Choicepoint(program.NumberOfArguments, state.E, program.CP, state.B, nextClause, trail.TR, heap.H);
B.SaveRegisters(state, program.NumberOfArguments);
state.B = B;
program.Next();
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AMHeap heap = (AMHeap)state.DataArea;
EnvironmentFrame env = new EnvironmentFrame(state.E, program.CP, state.B0, 2);
// Is this really needed?
heap.Push(env);
state.E = (EnvironmentFrame)heap.Top();
program.Next();
}
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();
constantData = constantData.Trim(new char[] { '\'' });
if (constantData.Length == 1)
{
program.Next();
}
else
{
state.Backtrack();
return;
}
}
else if (X0.IsReference)
{
if (X0.Reference() == X0)
{
program.Next();
}
else
{
state.Backtrack();
return;
}
}
else
{
state.Backtrack();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
if (X0.IsConstant || X0.IsStructure || X0.IsList)
{
program.Next();
}
else
{
state.Backtrack();
}
}
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 override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
if (X0.IsReference && X0.Reference() == X0)
{
program.Next();
}
else
{
state.Backtrack();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
AbstractTerm X1 = ((AbstractTerm)state["X1"]).Dereference();
if (TermEvaluator.Evaluate(X0) == TermEvaluator.Evaluate(X1))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference();
AbstractTerm X1 = ((AbstractTerm)state["X1"]).Dereference();
if (X0.Unify(new ConstantTerm(TermEvaluator.Evaluate(X1).ToString())))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm Vn = (AbstractTerm)state[_vn];
// Fix for Ticket #12, #4, had to dereference
AbstractTerm Ai = ((AbstractTerm)state[_ai]).Dereference();
if (!Vn.Unify(Ai))
{
state.Backtrack();
}
else
{
program.Next();
}
}
public void Next()
{
ArrayList p = new ArrayList();
p.Add(new NopInstruction());
HaltInstruction hi = new HaltInstruction();
p.Add(hi);
AMProgram program = new AMProgram();
program.Initialize(p);
program.Next();
Assert.AreSame(program.P.Instruction, hi);
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = (AbstractTerm)state["X0"];
AbstractTerm X1 = (AbstractTerm)state["X1"];
if (X0.Unify(X1))
{
program.Next();
}
else
{
state.Backtrack();
}
}
