コード例 #1
0
ファイル: PrologCLR.cs プロジェクト: segmond/swicli
 public PrologCLR()
 {
     _singleInstance = this;
     ClientModule = null;
     ClientPrefix = "cli_";
     SetupProlog();
 }
コード例 #2
0
 /// <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));
     }
 }
コード例 #3
0
        public static void SetupProlog1()
        {
            PrologCLR.ConsoleTrace("geting lib path");
            CLASSPATH = java.lang.System.getProperty("java.class.path");
            ConsoleTrace("GOT lib path");
            string CLASSPATH0 = Environment.GetEnvironmentVariable("CLASSPATH");

            if (String.IsNullOrEmpty(CLASSPATH))
            {
                CLASSPATH = CLASSPATH0;
            }
            string jplcp = clasPathOf(new jpl.JPL());

            if (!JplDisabled)
            {
                CLASSPATH = IKVMHome + "/SWIJPL.dll" + ";" + IKVMHome + "/SWIJPL.jar;" + CLASSPATH0;
            }

            ConsoleWriteLine("CLASSPATH=" + CLASSPATH);
            if (CLASSPATH != null)
            {
                Environment.SetEnvironmentVariable("CLASSPATH", CLASSPATH);
                java.lang.System.setProperty("java.class.path", CLASSPATH);
            }
            java.lang.System.setProperty("java.library.path", libpath);
        }
コード例 #4
0
 private static string PlStringFormat(string text, params object[] ps)
 {
     RegisterCurrentThread();
     try
     {
         if (ps != null && ps.Length > 0)
         {
             for (int i = 0; i < ps.Length; i++)
             {
                 var o = ps[i];
                 if (o == null)
                 {
                     ps[i] = "NULL";
                 }
                 else if (o is Exception)
                 {
                     ps[i] = PrologCLR.ExceptionString((Exception)o);
                 }
             }
             text = String.Format(text, ps);
         }
     }
     catch (Exception)
     {
     }
     DeregisterThread(Thread.CurrentThread);
     return(text);
 }
コード例 #5
0
        //#pragma unsafe
        public override object CallPrologFast(object[] paramz)
        {
            //lock (oneEvtHandlerAtATime)
            {
                try
                {
                    string module = Key.Module ?? "user";
                    PrologEvents++;
                    if (!knownDefined && !PrologCLR.IsDefined(module, Key.Name, PrologArity))
                    {
                        //PrologCLR.Warn("Undefined Event Handler {0}:{1}/{2}", module, Key.Name, PrologArity);
                        return(null);
                    }
                    knownDefined = true;
                    return(PrologCLR.CallProlog(this, module, Key.Name, PrologArity, Key.Origin, paramz,
                                                ReturnType, true));
                }
                catch (AccessViolationException e)
                {
                    PrologCLR.Warn("CallProlog: {0} ex: {1}", this, e);
                    return(null);
                }
                catch (Exception e)
                {
                    PrologCLR.Warn("CallProlog: {0} ex: {1}", this, e);

                    return(null);
                }
            }
        }
コード例 #6
0
 public PrologCLR()
 {
     _singleInstance = this;
     ClientModule    = null;
     ClientPrefix    = "cli_";
     SetupProlog();
 }
コード例 #7
0
 public static PlTerm ValueToTerm(TValue value)
 {
     if (value.Equals(default(TValue)))
     {
         return(PlTerm.PlVar());
     }
     return(PrologCLR.ToProlog(value));
 }
コード例 #8
0
 public static PlTerm KeyToTerm(TKey key)
 {
     if (key.Equals(default(TValue)))
     {
         return(PlTerm.PlVar());
     }
     return(PrologCLR.ToProlog(key));
 }
コード例 #9
0
 public void Clear()
 {
     InForiegnFrame(() =>
     {
         PlTerm newPlTermV = PrologCLR.PlC(_querypred, new PlTermV(1));
         PlCall(_module, _retractall, new PlTermV(newPlTermV));
     });
 }
コード例 #10
0
ファイル: Tracker.cs プロジェクト: segmond/swicli
 public void RemoveRef()
 {
     Refs--;
     if (Refs == 0 && !Heaped)
     {
         PrologCLR.RemoveTaggedObject(TagName);
     }
 }
