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());
}