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 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 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 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 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; 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; AbstractTerm X0 = (AbstractTerm)state[_vn]; string predicateName = null; int predicateArity = 0; if (X0.IsList) { throw new Exception("callvar: cannot call a list."); } else if (X0.IsReference) { throw new Exception("callvar: cannot call an unbound variable."); } else if (X0.IsConstant) { int val; if (Int32.TryParse((string)X0.Data(), out val)) { throw new Exception("callvar: cannot call an int."); } predicateName = (string)X0.Data(); } else if (X0.IsStructure) { // TODO: should we maybe handle built-in predicates? predicateName = X0.Name; predicateArity = X0.Arity; } if (program.IsDefined(predicateName + "/" + predicateArity)) { program.CP = program.P.Next; program.NumberOfArguments = predicateArity; program.P = program[predicateName + "/" + predicateArity]; // TODO: B0 should be set to B } else { state.Backtrack(); } }
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 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 Unify_ref_con() { AbstractTerm term = new AbstractTerm(); ConstantTerm con = new ConstantTerm(); Assert.IsTrue(term.Unify(con)); Assert.AreEqual(term.Data(), con.Data()); Assert.AreSame(term.Reference(), con.Reference()); Assert.IsTrue(term.IsConstant); Assert.IsFalse(term.IsReference); }
// Get types and set types private void GetTypes(MethodInfo mi, AbstractTerm methodStructObj, ref ArrayList paramArray, AbstractTerm obj) { AMHeap da = (AMHeap)runtime.DataArea; AbstractTerm methodObj = (AbstractTerm)methodStructObj.Next; ParameterInfo[] parms = mi.GetParameters(); for (int i = 0; i < parms.Length; i++) { ParameterInfo par = (ParameterInfo)parms[i]; AbstractTerm var = (AbstractTerm)methodObj; if (i != parms.Length - 1) { methodObj = (AbstractTerm)methodObj.Next; } switch (par.ParameterType.ToString()) { case "System.Int32": paramArray.Add(Int32.Parse(var.Data() as string)); break; case "System.Char": paramArray.Add(((string)var.Data())[0]); break; case "System.String": paramArray.Add(var.Data() as string); break; case "System.Boolean": paramArray.Add(Boolean.Parse(var.Data() as string)); break; default: // pass Variable.Object paramArray.Add(var); break; } } }
private bool InvokeForeignPredicate(Type type, MethodInfo methodInfo, AMForeignPredicate fp, Assembly loadedAssembly, AbstractMachineState state) { int registerIndex = 0; ArrayList methodArguments = new ArrayList(); foreach (AMForeignPredicateArgument arg in fp.Arguments) { AbstractTerm term = ((AbstractTerm)state["X" + registerIndex.ToString()]).Dereference(); switch (arg.Type) { case AMForeignPredicateArgument.T_BOOL: bool bResult = false; if (!Boolean.TryParse(term.Data().ToString(), out bResult)) { return(false); } methodArguments.Add(System.Boolean.Parse(term.Data().ToString())); break; case AMForeignPredicateArgument.T_CHAR: if (term.Data() == null) { return(false); } methodArguments.Add(Convert.ToChar(term.Data())); break; case AMForeignPredicateArgument.T_DOUBLE: case AMForeignPredicateArgument.T_FLOAT: case AMForeignPredicateArgument.T_INTEGER: int iResult = 0; if (!Int32.TryParse(term.Data().ToString(), out iResult)) { return(false); } methodArguments.Add(Int32.Parse(term.Data().ToString())); break; case AMForeignPredicateArgument.T_STRING: methodArguments.Add(term.Data().ToString()); break; case AMForeignPredicateArgument.T_TERM: methodArguments.Add(term); break; } registerIndex++; } return(InvokePredicate(type, methodInfo, fp, state, loadedAssembly, methodArguments)); }
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 SetConstant() { AbstractMachineState state = SetupMachine(); SetConstantInstruction i = new SetConstantInstruction(); object[] args = { "ali" }; i.Process(args); i.Execute(state); AbstractTerm H = (AbstractTerm)((AMHeap)state.DataArea).Top(); Assert.AreEqual("set_constant", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); Assert.AreEqual("ali", H.Data()); }
public void UnifyValue() { AbstractMachineState state = SetupMachine(); UnifyValueInstruction i = new UnifyValueInstruction(); object[] args = { "X0" }; state.S = new ConstantTerm("ali"); i.Process(args); i.Execute(state); AbstractTerm X0 = (AbstractTerm)state["X0"]; Assert.AreEqual("unify_value", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); Assert.AreEqual("ali", X0.Data()); }
public void GetConstant() { AbstractMachineState state = SetupMachine(); GetConstantInstruction i = new GetConstantInstruction(); object[] args = { "ali", "X0" }; i.Process(args); i.Execute(state); Assert.AreEqual("get_constant", i.Name()); Assert.AreEqual(2, i.NumberOfArguments()); AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference(); Assert.IsTrue(X0.IsConstant); Assert.AreEqual("ali", X0.Data()); }
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 override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference(); if (X0.IsReference) { throw new Exception("wait/1: argument cannot be an unbound variable."); } else if (X0.IsConstant) { int msec; if (!Int32.TryParse((string)X0.Data(), out msec)) { throw new Exception("wait/1: invalid wait time."); } System.Threading.Thread.Sleep(msec); } program.Next(); }
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; 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 static double Evaluate(AbstractTerm t) { double result = 0; AbstractTerm term = t.Dereference(); if (term.IsConstant) { int r; double d; if (Int32.TryParse((string)term.Data(), out r)) { return(r); } else if (Double.TryParse((string)term.Data(), out d)) { return(d); } else { switch ((string)term.Data()) { case "pi": result = Math.PI; break; case "e": result = Math.E; break; case "cputime": Process p = Process.GetCurrentProcess(); result = (p.TotalProcessorTime.TotalMilliseconds / 1000); break; default: throw new Exception("TermEvaluator: cannot evaluate string " + term.Data()); } } } else if (term.IsReference) { throw new Exception("TermEvaluator: cannot evaluate a reference term."); } else if (term.IsStructure) { AbstractTerm op1 = (AbstractTerm)term.Next; AbstractTerm op2 = (AbstractTerm)term.Next.Next; switch (term.Name) { case "+": result = Evaluate(op1) + Evaluate(op2); break; case "-": result = Evaluate(op1) - Evaluate(op2); break; case "*": result = Evaluate(op1) * Evaluate(op2); break; case "/": if (Evaluate(op2) == 0) { throw new Exception("TermEvaluator: Division by zero error."); } result = Evaluate(op1) / Evaluate(op2); break; case "^": result = Math.Pow(Evaluate(op1), Evaluate(op2)); break; case "cos": result = Math.Cos(Evaluate(op1)); break; case "sin": result = Math.Sin(Evaluate(op1)); break; case "tan": result = Math.Tan(Evaluate(op1)); break; case "log": result = Math.Log(Evaluate(op1)); break; } } return(result); }
private bool InvokeMethod(AbstractTerm obj, AbstractTerm method, AbstractTerm returnObject, AbstractMachineState state) { if (obj.IsConstant) { // invoke a static method Assembly asm = GetRequiredAssembly(obj.Data() as string, state); Type type = asm.GetType(obj.Data() as string); if (type == null) { return(false); } ArrayList paramArray = new ArrayList(); GetTypes(type.GetMethod(method.Data() as string), method, ref paramArray, obj); object[] arguments = paramArray.ToArray(); object res = type.InvokeMember(method.Data() as string, BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, arguments); switch (res.GetType().ToString()) { case "System.Char": case "System.String": case "System.Int32": case "System.Boolean": returnObject.Assign(new ConstantTerm(res.ToString())); break; default: returnObject.Assign(new ObjectTerm(res)); break; } SetTypes(method, arguments); } else { // invoke an instance method ArrayList paramArray = new ArrayList(); GetTypes(obj.Data().GetType().GetMethod(method.Data() as string), method, ref paramArray, obj); object classObject = obj.Data(); MethodInfo omi = classObject.GetType().GetMethod(method.Data() as string); object[] arguments = paramArray.ToArray(); object res = obj.Data().GetType().InvokeMember(method.Data() as string, BindingFlags.Default | BindingFlags.ExactBinding | BindingFlags.InvokeMethod, null, obj.Data(), arguments); if (res != null) { switch (res.GetType().ToString()) { case "System.String": ConstantTerm rC = new ConstantTerm(res.ToString()); if (!returnObject.Unify(rC)) { return(false); } break; case "System.Char": case "System.Int32": case "System.Boolean": ConstantTerm returnConstant = new ConstantTerm(res.ToString()); if (!returnObject.Unify(returnConstant)) { return(false); } break; default: returnObject.Assign(new ObjectTerm(res)); break; } } SetTypes(method, arguments); } return(true); }
public bool Setproperty(AbstractTerm obj, AbstractTerm method, AbstractTerm objValue) { if (obj.IsConstant) { // invoke a static method Assembly asm = GetRequiredAssembly(obj.Data() as string, runtime); Type type = asm.GetType(obj.Data() as string); if (type == null) { return(false); } ArrayList paramArray = new ArrayList(); ParameterInfo par = type.GetMethod(method.Data() as string).GetParameters()[0]; switch (par.GetType().ToString()) { case "System.Int32": paramArray.Add(Int32.Parse(objValue.Data() as string)); break; case "System.Char": paramArray.Add(objValue.Data().ToString()[0]); break; case "System.String": paramArray.Add(objValue.Data() as string); break; case "System.Boolean": paramArray.Add(Boolean.Parse(objValue.Data() as string)); break; default: // pass Variable.Object paramArray.Add(objValue); break; } object res = type.InvokeMember(method.Data() as string, BindingFlags.Static | BindingFlags.Public | BindingFlags.SetProperty, null, obj, paramArray.ToArray()); switch (res.GetType().ToString()) { case "System.Char": case "System.String": case "System.Int32": case "System.Boolean": objValue.Unify(new ConstantTerm(res.ToString())); break; default: objValue.Unify(new ObjectTerm(res)); break; } } else { ArrayList paramArray = new ArrayList(); Type t = obj.Data().GetType(); PropertyInfo pInfo = t.GetProperty(method.Data() as string); if (pInfo == null) { return(false); } if (pInfo.CanWrite == false) { return(false); } switch (pInfo.PropertyType.ToString()) { case "System.Int32": paramArray.Add(Int32.Parse(objValue.Data() as string)); break; case "System.Char": paramArray.Add(objValue.Data().ToString()[0]); break; case "System.String": paramArray.Add(objValue.Data() as string); break; case "System.Boolean": paramArray.Add(Boolean.Parse(objValue.Data() as string)); break; default: // pass Variable.Object paramArray.Add(objValue); break; } object res = obj.Data().GetType().InvokeMember(method.Data() as string, BindingFlags.Default | BindingFlags.ExactBinding | BindingFlags.SetProperty, null, obj.Data(), paramArray.ToArray()); } return(true); }
public bool Getproperty(AbstractTerm obj, AbstractTerm method, AbstractTerm returnObject) { if (obj.IsConstant) { // invoke a static get property Assembly asm = GetRequiredAssembly(obj.Data() as string, runtime);; Type type = asm.GetType(obj.Data() as string); if (type == null) { return(false); } if (type.GetProperty(method.Data() as string) == null) { return(false); } object res = type.InvokeMember(method.Data() as string, BindingFlags.GetProperty | BindingFlags.Static | BindingFlags.Public, null, null, null); switch (res.GetType().ToString()) { case "System.String": AbstractTerm rC = new ConstantTerm(res.ToString()); if (!returnObject.Unify(rC)) { return(false); } break; case "System.Char": case "System.Int32": case "System.Boolean": AbstractTerm returnConstant = new ConstantTerm(res.ToString()); if (!returnObject.Unify(returnConstant)) { return(false); } break; default: returnObject.Unify(new ObjectTerm(res)); break; } } else { if (obj.Data().GetType().GetProperty(method.Data() as string) == null) { return(false); } // invoke an instance get property object res = obj.Data().GetType().InvokeMember(method.Data() as string, BindingFlags.Default | BindingFlags.ExactBinding | BindingFlags.GetProperty, null, obj.Data(), null); switch (res.GetType().ToString()) { case "System.Char": case "System.String": case "System.Int32": case "System.Boolean": returnObject.Unify(new ConstantTerm(res.ToString())); break; default: returnObject.Unify(new ObjectTerm(res)); break; } } return(true); }
public void Data() { AbstractTerm t = new AbstractTerm(); Assert.IsNull(t.Data()); }