private static int CountTo(PlTerm term, PlTerm term2, ref NonDetTest o) { try { var c = o.start; bool succed = term.Unify("callnum" + c); if (!succed) { succed = term2.Unify("callnum" + c); } if (succed) { succed = term2.Unify(term); } if (succed) { return(libpl.PL_succeed); } return(libpl.PL_fail); } finally { o.start++; } }
public static bool cliNewEventWaiter(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm blockOn) { object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } Type[] paramz = null; if (!CheckBound(memberSpec)) { return(false); } EventInfo fi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); if (fi == null) { return(Error("Cant find event {0} on {1}", memberSpec, (object)c ?? clazzOrInstance)); } WaitUntilDelegateList list = new WaitUntilDelegateList(); list.WaitOns.Add(new WaitUntilDelegate(list, fi, getInstance)); return(blockOn.FromObject(list)); }
public static bool cliFindMethod(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm methodOut) { BindingFlags searchFlags = BindingFlagsALL; if (!methodOut.IsVar) { var plvar = PlTerm.PlVar(); return(cliFindMethod(clazzOrInstance, memberSpec, plvar) && SpecialUnify(methodOut, plvar)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } if (!CheckBound(memberSpec)) { return(false); } Type[] paramz = null; var mi = findMethodInfo(memberSpec, -1, c, ref paramz, searchFlags); if (mi != null) { return(methodOut.FromObject((mi))); } return(false); }
public void KomplexPlException() { const int size = 4; const int index = 6; PlTerm term = PlTerm.PlCompound("error", new PlTermV(PlTerm.PlCompound("domain_error", new PlTermV(PlTerm.PlCompound("argv", new PlTermV(size)), new PlTerm(index)) ), PlTerm.PlVar()) ); var ex = new PlException(term); //Assert.AreEqual("Domain error: `argv(_G1, _G2, _G3, _G4)' expected, found `6'", ex.Message); // since swi-prolog version 5.7.6 // Assert.AreEqual("Domain error: `argv(_G60, _G61, _G62, _G63)' expected, found `6'", ex.Message); // since swi-prolog version 5.7.10 // Assert.AreEqual("Domain error: `argv(_G1, _G2, _G3, _G4)' expected, found `6'", ex.Message); // since swi-prolog version 5.9.10 #if _PL_X64 Assert.AreEqual("Domain error: `argv(_G53,_G54,_G55,_G56)' expected, found `6'", ex.Message); #else Assert.AreEqual("Domain error: `argv(_G1,_G2,_G3,_G4)' expected, found `6'", ex.Message); #endif }
static public bool cliFree(PlTerm taggedObject) { if (taggedObject.IsVar) { return(false); } string tag; if (taggedObject.IsCompound) { tag = taggedObject[1].Name; } else if (taggedObject.IsAtom) { tag = taggedObject.Name; } else if (taggedObject.IsString) { tag = taggedObject.Name; } else { return(true); } return(FreeTag(tag, true)); }
public static bool cliAddTag(PlTerm taggedObj, PlTerm tagString) { object o = GetInstance(taggedObj); string tagname = (string)tagString; lock (ObjToTag) { TrackedObject s; long adr; GCHandle iptr = GetIptr(o, out adr, true); var hc = tagname.GetHashCode(); s = new TrackedObject(o) { TagName = tagname, Pinned = iptr, addr = adr, HashCode = hc, Heaped = true }; ObjToTag[o] = s; TagToObj[tagname] = s; } return(true); }
public void QueryPrologLatin12() { PlQuery.PlCall("consult('" + _plFilenameUnicode + "')"); PlTerm t = PlQuery.PlCallQuery("latin1(L)"); Assert.AreEqual(StrLatin1, t.ToString()); }
public static bool cliSetField(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm valueIn) { if (!valueIn.IsVar) { return(Error("Cant set property with a var {0}", valueIn)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } if (!CheckBound(memberSpec)) { return(false); } bool found; foreach (var searchFlags in getInstance == null ? BindingFlags_SEARCHS : BindingFlags_SEARCHIS) { if (cliSet0(getInstance, memberSpec, valueIn, c, searchFlags | BindingFlags.SetField)) { return(true); } } return(false); }
/// <summary> /// <para>To catch a exception thrown by prolog</para> /// <para>For a example see <see cref="PlException"/>.</para> /// </summary> /// <param name="term">A PlTerm containing the Prolog exception</param> /// <see cref="PlException"/> public PlException(PlTerm term) { EnsureExFrame(); Check.Require(term.TermRefIntern != 0); _exTerm = new PlTerm(term.TermRef); // If this line is deleted -> update comment in PlTern(term_ref) _messagePl = "" + _exTerm; }
public void QueryPrologUnicode() { PlQuery.PlCall("consult('" + _plFilenameUtf8 + "')"); PlTerm t = PlQuery.PlCallQuery("unicode(L)"); Assert.AreEqual(StrUnicode, t.ToString()); }
private Event CreateEventFromTerm(PlTerm term) { if (term.Name != "event" || term.Arity != 2) { return(null); } var queryEventArgs = new PlTerm[] { term[1], PlTerm.PlVar(), PlTerm.PlVar(), PlTerm.PlVar(), PlTerm.PlVar(), PlTerm.PlVar(), PlTerm.PlVar() }; bool eventExists = PlQuery.PlCall("eventType", new PlTermV(queryEventArgs)); if (!eventExists) { return(null); } var argsLst = PlTermExtension.ArgsLst(term[1]); var stateTermsArgs = instanceStateTermArgs(argsLst); if (stateTermsArgs == null) { return(null); } return(new Event(term[1].Name, term[1].Arity, stateTermsArgs, float.Parse(term[2].ToString(), CultureInfo.InvariantCulture))); }
//operator char *(void); /// <inheritdoc /> /// <summary> /// The exception is translated into a message as produced by print_message/2. The character data is stored in a ring. /// </summary> /// <returns>A textual description of the Exception</returns> override public string ToString() { if (!PlEngine.IsInitialized) { return("A PlException was thrown but it can't formatted because PlEngine is not Initialized."); } string strRet = "[ERROR: Failed to generate message. Internal error]\n"; using (new PlFrame()) { #if USE_PRINT_MESSAGE PlTermV av = new PlTermV(2); av[0] = PlTerm.PlCompound("print_message", new PlTermV(new PlTerm("error"), new PlTerm(_exTerm.TermRef))); PlQuery q = new PlQuery("$write_on_string", av); if (q.NextSolution()) { strRet = (string)av[1]; } q.Free(); #else var av = new PlTermV(2); av[0] = new PlTerm(_exTerm.TermRef); using (var q = new PlQuery("$messages", "message_to_string", av)) { if (q.NextSolution()) { strRet = av[1].ToString(); } } #endif } return(strRet); }
private static Type[] GetParamSpec(PlTerm[] memberSpec, bool isObjects, int start, int length) { var specArray = memberSpec; int arity = specArray.Length - start; if (length > -1) { arity = length - start; } int end = start + arity; Type[] paramz = new Type[arity]; for (int i = start; i < end; i++) { PlTerm info = specArray[i]; if (!info.IsVar) { var t = GetType(info, isObjects); if (t == null) { t = typeof (object); } paramz[i] = t; } } return paramz; }
private void newGameToolStripMenuItem_Click(object sender, EventArgs e) { FrmNewGame newGame = new FrmNewGame(); newGame.ShowDialog(); foreach (Player p in Player.PlayerList) { foreach (Token t in p.TokenList) { panelBoard.Controls.Add(t); t.LocationChanged += new EventHandler <EventArgs>(token_LocationChanged); } } FrmFirstPlay firstPlay = new FrmFirstPlay(); firstPlay.ShowDialog(); PlTerm term = PlTerm.PlVar(); PlQuery q = new PlQuery("na_redu", new PlTermV(term)); q.NextSolution(); int idPlayer = int.Parse(term.ToString()); q.Dispose(); playerOnMove = Player.PlayerList.Find(x => x.ID == idPlayer); lblPlayerOnTheMove.Text = playerOnMove.Nickname; btnColor.BackColor = playerOnMove.Color; btnRollDice.Enabled = true; lblStatus.Text = "Roll the dice!"; }
public void QueryPrologAscii2() { PlQuery.PlCall("consult('" + _plFilenameUnicode + "')"); PlTerm t = PlQuery.PlCallQuery("ascii(L)"); Assert.AreEqual(StrAscii, t.ToString()); }
public static bool cliGetProperty(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm indexValues, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return(cliGetProperty(clazzOrInstance, memberSpec, indexValues, plvar) && SpecialUnify(valueOut, plvar)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } Type[] paramz = null; BindingFlags searchFlags = BindingFlagsALL; if (!CheckBound(memberSpec, indexValues)) { return(false); } var pi = findPropertyInfo(memberSpec, c, false, true, ref paramz, searchFlags); if (pi == null) { Error("Cant find property {0} on {1}", memberSpec, c); return(false); } Action postCallHook; var ps = PlListToCastedArray(indexValues, pi.GetIndexParameters(), out postCallHook); object cliGet01 = pi.GetValue(getInstance, ps); CommitPostCall(postCallHook); return(valueOut.FromObject(cliGet01)); }
public void CharSet_3() { var t2 = new PlTerm("'ąę'"); var t1 = new PlTerm(@"'\u0105\u0119'"); Assert.IsTrue(t1.Unify(t2)); }
static public bool cliTrackerBegin(PlTerm trackerOut) { ThisThreadTracked++; var newTracking = LocallyTrackedObjects.CreateFrame(); return(UnifyTagged(newTracking, trackerOut)); }
public void PlCallQuery2() { #region PlCallQuery_direct_2_doc PlTerm t = PlQuery.PlCallQuery("atom_concat(a, b, X)"); Assert.AreEqual("ab", t.ToString()); #endregion PlCallQuery_direct_2_doc }
static public bool cliHeap(PlTerm taggedObject) { if (taggedObject.IsVar) { return(false); } string tag; if (taggedObject.IsCompound) { tag = taggedObject[1].Name; } else if (taggedObject.IsAtom) { tag = taggedObject.Name; } else if (taggedObject.IsString) { tag = taggedObject.Name; } else { return(true); } lock (TagToObj) { TrackedObject oref; if (TagToObj.TryGetValue(tag, out oref)) { oref.Heaped = true; return(true); } return(false); } }
public void PlCallQuery3() { #region PlCallQuery_direct_3_doc PlTerm t = PlQuery.PlCallQuery("working_directory(O, O)"); Assert.IsTrue(t.ToString().EndsWith("contrib-swiplcs/testswipl/bin/debug/"), "Path is not correct:" + t.ToString()); #endregion PlCallQuery_direct_3_doc }
private static Type[] GetParamSpec(PlTerm[] memberSpec, bool isObjects, int start, int length) { var specArray = memberSpec; int arity = specArray.Length - start; if (length > -1) { arity = length - start; } int end = start + arity; Type[] paramz = new Type[arity]; for (int i = start; i < end; i++) { PlTerm info = specArray[i]; if (!info.IsVar) { var t = GetType(info, isObjects); if (t == null) { t = typeof(object); } paramz[i] = t; } } return(paramz); }
static public bool cliAddEventHandler(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm prologPred) { object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; Type[] paramz = null; if (!CheckBound(memberSpec, prologPred)) return false; EventInfo fi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); if (fi == null) { return Error("Cant find event {0} on {1}", memberSpec, c); } var Key = new EventHandlerInPrologKey { Name = PredicateName(prologPred), Module = PredicateModule(prologPred), Arity = PredicateArity(prologPred), Origin = getInstance, Event = fi }; lock (PrologEventHandlers) { EventHandlerInProlog handlerInProlog; if (PrologEventHandlers.TryGetValue(Key, out handlerInProlog)) { fi.RemoveEventHandler(getInstance, handlerInProlog.Delegate); PrologEventHandlers.Remove(Key); } handlerInProlog = new EventHandlerInProlog(Key); PrologEventHandlers.Add(Key, handlerInProlog); fi.AddEventHandler(getInstance, handlerInProlog.Delegate); } return true; }
public static bool cliRaiseEventHandler(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return(cliRaiseEventHandler(clazzOrInstance, memberSpec, paramsIn, plvar) && SpecialUnify(valueOut, plvar)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } Type[] paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; if (!CheckBound(memberSpec, paramsIn)) { return(false); } PlTerm[] paramIn = ToTermArray(paramsIn); if (paramz.Length == 0 && paramIn.Length > paramz.Length) { paramz = GetParamSpec(paramIn, true); } EventInfo evi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); return(RaiseEvent(getInstance, memberSpec, paramIn, valueOut, evi, c)); }
/// <summary> /// Wygenerowanie pierwszego rozwiązania. /// </summary> private void start_button_Click(object sender, EventArgs e) { try { String sciezka = @"..\..\..\alloc.pl"; if (!File.Exists(sciezka)) { throw new FileNotFoundException("Brak pliku: " + sciezka); } String crew = prepareCrewPrologList(); String flightsReqs = prepareFlightsRequirements(); //DefaultData.prepareDefaultRequirements(); if (!PlEngine.IsInitialized) { String[] param = { "-f", sciezka }; PlEngine.Initialize(param); } prologParams = new PlTermV(3); prologQuery = new PlQuery("matchTeams", prologParams); prologParams[1] = new PlTerm(flightsReqs); prologParams[2] = new PlTerm(crew); generateResultAndShow(); } catch (Exception ex) { MessageBox.Show("Wyjatek:\n\n" + ex.Message); } }
/// <summary> /// Gets or sets the element with the specified key. /// </summary> /// <returns> /// The element with the specified key. /// </returns> /// <param name="key">The key of the element to get or set. /// </param><exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null. /// </exception><exception cref="T:System.Collections.Generic.KeyNotFoundException">The property is retrieved and <paramref name="key"/> is not found. /// </exception><exception cref="T:System.NotSupportedException">The property is set and the <see cref="T:System.Collections.Generic.IDictionary`2"/> is read-only. /// </exception> public TValue this[TKey key] { get { TValue tvalue = default(TValue); InForiegnFrame(() => { PlTerm newPlTermV = PrologCLR.PlC(_getvalue, KeyToTerm(key), PlTerm.PlVar()); bool res = PlCall(_module, _getvalue, new PlTermV(newPlTermV)); if (res) { tvalue = (TValue)PrologCLR.CastTerm(newPlTermV.Arg(1), valueType); } else { // tvalue = default(TValue); } }); return(tvalue); } set { Remove(key); Add(new KeyValuePair <TKey, TValue>(key, value)); } }
public static object GetInstance(PlTerm classOrInstance) { if (classOrInstance.IsVar) { Warn("GetInstance(PlVar) {0}", classOrInstance); return null; } if (!classOrInstance.IsCompound) { if (classOrInstance.IsString) { Debug("GetInstance(string) {0}", classOrInstance); return (string)classOrInstance; } if (classOrInstance.IsAtom) { if (classOrInstance.Name == "[]") { return CastCompoundTerm("[]", 0, classOrInstance, classOrInstance, null); } Type t = GetType(classOrInstance); // we do this for static invokations like: cliGet('java.lang.Integer','MAX_VALUE',...) // the arg1 denotes a type, then return null! if (t != null) return null; Warn("GetInstance(atom) {0}", classOrInstance); // possibly should always return null?! } return CastTerm(classOrInstance, null); } string name = classOrInstance.Name; int arity = classOrInstance.Arity; return CastCompoundTerm(name, arity, classOrInstance[1], classOrInstance, null); }
public static bool cliAddEventWaiter(PlTerm blockOn, PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm newBlockOn) { WaitUntilDelegateList list = null; object getInstance1 = GetInstance(blockOn); var wud = getInstance1 as WaitUntilDelegate; if (wud == null) { if (!(getInstance1 is WaitUntilDelegateList)) return Embedded.Error("Not an instance of WaitUntilDelegate: " + blockOn); list = getInstance1 as WaitUntilDelegateList; } else { list = wud.parent; } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; Type[] paramz = null; if (!CheckBound(memberSpec, blockOn)) return false; EventInfo fi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); if (fi == null) { return Embedded.Error("Cant find event {0} on {1}", memberSpec, (object)c ?? clazzOrInstance); } var wud2 = new WaitUntilDelegate(list, fi, getInstance); list.WaitOns.Add(wud2); return newBlockOn.FromObject(list); }
/// <summary> /// Returns the Type when denoated by a 'namespace.type' (usefull for static instance specification) /// if a @C#234234 the type of the object unless its a a class /// c(a) => System.Char "sdfsdf" => System.String uint(5) => System.UInt32 /// /// instanceMaybe maybe Null.. it is passed in so the method code doesn't have to call GetInstance again /// on classOrInstance /// </summary> /// <param name="instanceMaybe"></param> /// <param name="classOrInstance"></param> /// <returns></returns> private static Type GetTypeFromInstance(object instanceMaybe, PlTerm classOrInstance) { if (classOrInstance.IsAtom) { return GetType(classOrInstance); } if (classOrInstance.IsString) { if (instanceMaybe != null) return instanceMaybe.GetType(); return typeof(string); } if (classOrInstance.IsCompound) { if (classOrInstance.Name == "static") { return GetType(classOrInstance[1]); } } object val = instanceMaybe ?? GetInstance(classOrInstance); //if (val is Type) return (Type)val; if (val == null) { Warn("GetTypeFromInstance: {0}", classOrInstance); return null; } return val.GetType(); }
public static bool cliGetField(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return(cliGetField(clazzOrInstance, memberSpec, plvar) && SpecialUnify(valueOut, plvar)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } if (!CheckBound(memberSpec)) { return(false); } bool found; foreach (var searchFlags in getInstance == null ? BindingFlags_SEARCHS : BindingFlags_SEARCHIS) { object cliGet01 = cliGet0(getInstance, memberSpec, c, out found, searchFlags | BindingFlags.GetField); if (found) { return(valueOut.FromObject(cliGet01)); } } return(false); }
private static bool SpecialUnify(PlTerm valueOut, PlTerm plvar) { bool b = valueOut.Unify(plvar); if (b) return true; object obj1 = GetInstance(plvar); if (ReferenceEquals(obj1, null)) { return false; } Type t1 = obj1.GetType(); object obj2 = CastTerm(valueOut, t1); if (ReferenceEquals(obj2, null)) { return false; } Type t2 = obj2.GetType(); if (obj1.Equals(obj2)) { return true; } if (t1 == t2) { return false; } return false; }
public static bool cliSetProperty(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm indexValues, PlTerm valueIn) { if (!valueIn.IsVar) { return(Error("Cant set property with a var {0}", valueIn)); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) { return(false); } Type[] paramz = null; if (!CheckBound(memberSpec, indexValues, valueIn)) { return(false); } BindingFlags searchFlags = BindingFlagsALL; var pi = findPropertyInfo(memberSpec, c, false, true, ref paramz, searchFlags); if (pi == null) { Error("Cant find property {0} on {1}", memberSpec, c); return(false); } Action postCallHook; var ps = PlListToCastedArray(indexValues, pi.GetIndexParameters(), out postCallHook); pi.SetValue(getInstance, CastTerm(valueIn, pi.PropertyType), ps); CommitPostCall(postCallHook); return(true); }
/// <summary> /// Début du tour nbTour /// </summary> /// <param name="term"></param> /// <returns></returns> private bool callPlayTour(PlTerm term) { int nbTour = int.Parse(term.ToString()); events.tourChanged(nbTour + 1); return(true); }
public static bool cliCallRaw(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); Type returnTypeHint = GuessReturnType(valueOut, typeof(void)); return cliCallRawForVar(clazzOrInstance, memberSpec, paramsIn, plvar, returnTypeHint) && SpecialUnify(valueOut, plvar); } return cliCallRawForVar(clazzOrInstance, memberSpec, paramsIn, valueOut, typeof(void)); }
static public bool cliNewDelegate(PlTerm delegateClass, PlTerm prologPred, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliNewDelegate(delegateClass, prologPred, plvar) && SpecialUnify(valueOut, plvar); } object retval = cliNewDelegateTerm(GetTypeThrowIfMissing(delegateClass), prologPred, true); return valueOut.FromObject(retval); }
static public Delegate cliNewDelegateTerm(Type fi, PlTerm prologPred, bool saveKey) { if (prologPred.IsCompound) { if (prologPred.Name == "delegate") { if (prologPred.Arity == 1) { return cliNewDelegateTerm(fi, prologPred.Arg(0), saveKey); } Type dt = GetTypeThrowIfMissing(prologPred.Arg(0)); var obj = cliNewDelegateTerm(dt, prologPred.Arg(1), saveKey); return (Delegate)RecastObject(fi, obj, dt); } if (prologPred.Name == "@") { return (Delegate)RecastObject(fi, tag_to_object((string)prologPred.Arg(0)), null); } } string pn = prologPred.Name; if (pn == "." || pn == "{}") { // Warn("Delegate term = " + pn); } var Key = new DelegateObjectInPrologKey { Name = PredicateName(prologPred), Arity = PredicateArity(prologPred), Module = PredicateModule(prologPred), DelegateType = fi }; //uint fid = libpl.PL_open_foreign_frame(); //Key.Origin = prologPred.Copy(); DelegateObjectInProlog handlerInProlog; lock (PrologDelegateHandlers) { if (PrologDelegateHandlers.TryGetValue(Key, out handlerInProlog)) { // fi.RemoveEventHandler(getInstance, handlerInProlog.Delegate); PrologDelegateHandlers.Remove(Key); } handlerInProlog = new DelegateObjectInProlog(Key); if (saveKey) PrologDelegateHandlers.Add(Key, handlerInProlog); // fi.AddEventHandler(getInstance, handlerInProlog.Delegate); } return handlerInProlog.Delegate; }
public static bool cliNewEventWaiter(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm blockOn) { object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; Type[] paramz = null; if (!CheckBound(memberSpec)) return false; EventInfo fi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); if (fi == null) { return Error("Cant find event {0} on {1}", memberSpec, (object) c ?? clazzOrInstance); } WaitUntilDelegateList list = new WaitUntilDelegateList(); list.WaitOns.Add(new WaitUntilDelegate(list, fi, getInstance)); return blockOn.FromObject(list); }
public static bool cliSetField(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm valueIn) { if (!valueIn.IsVar) { return Error("Cant set property with a var {0}", valueIn); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; if (!CheckBound(memberSpec)) return false; bool found; foreach (var searchFlags in getInstance == null ? BindingFlags_SEARCHS : BindingFlags_SEARCHIS) { if (cliSet0(getInstance, memberSpec, valueIn, c, searchFlags | BindingFlags.SetField)) return true; } return false; }
public static bool cliCallRawForVar(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut, Type returnTypeHint) { BindingFlags searchFlags = BindingFlagsALL; object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; if (!CheckBound(memberSpec, paramsIn)) return false; Type[] paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; PlTerm[] paramIn = ToTermArray(paramsIn); if (paramz.Length == 0 && paramIn.Length > paramz.Length) { paramz = GetParamSpecFromObjects(paramIn); } var mi = findMethodInfo(memberSpec, paramz.Length, c, ref paramz, searchFlags); if (mi == null) { if (getInstance is PInvokeMetaObject) { PInvokeMetaObject pi = getInstance as PInvokeMetaObject; string mspecName = GetMemberName(memberSpec); mi = pi.GetInvoke(mspecName, paramz, returnTypeHint); } } if (mi == null) { var ei = findEventInfo(memberSpec, c, ref paramz, searchFlags); if (ei != null) return RaiseEvent(getInstance, memberSpec, paramIn, valueOut, ei, c); if (paramsIn.IsNil) return cliGetRaw(clazzOrInstance, memberSpec, valueOut); Embedded.Warn("Cant find method {0} on {1}", memberSpec, c); return false; } Action postCallHook; object[] value = PlListToCastedArray(paramIn, mi.GetParameters(), out postCallHook); object target = mi.IsStatic ? null : getInstance; object retval = InvokeCaught0(mi, target, value, postCallHook); return valueOut.FromObject(retval ?? VoidOrNull(mi)); }
public static bool cliGetField(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliGetField(clazzOrInstance, memberSpec, plvar) && SpecialUnify(valueOut, plvar); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; if (!CheckBound(memberSpec)) return false; bool found; foreach (var searchFlags in getInstance == null ? BindingFlags_SEARCHS : BindingFlags_SEARCHIS) { object cliGet01 = cliGet0(getInstance, memberSpec, c, out found, searchFlags | BindingFlags.GetField); if (found) { return valueOut.FromObject(cliGet01); } } return false; }
private static Type[] GetParamSpec(PlTerm[] memberSpec, bool isObjects) { return GetParamSpec(memberSpec, isObjects, 0, -1); }
private static Type[] GetParamSpec(PlTerm memberSpec) { return memberSpec.IsCompound ? GetParamSpec(ToTermArray(memberSpec), false) : null; }
public static bool cliNew(PlTerm clazzSpec, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliNew(clazzSpec, memberSpec, paramsIn, plvar) && SpecialUnify(valueOut, plvar); } Type c = GetType(clazzSpec); if (c == null) { Error("Cant resolve clazzSpec {0}", clazzSpec); return false; } Type[] paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; PlTerm[] paramIn = ToTermArray(paramsIn); if (paramz.Length == 0 && paramIn.Length > paramz.Length) { paramz = GetParamSpec(paramIn, true); } MethodBase mi = null; if (!c.IsAbstract) mi = findConstructorInfo(memberSpec, c, ref paramz); object target = null; if (mi == null) { int arity = paramz.Length; if (arity == 1) { mi = c.GetMethod("op_Implicit", (BindingFlags.Public | BindingFlags.Static), null, paramz, new ParameterModifier[0]); if (mi == null) { mi = c.GetMethod("op_Explicit", (BindingFlags.Public | BindingFlags.Static), null, paramz, new ParameterModifier[0]); } if (mi == null) { if (c.IsPrimitive) { //Warn("Trying to constuct a primitive type"); return valueOut.FromObject(Convert.ChangeType(GetInstance(paramIn[0]), c)); } } } if (mi == null) { MethodInfo[] members = c.GetMethods(BindingFlagsJustStatic); mi = BestMethod(paramz, members, c, true); } } if (mi == null) { Error("Cant find constructor {0} on {1}", memberSpec, c); return false; } Action postCallHook; object[] values = PlListToCastedArray(paramIn, mi.GetParameters(), out postCallHook); object res; // mono doesnt mind.. // typeof(System.Text.StringBuilder).GetConstructor(new[]{typeof(System.String)}).Invoke(null,new object[]{"hi there"}).ToString(); // .NET doesnt if (mi is ConstructorInfo) { res = ((ConstructorInfo) mi).Invoke(values); } else { res = mi.Invoke(null, values); } var ret = valueOut.FromObject(res); CommitPostCall(postCallHook); return ret; }
public static bool cliFindConstructor(PlTerm clazzSpec, PlTerm memberSpec, PlTerm methodOut) { Type c = GetType(clazzSpec); Type[] paramz = null; MethodBase mi = findConstructorInfo(memberSpec, c, ref paramz); if (mi != null) { return methodOut.FromObject((mi)); } return false; }
private static ConstructorInfo findConstructorInfo(PlTerm memberSpec, Type c, ref Type[] paramz) { if (c == null) { Warn("findConstructor no class for {0}", memberSpec); return null; } if (IsTaggedObject(memberSpec)) { var r = tag_to_object(memberSpec[1].Name) as ConstructorInfo; if (r != null) return r; } if (memberSpec.IsInteger) { var mis = c.GetConstructors(BindingFlagsALL); return mis[memberSpec.intValue()]; } if (paramz == null) { Warn("using paramSpec {0}", ToString(memberSpec)); paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; } if (paramz != null) { var mi = c.GetConstructor(paramz); if (mi != null) return mi; } ConstructorInfo[] members = c.GetConstructors(BindingFlagsALL); if (members.Length == 0) return null; int arity = (paramz != null) ? paramz.Length : memberSpec.Arity; ConstructorInfo candidate = null; foreach (var info in members) { var infos = info; ParameterInfo[] paramTypes = infos.GetParameters(); if (paramTypes.Length == arity) { if (ParamsMatch(paramz, paramTypes)) return info; if (infos.IsStatic) { if (candidate == null) { candidate = info; } } else { if (candidate == null) { candidate = info; } } } } return candidate ?? members[0]; }
private static MethodInfo findMethodInfo0(PlTerm memberSpec, int arity, Type c, ref Type[] paramz, BindingFlags searchFlags) { if (c == null) { Warn("findMethod no class for {0}", memberSpec); return null; } if (memberSpec.IsVar) { Warn("findMethod IsVar {0} on type {1}", memberSpec, c); return null; } if (memberSpec.IsInteger) { var mis = c.GetMethods(BindingFlagsALL); return mis[memberSpec.intValue()]; } if (IsTaggedObject(memberSpec)) { object o = tag_to_object(memberSpec[1].Name); var r = o as MethodInfo; if (r != null) return r; var d = o as Delegate; if (d != null) return d.Method ?? d.GetType().GetMethod("Invoke"); } string fn = memberSpec.Name; MethodInfo mi = null; BindingFlags icbf = searchFlags; if (arity < 1) { mi = GetMethod(c, fn, icbf); if (mi != null) return mi; } if (paramz == null) { Warn("using paramSpec {0}", ToString(memberSpec)); paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; } try { bool hasNull = false; foreach (var s in paramz) { if (s == null) { hasNull = true; break; } } if (!hasNull) { mi = c.GetMethod(fn, icbf, null, CallingConventions.Any, paramz, null); } if (mi != null) { return mi; } } catch ( /*AmbiguousMatch*/ Exception e) { Debug("AME: {0} fn = {1}", e, fn); } MethodInfo[] members = c.GetMethods(searchFlags); if (arity < 0) arity = (paramz != null) ? paramz.Length : memberSpec.Arity; string fnLower = fn.ToLower(); var candidates = new MethodInfo[2]; foreach (var infos in members) { var methodParams = infos.GetParameters(); if (methodParams.Length == arity) { if (infos.Name == fn) { candidates[0] = infos; } else if (infos.Name.ToLower() == fnLower) { candidates[1] = infos; } else { continue; } if (ParamsMatch(paramz, methodParams)) return infos; } } return candidates[0] ?? candidates[1]; }
public static bool RaiseEvent(object getInstance, PlTerm memberSpec, PlTerm[] paramIn, PlTerm valueOut, EventInfo evi, Type c) { if (evi == null) { return Warn("Cant find event {0} on {1}", memberSpec, c); } ParameterInfo[] paramInfos = GetParmeters(evi); MethodInfo mi = evi.GetRaiseMethod(); string fn = evi.Name; if (mi == null) { FieldInfo fi = c.GetField(fn, BindingFlagsALLNC); if (fi != null) { Delegate del = (Delegate) fi.GetValue(getInstance); if (del != null) { Action postCallHook; var ret = valueOut.FromObject((del.DynamicInvoke( PlListToCastedArray(paramIn, paramInfos, out postCallHook)))); CommitPostCall(postCallHook); return ret; } } string fn1 = fn.Substring(1); int len = fn.Length; foreach (FieldInfo info in c.GetFields(BindingFlagsALL)) { if (info.Name.EndsWith(fn1)) { if (info.Name.Length - len < 3) { Delegate del = (Delegate) info.GetValue(info.IsStatic ? null : getInstance); if (del != null) { Action postCallHook; var ret = valueOut.FromObject((del.DynamicInvoke( PlListToCastedArray(paramIn, paramInfos, out postCallHook)))); CommitPostCall(postCallHook); return ret; } } } } } if (mi == null) { Type eviEventHandlerType = evi.EventHandlerType; if (eviEventHandlerType != null) mi = eviEventHandlerType.GetMethod("Invoke"); } if (mi == null) { Warn("Cant find event raising for {0} on {1}", evi, c); return false; } Action postCallHook0; object[] value = PlListToCastedArray(paramIn, mi.GetParameters(), out postCallHook0); object target = mi.IsStatic ? null : getInstance; return valueOut.FromObject(InvokeCaught(mi, target, value, postCallHook0) ?? VoidOrNull(mi)); }
public static bool cliBreak(PlTerm ex) { Trace(); return Embedded.WarnMissing(ToString(ex)) || true; }
public static bool cliFindMethod(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm methodOut) { BindingFlags searchFlags = BindingFlagsALL; if (!methodOut.IsVar) { var plvar = PlTerm.PlVar(); return cliFindMethod(clazzOrInstance, memberSpec, plvar) && SpecialUnify(methodOut, plvar); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; if (!CheckBound(memberSpec)) return false; Type[] paramz = null; var mi = findMethodInfo(memberSpec, -1, c, ref paramz, searchFlags); if (mi != null) { return methodOut.FromObject((mi)); } return false; }
private static bool GetInstanceAndType(PlTerm clazzOrInstance, out object getInstance, out Type c) { if (clazzOrInstance.IsVar) { c = null; getInstance = null; return Embedded.Error("Cant find instance {0}", clazzOrInstance); } getInstance = GetInstance(clazzOrInstance); c = GetTypeFromInstance(getInstance, clazzOrInstance); if (getInstance == null && c == null) { return Embedded.Error("Cant find instance or type {0}", clazzOrInstance); } return true; }
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) { Embedded.Warn("cliToString: {0}", e); object o = GetInstance(obj); if (o == null) return str.FromObject("" + obj); return str.FromObject(ToString(o)); } }
public static bool cliThrow(PlTerm ex) { throw (Exception) CastTerm(ex, typeof (Exception)); }
public static bool cliLockExit(PlTerm lockObj) { object getInstance = GetInstance(lockObj); Monitor.Exit(getInstance); return true; }
public static bool cliJavaToString(PlTerm paramIn, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliJavaToString(paramIn, plvar) && SpecialUnify(valueOut, plvar); } object getInstance = GetInstance(paramIn); if (getInstance == null) return valueOut.Unify(PlTerm.PlString("null")); #if USE_IKVM object val = getInstance as java.lang.Object; if (val == null) { Class c = ikvm.runtime.Util.getClassFromObject(getInstance); string s = (string)c.getMethod("toString", new Class[0]).invoke(getInstance, ZERO_OBJECTS); return valueOut.Unify(PlTerm.PlString(s)); } return valueOut.Unify(PlTerm.PlString(val.toString())); #else object val = getInstance; return valueOut.Unify(PlTerm.PlString(val.ToString())); #endif }
public static bool cliCallRaw(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut) { BindingFlags searchFlags = BindingFlagsALL; if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliCallRaw(clazzOrInstance, memberSpec, paramsIn, plvar) && SpecialUnify(valueOut, plvar); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; if (!CheckBound(memberSpec, paramsIn)) return false; Type[] paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; PlTerm[] paramIn = ToTermArray(paramsIn); if (paramz.Length == 0 && paramIn.Length > paramz.Length) { paramz = GetParamSpec(paramIn, true); } var mi = findMethodInfo(memberSpec, paramz.Length, c, ref paramz, searchFlags); if (mi == null) { var ei = findEventInfo(memberSpec, c, ref paramz, searchFlags); if (ei != null) return RaiseEvent(getInstance, memberSpec, paramIn, valueOut, ei, c); if (paramsIn.IsAtom && paramsIn.Name == "[]") return cliGetRaw(clazzOrInstance, memberSpec, valueOut); Warn("Cant find method {0} on {1}", memberSpec, c); return false; } Action postCallHook; object[] value = PlListToCastedArray(paramIn, mi.GetParameters(), out postCallHook); object target = mi.IsStatic ? null : getInstance; object retval = InvokeCaught(mi, target, value, postCallHook); return valueOut.FromObject(retval ?? VoidOrNull(mi)); }
private static bool link_swiplcs(PlTerm pathName) { try { return true; if (Embedded.JplSafeNativeMethodsCalled) { bool enabled = !Embedded.JplSafeNativeMethodsDisabled; SafelyRun( () => ConsoleTrace("JplSafeNativeMethods called again from " + pathName + " result=" + enabled)); return enabled; } Embedded.JplSafeNativeMethodsCalled = true; SafelyRun(() => ConsoleTrace("JplSafeNativeMethods call first time from " + pathName)); JplSafeNativeMethods.install(); //var v = new PlTerm("_1"); //JplSafeNativeMethods.jpl_c_lib_version_1_plc(v.TermRef); return true; } catch (Exception e) { Embedded.JplSafeNativeMethodsDisabled = true; Embedded.WriteException(e); return false; } }
public static bool cliRaiseEventHandler(PlTerm clazzOrInstance, PlTerm memberSpec, PlTerm paramsIn, PlTerm valueOut) { if (!valueOut.IsVar) { var plvar = PlTerm.PlVar(); return cliRaiseEventHandler(clazzOrInstance, memberSpec, paramsIn, plvar) && SpecialUnify(valueOut, plvar); } object getInstance; Type c; if (!GetInstanceAndType(clazzOrInstance, out getInstance, out c)) return false; Type[] paramz = GetParamSpec(memberSpec) ?? ZERO_TYPES; if (!CheckBound(memberSpec, paramsIn)) return false; PlTerm[] paramIn = ToTermArray(paramsIn); if (paramz.Length == 0 && paramIn.Length > paramz.Length) { paramz = GetParamSpec(paramIn, true); } EventInfo evi = findEventInfo(memberSpec, c, ref paramz, BindingFlagsALL); return RaiseEvent(getInstance, memberSpec, paramIn, valueOut, evi, c); }
private static MethodInfo findMethodInfo(PlTerm memberSpec, int arity, Type c, ref Type[] paramz, BindingFlags searchFlags) { var mi = findMethodInfo0(memberSpec, arity, c, ref paramz, searchFlags); if (mi == null) { return null; } if (!mi.IsGenericMethodDefinition) return mi; var typeparams = mi.GetGenericArguments() ?? ZERO_TYPES; if (typeparams.Length == 0) return mi; if (memberSpec.IsAtom) { { var ps = mi.GetParameters(); bool missingTypePAramInArgs = false; foreach (Type type in typeparams) { Type type1 = type; var pi = Array.Find(ps, p => p.ParameterType == type1); if (pi != null) { continue; } Warn("Trying to find a generic methods without type specifiers {0}", ToString(typeparams)); } } return mi; } else { if (memberSpec.IsCompound) { Type[] t = GetParamSpec(ToTermArray(memberSpec), false, 0, typeparams.Length); if (t.Length == typeparams.Length) { mi = mi.MakeGenericMethod(t); } } return mi; } }
private static EventInfo findEventInfo(PlTerm memberSpec, Type c, ref Type[] paramz, BindingFlags searchFlags) { if (memberSpec.IsVar) { WarnMissing("findEventInfo IsVar {0} on type {1}", memberSpec, c); return null; } if (memberSpec.IsInteger) { int ordinal = memberSpec.intValue(); var mis = c.GetEvents(BindingFlagsALL); if (ordinal < 0 || ordinal >= mis.Length) return null; return mis[ordinal]; } if (IsTaggedObject(memberSpec)) { var r = tag_to_object(memberSpec[1].Name) as EventInfo; if (r != null) return r; } if (memberSpec.IsCompound) { if (memberSpec.Name == "e") { var arg1 = memberSpec.Arg(0); if (arg1.IsInteger) { Type[] paramzN = null; return findEventInfo(arg1, c, ref paramzN, searchFlags); } } } if (c == null) return null; EventInfo ei = c.GetEvent(memberSpec.Name, searchFlags); if (ei != null) return ei; var members = c.GetEvents(searchFlags); if (members.Length == 0) return null; int arity = (paramz != null) ? paramz.Length : memberSpec.Arity; EventInfo candidate = null; foreach (var info in members) { var infos = info.GetRaiseMethod(); ParameterInfo[] paramTypes = infos.GetParameters(); if (paramTypes.Length == arity) { if (ParamsMatch(paramz, paramTypes)) return info; if (infos.IsStatic) { if (candidate == null) { candidate = info; } } else { if (candidate == null) { candidate = info; } } } } return candidate ?? members[0]; }
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); } }