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 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 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) { 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; 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 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 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; 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 void PutStructure() { AbstractMachineState state = SetupMachine(); PutStructureInstruction i = new PutStructureInstruction(); Assert.AreEqual("put_structure", i.Name()); Assert.AreEqual(2, i.NumberOfArguments()); object[] args = { "s/2", "X0" }; i.Process(args); i.Execute(state); AbstractTerm H = (AbstractTerm)state["H"]; Assert.IsTrue(H.IsStructure); Assert.AreEqual(2, H.Arity); Assert.AreEqual("s", H.Name); AbstractTerm X0 = (AbstractTerm)state["X0"]; Assert.AreSame(H.Dereference(), X0.Dereference()); Assert.IsTrue(X0.IsStructure); Assert.AreEqual(2, X0.Arity); Assert.AreEqual("s", X0.Name); }
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 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 Unify_after_assignment() { AbstractTerm term = new AbstractTerm(); ConstantTerm con = new ConstantTerm("test"); term.Assign(con); Assert.AreEqual(term.Unify(con), con.Unify(term)); }
public void Reference() { AbstractTerm term1 = new AbstractTerm(); AbstractTerm term2 = new AbstractTerm(); term1.Bind(term2); Assert.AreSame(term2, term1.Reference()); }
public void Unify_str_ref() { AbstractTerm term = new AbstractTerm(); StructureTerm s = new StructureTerm("s", 2); Assert.IsTrue(s.Unify(term)); Assert.AreEqual(term.Arity, s.Arity); Assert.AreEqual(term.Name, s.Name); }
public void Unify_ref_ref() { AbstractTerm term = new AbstractTerm(); AbstractTerm another = new AbstractTerm(); bool result = term.Unify(another); Assert.AreSame(term.Dereference(), another); Assert.IsTrue(result); }
static void Main(string[] args) { var peg = new PrologPeg(); var result = new AbstractTerm(); peg.solve(result); System.Console.WriteLine(result); System.Console.ReadKey(); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AbstractTerm Ai = (AbstractTerm)state[_ai]; Ai.Assign(new ConstantTerm(_c)); program.Next(); }
public void Unify_con_ref() { AbstractTerm term = new AbstractTerm(); ConstantTerm con = new ConstantTerm("ali"); Assert.IsTrue(con.Unify(term)); Assert.AreSame(term.Data(), con.Data()); }
public void Push_AbstractTerm() { AMHeap heap = new AMHeap(); AbstractTerm term = new AbstractTerm(); heap.Push(term); Assert.AreSame(heap.Top(), term); }
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 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 void Trail() { AMTrail trail = AMTrail.Instance; AbstractTerm term = new AbstractTerm(); trail.Initialize(); trail.Trail(term); Assert.AreEqual(1, trail.TR); }
private bool IsEnvironmentVariable(AbstractTerm Vn, AbstractMachineState state) { for (AbstractTerm a = state.E.PermanentVariables; a != null; a = (AbstractTerm)a.Next) { if (a == Vn) { return true; } } return false; }
public void Dereference() { AbstractTerm term1 = new AbstractTerm(); AbstractTerm term2 = new AbstractTerm(); AbstractTerm term3 = new AbstractTerm(); term2.Bind(term3); term1.Bind(term2); Assert.AreSame(term3, term1.Dereference()); }
public void Unbind() { AbstractTerm term = new AbstractTerm(); ConstantTerm con = new ConstantTerm("ali"); term.Assign(con); term.Unbind(); Assert.AreNotSame(term.Reference(), con.Reference()); }
public void Unify_ref_lis() { AbstractTerm term = new AbstractTerm(); ListTerm con = new ListTerm(); Assert.IsTrue(term.Unify(con)); Assert.AreSame(term.Reference(), con.Reference()); Assert.IsTrue(term.IsList); Assert.IsFalse(term.IsReference); }
public void Unify_ref_str() { AbstractTerm term = new AbstractTerm(); StructureTerm con = new StructureTerm(); Assert.IsTrue(term.Unify(con)); Assert.AreSame(term.Reference(), con.Reference()); Assert.IsTrue(term.IsStructure); Assert.IsFalse(term.IsReference); }
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 IsEnvironmentVariable(AbstractTerm Vn, AbstractMachineState state) { // required, otherwise it will crash if (state.E == null) return false; for (AbstractTerm a = state.E.PermanentVariables; a != null; a = (AbstractTerm)a.Next) { if (a == Vn) { return true; } } return false; }
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 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(); }