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