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 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) { 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; ExecuteForeignPredicate(state); }
public void Pop_an_empty_heap() { AMHeap heap = new AMHeap(); object top = heap.Pop(); Assert.IsNull(top); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AMHeap heap = (AMHeap)state.DataArea; heap.Push(new ConstantTerm(_constant)); program.Next(); }
public void Push_AbstractTerm() { AMHeap heap = new AMHeap(); AbstractTerm term = new AbstractTerm(); heap.Push(term); Assert.AreSame(heap.Top(), term); }
public void Push_ConstantTerm() { AMHeap heap = new AMHeap(); ConstantTerm con = new ConstantTerm("Hello, World!"); heap.Push(con); Assert.AreSame(con, heap.Top()); }
public void Push_StructureTerm() { AMHeap heap = new AMHeap(); StructureTerm con = new StructureTerm("Hello, World!", 2); heap.Push(con); Assert.AreSame(con, heap.Top()); }
public void Push_ListTerm() { AMHeap heap = new AMHeap(); ListTerm con = new ListTerm(); heap.Push(con); Assert.AreSame(con, heap.Top()); }
public void Push_ObjectTerm() { AMHeap heap = new AMHeap(); ObjectTerm con = new ObjectTerm(); heap.Push(con); Assert.AreSame(con, heap.Top()); }
public void Initialize() { AMHeap heap = new AMHeap(); AbstractMachineState state = new AbstractMachineState(new AMFactory()); heap.Initialize(state); Assert.IsNull(heap.H); Assert.IsNull(heap.Top()); }
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 Pop_one_item() { AMHeap heap = new AMHeap(); ConstantTerm con = new ConstantTerm("ali"); heap.Push(con); heap.Pop(); Assert.IsNull(heap.Top()); }
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; 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; 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; 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 void Pop_two_items() { AMHeap heap = new AMHeap(); ConstantTerm con = new ConstantTerm("ali"); ConstantTerm first = new ConstantTerm("foo"); heap.Push(first); heap.Push(con); heap.Pop(); Assert.AreSame(first, heap.Top()); }
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 SetVoid() { AbstractMachineState state = SetupMachine(); AMHeap heap = (AMHeap)state.DataArea; object[] args = { "3" }; SetVoidInstruction i = new SetVoidInstruction(); i.Process(args); i.Execute(state); Assert.AreEqual("set_void", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); Assert.IsTrue(((AbstractTerm)heap.Pop()).IsReference); Assert.IsTrue(((AbstractTerm)heap.Pop()).IsReference); Assert.IsTrue(((AbstractTerm)heap.Pop()).IsReference); }
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 Ai = ((AbstractTerm)state[_ai]).Dereference(); if (Ai.IsReference) { heap.Push(new StructureTerm(_structureName, _arity)); Ai.Bind((AbstractTerm)heap.Top()); state.IsWriteMode = true; } else if (Ai.IsStructure) { if (Ai.Name == _structureName) { // set S to next item on heap state.S = Ai.Next; // set read mode state.IsReadMode = true; } else { state.Fail = true; } } else { state.Fail = true; } if (state.Fail) { state.Backtrack(); } else { program.Next(); } }
public void SetVariable() { AbstractMachineState state = SetupMachine(); SetVariableInstruction i = new SetVariableInstruction(); object[] args = { "X0" }; i.Process(args); i.Execute(state); Assert.AreEqual("set_variable", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference(); AMHeap heap = (AMHeap)state.DataArea; Assert.AreSame(X0, heap.Top()); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AMHeap heap = (AMHeap)state.DataArea; AMTrail trail = (AMTrail)state.Trail; state.B.UnsaveRegisters(state, state.B.Arity); state.E = state.B.CE; program.CP = state.B.CP; trail.Unwind(state.B.TR); trail.TR = state.B.TR; heap.H = state.B.H; state.B = state.B.B; program.Next(); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AMHeap heap = (AMHeap)state.DataArea; if (state.IsReadMode) { for (int i = 0; i < _n; i++) { state.S = state.S.Next; } } else { for (int j = 0; j < _n; j++) { heap.Push(new AbstractTerm()); } } program.Next(); }
private void SetTypes(AbstractTerm obj, object[] arguments) { AMHeap da = (AMHeap)runtime.DataArea; AbstractTerm argObj = obj; for (int i = 0; i < arguments.Length; i++) { AbstractTerm a = (AbstractTerm)argObj.Next; argObj = (AbstractTerm)argObj.Next; if (!a.IsObject) { // Need to check if unification is the apropriate method a.Unify(new ConstantTerm(arguments[i].ToString())); } else { // Need to check if unification is the apropriate method a.Unify(new ObjectTerm(arguments[i])); } } }