public static bool cliToStrRaw(PlTerm obj, PlTerm str)
{
try
{
if (!str.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliToStrRaw(obj, plvar) && SpecialUnify(str, plvar));
}
if (obj.IsString)
{
return(str.Unify(obj));
}
if (obj.IsVar)
{
return(str.Unify((string)obj));
}
object o = GetInstance(obj);
if (o == null)
{
return(str.FromObject("" + obj));
}
return(str.FromObject(ToString(o)));
}
catch (Exception e)
{
Warn("cliToString: {0}", e);
object o = GetInstance(obj);
if (o == null)
{
return(str.FromObject("" + obj));
}
return(str.FromObject(ToString(o)));
}
}
public void Intern(string varname, object value)
{
PlTerm termin = PlTerm.PlVar();
termin.FromObject(value);
ModuleCall("Intern", PlNamed(varname), termin);
}
static public bool cliGetClass(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliGetClass(valueIn, plvar) && SpecialUnify(valueOut, plvar));
}
object val = GetInstance(valueIn);
// extension method
#if USE_IKVM
return(valueOut.FromObject((val.getClass())));
#else
return(valueOut.FromObject((val.GetType())));
#endif
}
internal static PlTerm ToPLCS(Term args)
{
if (args is Atom)
{
return(new PlTerm(args.name()));
}
if (args is jpl.Variable)
{
return(new PlTerm((uint)GetField(args, "term_")));
}
if (args is jpl.Float)
{
return(new PlTerm(args.doubleValue()));
}
if (args is jpl.Integer)
{
return(new PlTerm(args.longValue()));
}
if (args is jpl.Compound)
{
return(PlTerm.PlCompound(args.name(), ToPLCSV(args.args())));
}
if (args is jpl.JRef)
{
var jref = (jpl.JRef)args;// return new PlTerm(args.doubleValue());
var obj = jref.@ref();
var t = new PlTerm();
t.FromObject(obj);
return(t);
}
throw new ArgumentOutOfRangeException();
}
public static PlTerm ToProlog(object value)
{
PlTerm t = PlTerm.PlVar();
t.FromObject(value);
return(t);
}
static public bool cliTypeFromClass(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliTypeFromClass(valueIn, plvar) && SpecialUnify(valueOut, plvar));
}
Type val = GetType(valueIn);
if (val == null)
{
return(false);
}
#if USE_IKVM
Type c = ikvm.runtime.Util.getInstanceTypeFromClass(val);
return(valueOut.FromObject((c)));
#else
return(valueOut.FromObject(val));
#endif
}
public static bool cliTermToArray(PlTerm arrayValue, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliTermToArray(arrayValue, plvar) && SpecialUnify(valueOut, plvar));
}
if (arrayValue.Name == "array")
{
return(valueOut.FromObject(GetInstance(arrayValue)));
}
Type elementType = ResolveType(arrayValue.Name);
if (elementType == null)
{
Error("Cant find vector from {0}", arrayValue);
return(false);
}
var value = CreateArrayOfTypeRankOneFilled(arrayValue, elementType.MakeArrayType());
return(valueOut.FromObject((value)));
}
static public bool cliGetType(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliGetType(valueIn, plvar) && SpecialUnify(valueOut, plvar));
}
object val = GetInstance(valueIn);
if (val == null)
{
Error("Cannot get object for {0}", valueIn);
return(true);
}
return(valueOut.FromObject((val.GetType())));
}
static public bool cliCastImmediate(PlTerm valueIn, PlTerm clazzSpec, PlTerm valueOut)
{
if (valueIn.IsVar)
{
return(Warn("Cant find instance {0}", valueIn));
}
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliCastImmediate(valueIn, clazzSpec, plvar) && SpecialUnify(valueOut, plvar));
}
Type type = GetType(clazzSpec);
object retval = CastTerm(valueIn, type);
return(valueOut.FromObject(retval));
}
internal static PlTerm ToPLCS(Term args)
{
if (args is Atom) return new PlTerm(args.name());
if (args is jpl.Variable) return new PlTerm((uint)GetField(args, "term_"));
if (args is jpl.Float) return new PlTerm(args.doubleValue());
if (args is jpl.Integer) return new PlTerm(args.longValue());
if (args is jpl.Compound) return PlTerm.PlCompound(args.name(), ToPLCSV(args.args()));
if (args is jpl.JRef)
{
var jref = (jpl.JRef)args;// return new PlTerm(args.doubleValue());
var obj = jref.@ref();
var t = new PlTerm();
t.FromObject(obj);
return t;
}
throw new ArgumentOutOfRangeException();
}
public object Eval(object obj)
{
PlTerm termin = PlTerm.PlVar();
if (obj is PlTerm)
{
termin.Unify((PlTerm)obj);
}
else
{
termin.FromObject(obj);
}
PlTerm termout = PlTerm.PlVar();
if (!ModuleCall("Eval", termin, termout))
{
return(null);
}
return(PrologCLR.CastTerm(termout, typeof(System.Object)));
}
static public bool cliGetterm(PlTerm valueCol, PlTerm valueIn, PlTerm valueOut)
{
List <object> objs;
if (valueCol.IsVar)
{
objs = new List <object>();
valueCol.FromObject(objs);
}
else
{
objs = (List <object>)CastTerm(valueCol, typeof(ICollection));
}
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return(cliGetterm(valueCol, valueIn, plvar) && SpecialUnify(valueOut, plvar));
}
if (IsTaggedObject(valueIn))
{
object val = GetInstance(valueIn);
int index = objs.IndexOf(val);
if (index < 0)
{
index = objs.Count;
objs.Add(val);
var type = val.GetType();
if (type.IsArray)
{
return(valueIn.Unify(valueOut));
}
return(ToFieldLayout("object", typeToName(type), val, type, valueOut, false, false) != libpl.PL_fail);
}
}
return(valueIn.Unify(valueOut));
}
public static bool cliToStrRaw(PlTerm obj, PlTerm str)
{
try
{
if (!str.IsVar)
{
var plvar = PlTerm.PlVar();
return cliToStrRaw(obj, plvar) && SpecialUnify(str, plvar);
}
if (obj.IsString) return str.Unify(obj);
if (obj.IsVar) return str.Unify((string)obj);
object o = GetInstance(obj);
if (o == null) return str.FromObject("" + obj);
return str.FromObject(ToString(o));
}
catch (Exception e)
{
Warn("cliToString: {0}", e);
object o = GetInstance(obj);
if (o == null) return str.FromObject("" + obj);
return str.FromObject(ToString(o));
}
}
static public bool cliGetClass(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return cliGetClass(valueIn, plvar) && SpecialUnify(valueOut, plvar);
}
object val = GetInstance(valueIn);
// extension method
#if USE_IKVM
return valueOut.FromObject((val.getClass()));
#else
return valueOut.FromObject((val.GetType()));
#endif
}
static public bool cliTypeFromClass(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return cliTypeFromClass(valueIn, plvar) && SpecialUnify(valueOut, plvar);
}
Type val = GetType(valueIn);
if (val == null) return false;
#if USE_IKVM
Type c = ikvm.runtime.Util.getInstanceTypeFromClass(val);
return valueOut.FromObject((c));
#else
return valueOut.FromObject(val);
#endif
}
private static bool UnifySpecialObject(PlTerm plTerm, object ret1)
{
if (plTerm.IsVar)
{
return plTerm.FromObject(ret1);
}
else
{
var plvar = PlTerm.PlVar();
return plvar.FromObject(ret1) && SpecialUnify(plTerm, plvar);
}
}
static public bool cliGetType(PlTerm valueIn, PlTerm valueOut)
{
if (!valueOut.IsVar)
{
var plvar = PlTerm.PlVar();
return cliGetType(valueIn, plvar) && SpecialUnify(valueOut, plvar);
}
object val = GetInstance(valueIn);
if (val == null)
{
Error("Cannot get object for {0}", valueIn);
return true;
}
return valueOut.FromObject((val.GetType()));
}