コード例 #11
0
        public object GetSymbol(string name)
        {
            PlTerm termout = PlTerm.PlVar();

            if (!ModuleCall("GetSymbol", PlNamed(name), termout))
            {
                return(null);
            }
            return(PrologCLR.CastTerm(termout, typeof(System.Object)));
        }
コード例 #12
0
        /// <summary>
        /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
        /// </summary>
        /// <returns>
        /// true if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>.
        /// </returns>
        /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
        ///                 </param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
        ///                 </exception>
        public bool Remove(KeyValuePair <TKey, TValue> item)
        {
            bool removed = false;

            InForiegnFrame(() =>
            {
                PlTerm newPlTermV = PrologCLR.PlC(_getvalue, TermVOf(item));
                removed           = PlCall(_module, _retractPred, new PlTermV(newPlTermV));
            });
            return(removed);
        }
コード例 #13
0
ファイル: GenericDelegate.cs プロジェクト: segmond/swicli
        /// <summary>
        ///  ?- closure(v(V1,V2),format('I was called with ~q ~q ...',[V1,V2]).
        /// </summary>
        /// <param name="info"></param>
        /// <param name="instance"></param>
        /// <param name="closureTerm"></param>
        public ClosureDelegate(EventInfo info, object instance, PlTerm clousreTerm)
        {
            Event    = info;
            Instance = instance;
            SetInstanceOfDelegateType(info.EventHandlerType);
            PlTerm plC = PlTerm.PlVar();

            PrologCLR.PlCall("system", "copy_term", new PlTermV(clousreTerm, plC));
            this.closureTerm = libpl.PL_record(clousreTerm.TermRef);
            Event.AddEventHandler(instance, Delegate);
        }
コード例 #14
0
 public void Add(T item)
 {
     if (_assertPred == null)
     {
         throw new NotSupportedException("add " + this);
     }
     InForiegnFrame(() =>
     {
         PlTerm newPlTermV = PrologCLR.PlC(_querypred, new PlTermV(KeyToTerm(item)));
         PlCall(_module, _assertPred, new PlTermV(newPlTermV));
     });
 }
コード例 #15
0
ファイル: GenericDelegate.cs プロジェクト: segmond/swicli
 static public void EnsureStated()
 {
     if (PrologGenericDelegateThread == null)
     {
         PrologGenericDelegateThread      = new Thread(PrologEventLoop);
         PrologGenericDelegateThread.Name = "PrologEventSerializer";
         PrologGenericDelegateThread.TrySetApartmentState(ApartmentState.STA);
         PrologGenericDelegateThread.IsBackground = true;
         PrologCLR.RegisterThread(PrologGenericDelegateThread);
         PrologGenericDelegateThread.Start();
     }
 }
コード例 #16
0
 /// <summary>
 /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>.
 /// </summary>
 /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.
 ///                 </param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
 ///                 </exception>
 public void Add(KeyValuePair <TKey, TValue> item)
 {
     if (_assertPred == null)
     {
         throw new NotSupportedException("add " + this);
     }
     InForiegnFrame(() =>
     {
         PlTerm newPlTermV = PrologCLR.PlC(_getvalue, TermVOf(item));
         PlCall(_module, _assertPred, new PlTermV(newPlTermV));
     });
 }
コード例 #17
0
 /// <summary>
 /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
 /// </summary>
 /// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
 ///                 </exception>
 public void Clear()
 {
     if (_retractall == null)
     {
         throw new NotSupportedException("clear " + this);
     }
     InForiegnFrame(() =>
     {
         PlTerm newPlTermV = PrologCLR.PlC(_getvalue, new PlTermV(2));
         PlCall(_module, _retractall, new PlTermV(newPlTermV));
     });
 }
コード例 #18
0
            /// <summary>
            /// Advances the enumerator to the next element of the collection.
            /// </summary>
            /// <returns>
            /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
            /// </returns>
            /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created.
            ///                 </exception><filterpriority>2</filterpriority>
            public bool MoveNext()
            {
                if (!plQuery.NextSolution())
                {
                    Dispose();
                    return(false);
                }
                nonLeft = false;
                PlTerm plQueryArgs = plQuery.Args[0];

                currentValue = PrologCLR.CastTerm(plQueryArgs, _dictionary.keyType);;
                return(true);
            }
