public override bool Unify(AbstractTerm term)
{
if (term.IsReference)
{
term.Assign(this);
return(true);
}
if (term.IsList)
{
return(Head.Unify(term.Head) && Tail.Unify(term.Tail));
}
return(false);
}
public virtual bool Unify(AbstractTerm term)
{
if (IsAssigned())
{
return(_containee.Unify(term));
}
// perform unification here
if (this == term)
{
return(true);
}
if (!term.IsReference)
{
this.Assign(term);
return(true);
}
else
{
this.Bind(term);
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 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 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);
}
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_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);
}
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 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;
}
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;
}
