private static int PredicateArity(PlTerm term) { if (term.Name == "{}") { if (term.Arity == 1) { return(PredicateArity(term.Arg(0))); } } if (term.Name == ":") { if (term.Arity == 2) { return(PredicateArity(term.Arg(1))); } } if (term.Name == "/") { if (term.Arity == 2) { return(term.Arg(1).intValue()); } } return(term.Arity); }
private static string PredicateName(PlTerm term) { if (term.Name == "{}") { if (term.Arity == 1) { return(PredicateName(term.Arg(0))); } } if (term.Name == ":") { if (term.Arity == 2) { return(PredicateName(term.Arg(1))); } } if (term.Name == "/") { if (term.Arity == 2) { return(PredicateName(term.Arg(0))); } } return(term.Name); }
static public bool cliAddLayout(PlTerm clazzSpec, PlTerm memberSpec) { Type type = GetType(clazzSpec); string name = memberSpec.Name; int arity = memberSpec.Arity; MemberInfo[] fieldInfos = new MemberInfo[arity]; for (int i = 0; i < arity; i++) { var arg = memberSpec.Arg(i); fieldInfos[i] = findMember(arg, type); } AddPrologTermLayout(type, name, fieldInfos, null); return(true); }
public static PlTerm[] ToTermArray(IEnumerable <PlTerm> enumerable) { if (enumerable is PlTerm[]) { return((PlTerm[])enumerable); } if (enumerable is PlTermV) { PlTermV tv = (PlTermV)enumerable; return(tv.ToArray()); } if (enumerable is PlTerm) { // I guess IsList makes a copy PlTerm tlist = (PlTerm)enumerable; if (tlist.IsVar) { return new PlTerm[] { tlist } } ; if (tlist.IsList) { enumerable = tlist.Copy(); } if (tlist.Name == "{}") { var t = tlist.Arg(0); var terms = new List <PlTerm>(); while (t.Arity == 2) { terms.Add(t.Arg(0)); t = t.Arg(1); } // last Item terms.Add(t); return(terms.ToArray()); } if (tlist.IsAtomic) { if (tlist.IsAtom && tlist.Name == "[]") { return(new PlTerm[0]); } return(new PlTerm[] { tlist }); } } return(enumerable.ToArray()); }
/* * * jpl_is_ref(@(Y)) :- * atom(Y), % presumably a (garbage-collectable) tag * Y \== void, % not a ref * Y \== false, % not a ref * Y \== true. % not a ref * */ private static object CastCompoundTerm(string name, int arity, PlTerm arg1, PlTerm orig, Type pt) { string key = name + "/" + arity; lock (FunctorToLayout) { PrologTermLayout pltl; if (FunctorToLayout.TryGetValue(key, out pltl)) { Type type = pltl.ObjectType; MemberInfo[] fis = pltl.FieldInfos; MemberInfo toType = pltl.ToType; if (toType != null) { return(GetMemberValue(toType, CastTerm(arg1, argOneType(toType)))); } return(CreateInstance(type, fis, orig, 1)); } } lock (FunctorToRecomposer) { PrologTermRecomposer layout; if (FunctorToRecomposer.TryGetValue(key, out layout)) { Type type = layout.ToType; uint newref = libpl.PL_new_term_ref(); PlTerm outto = new PlTerm(newref); var ret = PlQuery.PlCall(layout.module, layout.r2obj, new PlTermV(orig, outto)); if (ret) { object o = CastTerm(outto, type); if (!pt.IsInstanceOfType(o)) { Warn(type + " (" + o + ") is not " + pt); } return(o); } } } if (key == "[]/0") { if (pt != null) { if (pt.IsArray) { return(Array.CreateInstance(pt.GetElementType(), 0)); } return(MakeDefaultInstance(pt)); } Warn("Not sure what to convert `[]` too"); return(null); } if (key == "static/1") { return(null); } if (key == "delegate/1") { return(CastTerm0(arg1, pt)); } if (key == "delegate/2") { return(cliNewDelegateTerm(pt, orig, false)); } if (key == "{}/1") { return(arg1); } if (pt == typeof(object)) { pt = null; } //{T} //@(_Tag) if (key == "@/1" && arg1.IsAtom) { name = arg1.Name; switch (name) { case "true": { return(true); } case "false": { return(false); } case "null": { if (pt != null && pt.IsValueType) { return(MakeDefaultInstance(pt)); } return(null); } case "void": { #if USE_IKVM if (pt == typeof(void)) { return(JPL.JVOID); } #endif return(null); } default: { { object o = tag_to_object(name); if (o == null) { Warn("Null from tag " + name); } return(o); #if plvar_pins lock (ToFromConvertLock) lock (atomToPlRef) { PlRef oldValue; if (!atomToPlRef.TryGetValue(name, out oldValue)) { //Warn("no value for tag=" + name); if (pt != null && pt.IsInstanceOfType(o)) { return(o); } return(o); } var v = oldValue.Value; if (pt != null && pt.IsInstanceOfType(v)) { return(v); } return(v); } #endif } } } } #if plvar_pins if (name == "$cli_object") { lock (ToFromConvertLock) { lock (termToObjectPins) { PlRef oldValue; Int64 ohandle = (long)arg1; if (!termToObjectPins.TryGetValue(ohandle, out oldValue)) { Warn("no value for ohandle=" + ohandle); } return(oldValue.Value); } } } #endif if (key == "enum/2") { Type type = GetType(arg1); PlTerm arg2 = orig.Arg(1); object value = Enum.Parse(type, arg2.Name, true); if (value == null) { Warn("cant parse enum: {0} for type {1}", arg2, type); } return(value); } if (key == "array/2") { Type type = GetType(arg1); return(CreateArrayOfTypeRankOneFilled(orig.Arg(1), type.MakeArrayType())); } if (key == "array/3") { Type type = GetType(arg1); var ar = CreateArrayOfType(ToTermArray(orig.Arg(1)), type); FillArray(ToTermArray(orig.Arg(2)), type.GetElementType(), ar); return(ar); } if (name == "values") { Warn("Values array"); } if (name == "struct" || name == "event" || name == "object") { Type type = GetType(arg1); MemberInfo[] fis = GetStructFormat(type); return(CreateInstance(type, fis, orig, 2)); } if (orig.IsList) { if (arg1.IsInteger || arg1.IsAtom) { Debug("maybe this is a string {0}", orig); } if (pt == null) { var o1 = GetInstance(arg1); if (false && o1 != null && IsTaggedObject(arg1) && arg1.IsCompound && !o1.GetType().IsPrimitive) { Warn(" send a list into cliGet0 ", orig); bool found; var res = cliGet0(arg1, orig.Arg(1), o1.GetType(), out found, BindingFlagsALL3 | BindingFlagsALL); if (found) { return(res); } } Debug("Return as array of object[]?", orig); var o = CreateArrayNarrowest(ToObjectArray(ToTermArray(orig))); return(o); } else { if (pt.IsArray) { return(CreateArrayOfTypeRankOneFilled(orig, pt)); } if (!typeof(IEnumerable).IsAssignableFrom(pt)) { Warn("Return as collection?", orig); } return(CreateCollectionOfType(orig, pt)); } } if (pt != null && pt.IsArray) { return(CreateArrayOfTypeRankOneFilled(orig, pt)); } Type t = ResolveType(name); if (t == null) { WarnMissing(String.Format("Cant GetInstance from {0}", orig)); return(orig); } if (pt == null || pt.IsAssignableFrom(t)) { if (arity == 1) { return(CastTerm(arg1, t)); } foreach (var m in t.GetConstructors()) { ParameterInfo[] mGetParameters = m.GetParameters(); if (mGetParameters.Length == arity) { Action postCallHook; try { WarnMissing("using contructor {0}", m); var values = PlListToCastedArray(orig, mGetParameters, out postCallHook); var retval = m.Invoke(values); CommitPostCall(postCallHook); return(retval); } catch (Exception) { } } } } // Debug("Get Instance fallthru"); MemberInfo[] ofs = GetStructFormat(t); return(CreateInstance(t, ofs, orig, 1)); }