コード例 #19
0
        public void InForiegnFrame(Action action)
        {
            PrologCLR.RegisterCurrentThread();
            uint fid = libpl.PL_open_foreign_frame();

            try
            {
                action();
            }
            finally
            {
                // if (fid > 0) libpl.PL_close_foreign_frame(fid);
            }
        }
コード例 #20
0
ファイル: Tracker.cs プロジェクト: segmond/swicli
 public bool RemoveFrame(TrackedFrame frame)
 {
     if (CurrentTrackedFrame == frame)
     {
         PopFrame();
         return(true);
     }
     else
     {
         if (PrologCLR.DebugRefs)
         {
             PrologCLR.Debug("Removing wierd frame{0}", frame);
         }
         frame.RemoveRefs();
         return(false);
     }
 }
コード例 #21
0
 static public int install()
 {
     try
     {
         PrologCLR.IsPLWin         = Type.GetType("Mono.Runtime") == null;
         PrologCLR.RedirectStreams = false;
         PrologCLR.SetupProlog();
         PrologCLR.ConsoleWriteLine(typeof(Embedded).FullName + ".install suceeded");
         PrologCLR.ClientReady = true;
         return(libpl.PL_succeed);
     }
     catch (Exception e)
     {
         PrologCLR.WriteException(e);
         PrologCLR.ConsoleWriteLine(typeof(Embedded).FullName + ".install failed");
         return(libpl.PL_fail);
     }
 }
コード例 #22
0
        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)));
        }
コード例 #23
0
ファイル: GenericDelegate.cs プロジェクト: segmond/swicli
        public override object CallPrologFast(object[] paramz)
        {
            PrologCLR.RegisterCurrentThread();
            var    results = paramz;
            PlTerm plC     = PlTerm.PlVar();

            libpl.PL_recorded(closureTerm, plC.TermRef);
            PlTerm ctestVars = plC.Arg(0);
            PlTerm ctestCode = plC.Arg(1);

            PlTerm[] terms  = PrologCLR.ToTermArray(ctestVars);
            int      idx    = terms.Length - 1;
            int      resdex = results.Length - 1;;

            while (idx >= 0 && resdex >= 0)
            {
                terms[idx--].FromObject(results[resdex--]);
            }
            PrologCLR.PlCall("user", "call", new PlTermV(ctestCode, 1));
            return(null);
        }
コード例 #24
0
        /// <summary>
        /// Gets the value associated with the specified key.
        /// </summary>
        /// <returns>
        /// true if the object that implements <see cref="T:System.Collections.Generic.IDictionary`2"/> contains an element with the specified key; otherwise, false.
        /// </returns>
        /// <param name="key">The key whose value to get.
        ///                 </param><param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the <paramref name="value"/> parameter. This parameter is passed uninitialized.
        ///                 </param><exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null.
        ///                 </exception>
        public bool TryGetValue(TKey key, out TValue value)
        {
            TValue value0 = default(TValue);
            bool   res    = false;

            InForiegnFrame(() =>
            {
                PlTerm plTermPlVar = PlTerm.PlVar();
                PlTermV newPlTermV = new PlTermV(KeyToTerm(key), plTermPlVar);
                res = PlCall(_module, _getvalue, newPlTermV);
                if (res)
                {
                    value0 = (TValue)PrologCLR.CastTerm(newPlTermV[1], valueType);
                }
                else
                {
                }
            });
            value = value0;
            return(res);
        }
コード例 #25
0
        //#pragma unsafe
        public override object CallPrologFast(object[] paramz)
        {
            //lock (oneEvtHandlerAtATime)
            {
                try
                {
                    object arg1 =
                        //Key.Origin; //makes sense for UseCallN
                        this;
                    PrologEvents++;
                    if (UseCallN)
                    {
                        return(PrologCLR.CallProlog(this, Key.Module, "call", PrologArity, arg1, paramz, ReturnType,
                                                    false));
                    }
                    string module = Key.Module ?? "user";
                    PrologEvents++;
                    if (!knownDefined && !PrologCLR.IsDefined(module, Key.Name, PrologArity))
                    {
                        PrologCLR.Warn("Undefined Delegate Handler {0}:{1}/{2}", module, Key.Name, PrologArity);
                        return(null);
                    }

                    knownDefined = true;
                    return(PrologCLR.CallProlog(this, module, Key.Name, PrologArity, arg1, paramz,
                                                ReturnType, false));
                }
                catch (AccessViolationException e)
                {
                    PrologCLR.Warn("CallProlog: {0} ex: {1}", this, e);
                    return(null);
                }
                catch (Exception e)
                {
                    PrologCLR.Warn("CallProlog: {0} ex: {1}", this, e);

                    return(null);
                }
            }
        }
コード例 #26
0
        public ArrayIndexEnumerator(Array value)
        {
            Type arrayType = value.GetType();

            rank   = arrayType.GetArrayRank();
            uppers = new int[rank];
            lowers = new int[rank];
            idx    = new int[rank];

            len = 1;
            for (int i = 0; i < rank; i++)
            {
                int high = uppers[i] = value.GetUpperBound(i);
                int low  = lowers[i] = value.GetLowerBound(i);
                if (low != 0)
                {
                    PrologCLR.Error("LowerBound !=0 in " + arrayType);
                }
                int lenSize = (high - low + 1);
                len *= lenSize;
            }
        }
コード例 #27
0
        /// <summary>
        /// Removes the element with the specified key from the <see cref="T:System.Collections.Generic.IDictionary`2"/>.
        /// </summary>
        /// <returns>
        /// true if the element is successfully removed; otherwise, false.  This method also returns false if <paramref name="key"/> was not found in the original <see cref="T:System.Collections.Generic.IDictionary`2"/>.
        /// </returns>
        /// <param name="key">The key of the element to remove.
        ///                 </param><exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null.
        ///                 </exception><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.IDictionary`2"/> is read-only.
        ///                 </exception>
        public bool Remove(TKey key)
        {
            if (Keyz != null)
            {
                if (!Keyz.IsReadOnly)
                {
                    return(Keyz.Remove(key));
                }
            }
            if (_retractPred == null)
            {
                throw new NotSupportedException("remove " + this);
            }
            bool removed = false;

            InForiegnFrame(() =>
            {
                PlTerm newPlTermV = PrologCLR.PlC(_getvalue, KeyToTerm(key), PlTerm.PlVar());
                removed           = PlCall(_module, _retractPred, new PlTermV(newPlTermV));
            });
            return(removed);
        }
コード例 #28
0
 public static object CallProlog(object target, string module, string name, int arity, object origin, object[] paramz, Type returnType, bool discard)
 {
     if (!ClientReady)
     {
         return(null);
     }
     return(InvokeFromC(() =>
     {
         PlTermV args = NewPlTermV(arity);
         int fillAt = 0;
         if (origin != null)
         {
             args[fillAt++].FromObject(origin);
         }
         for (int i = 0; i < paramz.Length; i++)
         {
             args[fillAt++].FromObject(paramz[i]);
         }
         bool IsVoid = returnType == typeof(void);
         if (!IsVoid)
         {
             //args[fillAt] = PlTerm.PlVar();
         }
         if (!PlQuery.PlCall(module, name, args))
         {
             if (!IsVoid)
             {
                 Warn("Failed Event Handler {0} failed", target);
             }
         }
         if (IsVoid)
         {
             return null;
         }
         object ret = PrologCLR.CastTerm(args[fillAt], returnType);
         return ret;
     }, discard));
 }
コード例 #29
0
 static public Type ToType(PlTerm typeSpec)
 {
     return(PrologCLR.GetType(typeSpec));
 }
コード例 #30
0
 public override sealed void Init(object self)
 {
     lock (GroupInitLock)
     {
         prologClient = prologClient ?? new PrologCLR();
         if (!IsInited)
         {
             IsInited = true;
             prologClient.InitFromUser();
         }
     }
 }
コード例 #31
0
ファイル: RuntimeTypeInfo.cs プロジェクト: segmond/swicli
 private PlTerm C(string collection)
 {
     return(PrologCLR.C(collection));
 }
コード例 #32
0
 public bool ConsultIfExists(string file)
 {
     return(PrologCLR.InvokeFromC(() => File.Exists(file) && Consult(file), false));
 }