1 files changed, 1440 insertions, 1440 deletions
diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YP.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YP.cs
index 3c0e4e0..2912ab9 100644
--- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YP.cs
+++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YP.cs
@@ -1,1440 +1,1440 @@
-/*
+/*
- * Copyright (C) 2007-2008, Jeff Thompson
+ * Copyright (C) 2007-2008, Jeff Thompson
- * 
+ * 
- * All rights reserved.
+ * All rights reserved.
- * 
+ * 
- * Redistribution and use in source and binary forms, with or without 
+ * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are met:
+ * modification, are permitted provided that the following conditions are met:
- * 
+ * 
- *     * Redistributions of source code must retain the above copyright 
+ *     * Redistributions of source code must retain the above copyright 
- *       notice, this list of conditions and the following disclaimer.
+ *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright 
+ *     * Redistributions in binary form must reproduce the above copyright 
- *       notice, this list of conditions and the following disclaimer in the 
+ *       notice, this list of conditions and the following disclaimer in the 
- *       documentation and/or other materials provided with the distribution.
+ *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the copyright holder nor the names of its contributors 
+ *     * Neither the name of the copyright holder nor the names of its contributors 
- *       may be used to endorse or promote products derived from this software 
+ *       may be used to endorse or promote products derived from this software 
- *       without specific prior written permission.
+ *       without specific prior written permission.
- * 
+ * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
+ */
-using System;
+using System;
-using System.Collections;
+using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.IO;
+using System.IO;
-using System.Reflection;
+using System.Reflection;
-namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog
+namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog
-{
+{
-    /// <summary>
+    /// <summary>
-    /// YP has static methods for general functions in Yield Prolog such as <see cref="getValue"/>
+    /// YP has static methods for general functions in Yield Prolog such as <see cref="getValue"/>
-    /// and <see cref="unify"/>.
+    /// and <see cref="unify"/>.
-    /// </summary>
+    /// </summary>
-    public class YP
+    public class YP
-    {
+    {
-        private static Fail _fail = new Fail();
+        private static Fail _fail = new Fail();
-        private static Repeat _repeat = new Repeat();
+        private static Repeat _repeat = new Repeat();
-        private static Dictionary<NameArity, List<IClause>> _predicatesStore =
+        private static Dictionary<NameArity, List<IClause>> _predicatesStore =
-            new Dictionary<NameArity, List<IClause>>();
+            new Dictionary<NameArity, List<IClause>>();
-        private static TextWriter _outputStream = System.Console.Out;
+        private static TextWriter _outputStream = System.Console.Out;
-        private static TextReader _inputStream = System.Console.In;
+        private static TextReader _inputStream = System.Console.In;
-        private static List<object[]> _operatorTable = null;
+        private static List<object[]> _operatorTable = null;
-        /// <summary>
+        /// <summary>
-        /// An IClause is used so that dynamic predicates can call match.
+        /// An IClause is used so that dynamic predicates can call match.
-        /// </summary>
+        /// </summary>
-        public interface IClause
+        public interface IClause
-        {
+        {
-            IEnumerable<bool> match(object[] args);
+            IEnumerable<bool> match(object[] args);
-        }
+        }
-        public static object getValue(object value)
+        public static object getValue(object value)
-        {
+        {
-            if (value is Variable)
+            if (value is Variable)
-                return ((Variable)value).getValue();
+                return ((Variable)value).getValue();
-            else
+            else
-                return value;
+                return value;
-        }
+        }
-        public static IEnumerable<bool> unify(object arg1, object arg2)
+        public static IEnumerable<bool> unify(object arg1, object arg2)
-        {
+        {
-            arg1 = getValue(arg1);
+            arg1 = getValue(arg1);
-            arg2 = getValue(arg2);
+            arg2 = getValue(arg2);
-            if (arg1 is IUnifiable)
+            if (arg1 is IUnifiable)
-                return ((IUnifiable)arg1).unify(arg2);
+                return ((IUnifiable)arg1).unify(arg2);
-            else if (arg2 is IUnifiable)
+            else if (arg2 is IUnifiable)
-                return ((IUnifiable)arg2).unify(arg1);
+                return ((IUnifiable)arg2).unify(arg1);
-            else
+            else
-            {
+            {
-                // Arguments are "normal" types.
+                // Arguments are "normal" types.
-                if (arg1.Equals(arg2))
+                if (arg1.Equals(arg2))
-                    return new Succeed();
+                    return new Succeed();
-                else
+                else
-                    return _fail;
+                    return _fail;
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// This is used for the lookup key in _factStore.
+        /// This is used for the lookup key in _factStore.
-        /// </summary>
+        /// </summary>
-        public struct NameArity
+        public struct NameArity
-        {
+        {
-            public readonly Atom _name;
+            public readonly Atom _name;
-            public readonly int _arity;
+            public readonly int _arity;
-            public NameArity(Atom name, int arity)
+            public NameArity(Atom name, int arity)
-            {
+            {
-                _name = name;
+                _name = name;
-                _arity = arity;
+                _arity = arity;
-            }
+            }
-            public override bool Equals(object obj)
+            public override bool Equals(object obj)
-            {
+            {
-                if (obj is NameArity)
+                if (obj is NameArity)
-                {
+                {
-                    NameArity nameArity = (NameArity)obj;
+                    NameArity nameArity = (NameArity)obj;
-                    return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity);
+                    return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity);
-                }
+                }
-                else
+                else
-                {
+                {
-                    return false;
+                    return false;
-                }
+                }
-            }
+            }
-            public override int GetHashCode()
+            public override int GetHashCode()
-            {
+            {
-                return _name.GetHashCode() ^ _arity.GetHashCode();
+                return _name.GetHashCode() ^ _arity.GetHashCode();
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Convert term to an int.
+        /// Convert term to an int.
-        /// If term is a single-element List, use its first element
+        /// If term is a single-element List, use its first element
-        /// (to handle the char types like "a").  If can't convert, throw an exception.
+        /// (to handle the char types like "a").  If can't convert, throw an exception.
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static int convertInt(object term)
+        public static int convertInt(object term)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
-                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
-                // Assume it is a char type like "a".
+                // Assume it is a char type like "a".
-                term = YP.getValue(((Functor2)term)._arg1);
+                term = YP.getValue(((Functor2)term)._arg1);
-            return (int)term;
+            return (int)term;
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Convert term to a double.  This may convert an int to a double, etc.
+        /// Convert term to a double.  This may convert an int to a double, etc.
-        /// If term is a single-element List, use its first element
+        /// If term is a single-element List, use its first element
-        /// (to handle the char types like "a").  If can't convert, throw an exception.
+        /// (to handle the char types like "a").  If can't convert, throw an exception.
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static double convertDouble(object term)
+        public static double convertDouble(object term)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
-                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
-                // Assume it is a char type like "a".
+                // Assume it is a char type like "a".
-                term = YP.getValue(((Functor2)term)._arg1);
+                term = YP.getValue(((Functor2)term)._arg1);
-            return Convert.ToDouble(term);
+            return Convert.ToDouble(term);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// If term is an integer, set intTerm.
+        /// If term is an integer, set intTerm.
-        /// If term is a single-element List, use its first element
+        /// If term is a single-element List, use its first element
-        /// (to handle the char types like "a").  Return true for success, false if can't convert.
+        /// (to handle the char types like "a").  Return true for success, false if can't convert.
-        /// We use a success return value because throwing an exception is inefficient.
+        /// We use a success return value because throwing an exception is inefficient.
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static bool getInt(object term, out int intTerm)
+        public static bool getInt(object term, out int intTerm)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
+            if (term is Functor2 && ((Functor2)term)._name == Atom.DOT &&
-                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
+                YP.getValue(((Functor2)term)._arg2) == Atom.NIL)
-                // Assume it is a char type like "a".
+                // Assume it is a char type like "a".
-                term = YP.getValue(((Functor2)term)._arg1);
+                term = YP.getValue(((Functor2)term)._arg1);
-            if (term is int)
+            if (term is int)
-            {
+            {
-                intTerm = (int)term;
+                intTerm = (int)term;
-                return true;
+                return true;
-            }
+            }
-            intTerm = 0;
+            intTerm = 0;
-            return false;
+            return false;
-        }
+        }
-        public static bool equal(object x, object y)
+        public static bool equal(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x == (DateTime)YP.getValue(y);
+                return (DateTime)x == (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) == YP.convertDouble(y);
+            return YP.convertDouble(x) == YP.convertDouble(y);
-        }
+        }
-        public static bool notEqual(object x, object y)
+        public static bool notEqual(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x != (DateTime)YP.getValue(y);
+                return (DateTime)x != (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) != YP.convertDouble(y);
+            return YP.convertDouble(x) != YP.convertDouble(y);
-        }
+        }
-        public static bool greaterThan(object x, object y)
+        public static bool greaterThan(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x > (DateTime)YP.getValue(y);
+                return (DateTime)x > (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) > YP.convertDouble(y);
+            return YP.convertDouble(x) > YP.convertDouble(y);
-        }
+        }
-        public static bool lessThan(object x, object y)
+        public static bool lessThan(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x < (DateTime)YP.getValue(y);
+                return (DateTime)x < (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) < YP.convertDouble(y);
+            return YP.convertDouble(x) < YP.convertDouble(y);
-        }
+        }
-        public static bool greaterThanOrEqual(object x, object y)
+        public static bool greaterThanOrEqual(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x >= (DateTime)YP.getValue(y);
+                return (DateTime)x >= (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) >= YP.convertDouble(y);
+            return YP.convertDouble(x) >= YP.convertDouble(y);
-        }
+        }
-        public static bool lessThanOrEqual(object x, object y)
+        public static bool lessThanOrEqual(object x, object y)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is DateTime)
+            if (x is DateTime)
-                return (DateTime)x <= (DateTime)YP.getValue(y);
+                return (DateTime)x <= (DateTime)YP.getValue(y);
-            // Assume convertDouble converts an int to a double perfectly.
+            // Assume convertDouble converts an int to a double perfectly.
-            return YP.convertDouble(x) <= YP.convertDouble(y);
+            return YP.convertDouble(x) <= YP.convertDouble(y);
-        }
+        }
-        public static object negate(object x)
+        public static object negate(object x)
-        {
+        {
-            int intX;
+            int intX;
-            if (getInt(x, out intX))
+            if (getInt(x, out intX))
-                return -intX;
+                return -intX;
-            return -convertDouble(x);
+            return -convertDouble(x);
-        }
+        }
-        public static object abs(object x)
+        public static object abs(object x)
-        {
+        {
-            int intX;
+            int intX;
-            if (getInt(x, out intX))
+            if (getInt(x, out intX))
-                return Math.Abs(intX);
+                return Math.Abs(intX);
-            return Math.Abs(convertDouble(x));
+            return Math.Abs(convertDouble(x));
-        }
+        }
-        public static object sign(object x)
+        public static object sign(object x)
-        {
+        {
-            int intX;
+            int intX;
-            if (getInt(x, out intX))
+            if (getInt(x, out intX))
-                return Math.Sign(intX);
+                return Math.Sign(intX);
-            return Math.Sign(convertDouble(x));
+            return Math.Sign(convertDouble(x));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// The ISO standard returns an int.
+        /// The ISO standard returns an int.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object floor(object x)
+        public static object floor(object x)
-        {
+        {
-            return (int)Math.Floor(convertDouble(x));
+            return (int)Math.Floor(convertDouble(x));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// The ISO standard returns an int.
+        /// The ISO standard returns an int.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object truncate(object x)
+        public static object truncate(object x)
-        {
+        {
-            return (int)Math.Truncate(convertDouble(x));
+            return (int)Math.Truncate(convertDouble(x));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// The ISO standard returns an int.
+        /// The ISO standard returns an int.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object round(object x)
+        public static object round(object x)
-        {
+        {
-            return (int)Math.Round(convertDouble(x));
+            return (int)Math.Round(convertDouble(x));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// The ISO standard returns an int.
+        /// The ISO standard returns an int.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object ceiling(object x)
+        public static object ceiling(object x)
-        {
+        {
-            return (int)Math.Ceiling(convertDouble(x));
+            return (int)Math.Ceiling(convertDouble(x));
-        }
+        }
-        public static object sin(object x)
+        public static object sin(object x)
-        {
+        {
-            return Math.Sin(YP.convertDouble(x));
+            return Math.Sin(YP.convertDouble(x));
-        }
+        }
-        public static object cos(object x)
+        public static object cos(object x)
-        {
+        {
-            return Math.Cos(YP.convertDouble(x));
+            return Math.Cos(YP.convertDouble(x));
-        }
+        }
-        public static object atan(object x)
+        public static object atan(object x)
-        {
+        {
-            return Math.Atan(YP.convertDouble(x));
+            return Math.Atan(YP.convertDouble(x));
-        }
+        }
-        public static object exp(object x)
+        public static object exp(object x)
-        {
+        {
-            return Math.Exp(YP.convertDouble(x));
+            return Math.Exp(YP.convertDouble(x));
-        }
+        }
-        public static object log(object x)
+        public static object log(object x)
-        {
+        {
-            return Math.Log(YP.convertDouble(x));
+            return Math.Log(YP.convertDouble(x));
-        }
+        }
-        public static object sqrt(object x)
+        public static object sqrt(object x)
-        {
+        {
-            return Math.Sqrt(convertDouble(x));
+            return Math.Sqrt(convertDouble(x));
-        }
+        }
-        public static object bitwiseComplement(object x)
+        public static object bitwiseComplement(object x)
-        {
+        {
-            return ~YP.convertInt(x);
+            return ~YP.convertInt(x);
-        }
+        }
-        public static object add(object x, object y)
+        public static object add(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return intX + intY;
+                return intX + intY;
-            return convertDouble(x) + convertDouble(y);
+            return convertDouble(x) + convertDouble(y);
-        }
+        }
-        public static object subtract(object x, object y)
+        public static object subtract(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return intX - intY;
+                return intX - intY;
-            return convertDouble(x) - convertDouble(y);
+            return convertDouble(x) - convertDouble(y);
-        }
+        }
-        public static object multiply(object x, object y)
+        public static object multiply(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return intX * intY;
+                return intX * intY;
-            return convertDouble(x) * convertDouble(y);
+            return convertDouble(x) * convertDouble(y);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Return floating point, even if both arguments are integer.
+        /// Return floating point, even if both arguments are integer.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <param name="y"></param>
+        /// <param name="y"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object divide(object x, object y)
+        public static object divide(object x, object y)
-        {
+        {
-            return convertDouble(x) / convertDouble(y);
+            return convertDouble(x) / convertDouble(y);
-        }
+        }
-        public static object intDivide(object x, object y)
+        public static object intDivide(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return intX / intY;
+                return intX / intY;
-            // Still allow passing a double, but treat as an int.
+            // Still allow passing a double, but treat as an int.
-            return (int)convertDouble(x) / (int)convertDouble(y);
+            return (int)convertDouble(x) / (int)convertDouble(y);
-        }
+        }
-        public static object mod(object x, object y)
+        public static object mod(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return intX % intY;
+                return intX % intY;
-            // Still allow passing a double, but treat as an int.
+            // Still allow passing a double, but treat as an int.
-            return (int)convertDouble(x) % (int)convertDouble(y);
+            return (int)convertDouble(x) % (int)convertDouble(y);
-        }
+        }
-        public static object pow(object x, object y)
+        public static object pow(object x, object y)
-        {
+        {
-            return Math.Pow(YP.convertDouble(x), YP.convertDouble(y));
+            return Math.Pow(YP.convertDouble(x), YP.convertDouble(y));
-        }
+        }
-        public static object bitwiseShiftRight(object x, object y)
+        public static object bitwiseShiftRight(object x, object y)
-        {
+        {
-            return YP.convertInt(x) >> YP.convertInt(y);
+            return YP.convertInt(x) >> YP.convertInt(y);
-        }
+        }
-        public static object bitwiseShiftLeft(object x, object y)
+        public static object bitwiseShiftLeft(object x, object y)
-        {
+        {
-            return YP.convertInt(x) << YP.convertInt(y);
+            return YP.convertInt(x) << YP.convertInt(y);
-        }
+        }
-        public static object bitwiseAnd(object x, object y)
+        public static object bitwiseAnd(object x, object y)
-        {
+        {
-            return YP.convertInt(x) & YP.convertInt(y);
+            return YP.convertInt(x) & YP.convertInt(y);
-        }
+        }
-        public static object bitwiseOr(object x, object y)
+        public static object bitwiseOr(object x, object y)
-        {
+        {
-            return YP.convertInt(x) | YP.convertInt(y);
+            return YP.convertInt(x) | YP.convertInt(y);
-        }
+        }
-        public static object min(object x, object y)
+        public static object min(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return Math.Min(intX, intY);
+                return Math.Min(intX, intY);
-            return Math.Min(convertDouble(x), convertDouble(y));
+            return Math.Min(convertDouble(x), convertDouble(y));
-        }
+        }
-        public static object max(object x, object y)
+        public static object max(object x, object y)
-        {
+        {
-            int intX, intY;
+            int intX, intY;
-            if (getInt(x, out intX) && getInt(y, out intY))
+            if (getInt(x, out intX) && getInt(y, out intY))
-                return Math.Max(intX, intY);
+                return Math.Max(intX, intY);
-            return Math.Max(convertDouble(x), convertDouble(y));
+            return Math.Max(convertDouble(x), convertDouble(y));
-        }
+        }
-        public static IEnumerable<bool> copy_term(object inTerm, object outTerm)
+        public static IEnumerable<bool> copy_term(object inTerm, object outTerm)
-        {
+        {
-            return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore()));
+            return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore()));
-        }
+        }
-        public static void addUniqueVariables(object term, List<Variable> variableSet)
+        public static void addUniqueVariables(object term, List<Variable> variableSet)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is IUnifiable)
+            if (term is IUnifiable)
-                ((IUnifiable)term).addUniqueVariables(variableSet);
+                ((IUnifiable)term).addUniqueVariables(variableSet);
-        }
+        }
-        public static object makeCopy(object term, Variable.CopyStore copyStore)
+        public static object makeCopy(object term, Variable.CopyStore copyStore)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is IUnifiable)
+            if (term is IUnifiable)
-                return ((IUnifiable)term).makeCopy(copyStore);
+                return ((IUnifiable)term).makeCopy(copyStore);
-            else
+            else
-                // term is a "normal" type. Assume it is ground.
+                // term is a "normal" type. Assume it is ground.
-                return term;
+                return term;
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Sort the array in place according to termLessThan.  This does not remove duplicates
+        /// Sort the array in place according to termLessThan.  This does not remove duplicates
-        /// </summary>
+        /// </summary>
-        /// <param name="array"></param>
+        /// <param name="array"></param>
-        public static void sortArray(object[] array)
+        public static void sortArray(object[] array)
-        {
+        {
-            Array.Sort(array, YP.compareTerms);
+            Array.Sort(array, YP.compareTerms);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Sort the array in place according to termLessThan.  This does not remove duplicates
+        /// Sort the array in place according to termLessThan.  This does not remove duplicates
-        /// </summary>
+        /// </summary>
-        /// <param name="array"></param>
+        /// <param name="array"></param>
-        public static void sortArray(List<object> array)
+        public static void sortArray(List<object> array)
-        {
+        {
-            array.Sort(YP.compareTerms);
+            array.Sort(YP.compareTerms);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Sort List according to termLessThan, remove duplicates and unify with Sorted.
+        /// Sort List according to termLessThan, remove duplicates and unify with Sorted.
-        /// </summary>
+        /// </summary>
-        /// <param name="List"></param>
+        /// <param name="List"></param>
-        /// <param name="Sorted"></param>
+        /// <param name="Sorted"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> sort(object List, object Sorted)
+        public static IEnumerable<bool> sort(object List, object Sorted)
-        {
+        {
-            object[] array = ListPair.toArray(List);
+            object[] array = ListPair.toArray(List);
-            if (array == null)
+            if (array == null)
-                return YP.fail();
+                return YP.fail();
-            if (array.Length > 1)
+            if (array.Length > 1)
-                sortArray(array);
+                sortArray(array);
-            return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
+            return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Use YP.unify to unify each of the elements of the two arrays, and yield
+        /// Use YP.unify to unify each of the elements of the two arrays, and yield
-        /// once if they all unify.
+        /// once if they all unify.
-        /// </summary>
+        /// </summary>
-        /// <param name="array1"></param>
+        /// <param name="array1"></param>
-        /// <param name="array2"></param>
+        /// <param name="array2"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> unifyArrays(object[] array1, object[] array2)
+        public static IEnumerable<bool> unifyArrays(object[] array1, object[] array2)
-        {
+        {
-            if (array1.Length != array2.Length)
+            if (array1.Length != array2.Length)
-                yield break;
+                yield break;
-            IEnumerator<bool>[] iterators = new IEnumerator<bool>[array1.Length];
+            IEnumerator<bool>[] iterators = new IEnumerator<bool>[array1.Length];
-            bool gotMatch = true;
+            bool gotMatch = true;
-            int nIterators = 0;
+            int nIterators = 0;
-            // Try to bind all the arguments.
+            // Try to bind all the arguments.
-            for (int i = 0; i < array1.Length; ++i)
+            for (int i = 0; i < array1.Length; ++i)
-            {
+            {
-                IEnumerator<bool> iterator = YP.unify(array1[i], array2[i]).GetEnumerator();
+                IEnumerator<bool> iterator = YP.unify(array1[i], array2[i]).GetEnumerator();
-                iterators[nIterators++] = iterator;
+                iterators[nIterators++] = iterator;
-                // MoveNext() is true if YP.unify succeeds.
+                // MoveNext() is true if YP.unify succeeds.
-                if (!iterator.MoveNext())
+                if (!iterator.MoveNext())
-                {
+                {
-                    gotMatch = false;
+                    gotMatch = false;
-                    break;
+                    break;
-                }
+                }
-            }
+            }
-            try
+            try
-            {
+            {
-                if (gotMatch)
+                if (gotMatch)
-                    yield return false;
+                    yield return false;
-            }
+            }
-            finally
+            finally
-            {
+            {
-                // Manually finalize all the iterators.
+                // Manually finalize all the iterators.
-                for (int i = 0; i < nIterators; ++i)
+                for (int i = 0; i < nIterators; ++i)
-                    iterators[i].Dispose();
+                    iterators[i].Dispose();
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Return an iterator (which you can use in a for-in loop) which does
+        /// Return an iterator (which you can use in a for-in loop) which does
-        /// zero iterations.  This returns a pre-existing iterator which is
+        /// zero iterations.  This returns a pre-existing iterator which is
-        /// more efficient than letting the compiler generate a new one.
+        /// more efficient than letting the compiler generate a new one.
-        /// </summary>
+        /// </summary>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> fail()
+        public static IEnumerable<bool> fail()
-        {
+        {
-            return _fail;
+            return _fail;
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Return an iterator (which you can use in a for-in loop) which does
+        /// Return an iterator (which you can use in a for-in loop) which does
-        /// one iteration.  This returns a pre-existing iterator which is
+        /// one iteration.  This returns a pre-existing iterator which is
-        /// more efficient than letting the compiler generate a new one.
+        /// more efficient than letting the compiler generate a new one.
-        /// </summary>
+        /// </summary>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> succeed()
+        public static IEnumerable<bool> succeed()
-        {
+        {
-            return new Succeed();
+            return new Succeed();
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Return an iterator (which you can use in a for-in loop) which repeats
+        /// Return an iterator (which you can use in a for-in loop) which repeats
-        /// indefinitely.  This returns a pre-existing iterator which is
+        /// indefinitely.  This returns a pre-existing iterator which is
-        /// more efficient than letting the compiler generate a new one.
+        /// more efficient than letting the compiler generate a new one.
-        /// </summary>
+        /// </summary>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> repeat()
+        public static IEnumerable<bool> repeat()
-        {
+        {
-            return _repeat;
+            return _repeat;
-        }
+        }
-        public static IEnumerable<bool> univ(object Term, object List)
+        public static IEnumerable<bool> univ(object Term, object List)
-        {
+        {
-            Term = YP.getValue(Term);
+            Term = YP.getValue(Term);
-            List = YP.getValue(List);
+            List = YP.getValue(List);
-            if (nonvar(Term))
+            if (nonvar(Term))
-                return YP.unify(new ListPair
+                return YP.unify(new ListPair
-                    (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List);
+                    (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List);
-            Variable Name = new Variable();
+            Variable Name = new Variable();
-            Variable ArgList = new Variable();
+            Variable ArgList = new Variable();
-            foreach (bool l1 in new ListPair(Name, ArgList).unify(List))
+            foreach (bool l1 in new ListPair(Name, ArgList).unify(List))
-            {
+            {
-                object[] args = ListPair.toArray(ArgList);
+                object[] args = ListPair.toArray(ArgList);
-                if (args == null)
+                if (args == null)
-                    throw new Exception("Expected a list. Got: " + ArgList.getValue());
+                    throw new Exception("Expected a list. Got: " + ArgList.getValue());
-                if (args.Length == 0)
+                if (args.Length == 0)
-                    // Return the Name, even if it is not an Atom.
+                    // Return the Name, even if it is not an Atom.
-                    return YP.unify(Term, Name);
+                    return YP.unify(Term, Name);
-                if (!atom(Name))
+                if (!atom(Name))
-                    throw new Exception("Expected an atom. Got: " + Name.getValue());
+                    throw new Exception("Expected an atom. Got: " + Name.getValue());
-                return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args));
+                return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args));
-            }
+            }
-            return YP.fail();
+            return YP.fail();
-        }
+        }
-        public static IEnumerable<bool> functor(object Term, object FunctorName, object Arity)
+        public static IEnumerable<bool> functor(object Term, object FunctorName, object Arity)
-        {
+        {
-            Term = YP.getValue(Term);
+            Term = YP.getValue(Term);
-            FunctorName = YP.getValue(FunctorName);
+            FunctorName = YP.getValue(FunctorName);
-            Arity = YP.getValue(Arity);
+            Arity = YP.getValue(Arity);
-            if (!(Term is Variable))
+            if (!(Term is Variable))
-            {
+            {
-                foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term)))
+                foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term)))
-                {
+                {
-                    foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length))
+                    foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length))
-                        yield return false;
+                        yield return false;
-                }
+                }
-            }
+            }
-            else
+            else
-                throw new NotImplementedException("Debug: must finish functor/3");
+                throw new NotImplementedException("Debug: must finish functor/3");
-        }
+        }
-        public static IEnumerable<bool> arg(object ArgNumber, object Term, object Value)
+        public static IEnumerable<bool> arg(object ArgNumber, object Term, object Value)
-        {
+        {
-            if (YP.var(ArgNumber))
+            if (YP.var(ArgNumber))
-                throw new NotImplementedException("Debug: must finish arg/3");
+                throw new NotImplementedException("Debug: must finish arg/3");
-            else
+            else
-            {
+            {
-                int argNumberInt = convertInt(ArgNumber);
+                int argNumberInt = convertInt(ArgNumber);
-                if (argNumberInt < 0)
+                if (argNumberInt < 0)
-                    throw new Exception("ArgNumber must be non-negative");
+                    throw new Exception("ArgNumber must be non-negative");
-                object[] termArgs = YP.getFunctorArgs(Term);
+                object[] termArgs = YP.getFunctorArgs(Term);
-                // Silently fail if argNumberInt is out of range.
+                // Silently fail if argNumberInt is out of range.
-                if (argNumberInt >= 1 && argNumberInt <= termArgs.Length)
+                if (argNumberInt >= 1 && argNumberInt <= termArgs.Length)
-                {
+                {
-                    // The first ArgNumber is at 1, not 0.
+                    // The first ArgNumber is at 1, not 0.
-                    foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1]))
+                    foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1]))
-                        yield return false;
+                        yield return false;
-                }
+                }
-            }
+            }
-        }
+        }
-        public static bool termEqual(object Term1, object Term2)
+        public static bool termEqual(object Term1, object Term2)
-        {
+        {
-            Term1 = YP.getValue(Term1);
+            Term1 = YP.getValue(Term1);
-            if (Term1 is IUnifiable)
+            if (Term1 is IUnifiable)
-                return ((IUnifiable)Term1).termEqual(Term2);
+                return ((IUnifiable)Term1).termEqual(Term2);
-            return Term1.Equals(YP.getValue(Term2));
+            return Term1.Equals(YP.getValue(Term2));
-        }
+        }
-        public static bool termNotEqual(object Term1, object Term2)
+        public static bool termNotEqual(object Term1, object Term2)
-        {
+        {
-            return !termEqual(Term1, Term2);
+            return !termEqual(Term1, Term2);
-        }
+        }
-        public static bool termLessThan(object Term1, object Term2)
+        public static bool termLessThan(object Term1, object Term2)
-        {
+        {
-            Term1 = YP.getValue(Term1);
+            Term1 = YP.getValue(Term1);
-            Term2 = YP.getValue(Term2);
+            Term2 = YP.getValue(Term2);
-            int term1TypeCode = getTypeCode(Term1);
+            int term1TypeCode = getTypeCode(Term1);
-            int term2TypeCode = getTypeCode(Term2);
+            int term2TypeCode = getTypeCode(Term2);
-            if (term1TypeCode != term2TypeCode)
+            if (term1TypeCode != term2TypeCode)
-                return term1TypeCode < term2TypeCode;
+                return term1TypeCode < term2TypeCode;
-            // The terms are the same type code.
+            // The terms are the same type code.
-            if (term1TypeCode == -2)
+            if (term1TypeCode == -2)
-            {
+            {
-                // Variable.
+                // Variable.
-                // We always check for equality first because we want to be sure 
+                // We always check for equality first because we want to be sure 
-                //   that less than returns false if the terms are equal, in 
+                //   that less than returns false if the terms are equal, in 
-                //   case that the less than check really behaves like less than or equal.
+                //   case that the less than check really behaves like less than or equal.
-                if ((Variable)Term1 != (Variable)Term2)
+                if ((Variable)Term1 != (Variable)Term2)
-                    // The hash code should be unique to a Variable object.
+                    // The hash code should be unique to a Variable object.
-                    return Term1.GetHashCode() < Term2.GetHashCode();
+                    return Term1.GetHashCode() < Term2.GetHashCode();
-                return false;
+                return false;
-            }
+            }
-            if (term1TypeCode == 0)
+            if (term1TypeCode == 0)
-                return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0;
+                return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0;
-            if (term1TypeCode == 1)
+            if (term1TypeCode == 1)
-                return ((Functor1)Term1).lessThan((Functor1)Term2);
+                return ((Functor1)Term1).lessThan((Functor1)Term2);
-            if (term1TypeCode == 2)
+            if (term1TypeCode == 2)
-                return ((Functor2)Term1).lessThan((Functor2)Term2);
+                return ((Functor2)Term1).lessThan((Functor2)Term2);
-            if (term1TypeCode == 3)
+            if (term1TypeCode == 3)
-                return ((Functor3)Term1).lessThan((Functor3)Term2);
+                return ((Functor3)Term1).lessThan((Functor3)Term2);
-            if (term1TypeCode == 4)
+            if (term1TypeCode == 4)
-                return ((Functor)Term1).lessThan((Functor)Term2);
+                return ((Functor)Term1).lessThan((Functor)Term2);
-            // Type code is -1 for general objects.  First compare their type names.
+            // Type code is -1 for general objects.  First compare their type names.
-            // Note that this puts Double before Int32 as required by ISO Prolog.
+            // Note that this puts Double before Int32 as required by ISO Prolog.
-            string term1TypeName = Term1.GetType().ToString();
+            string term1TypeName = Term1.GetType().ToString();
-            string term2TypeName = Term2.GetType().ToString();
+            string term2TypeName = Term2.GetType().ToString();
-            if (term1TypeName != term2TypeName)
+            if (term1TypeName != term2TypeName)
-                return term1TypeName.CompareTo(term2TypeName) < 0;
+                return term1TypeName.CompareTo(term2TypeName) < 0;
-            // The terms are the same type name.
+            // The terms are the same type name.
-            if (Term1 is int)
+            if (Term1 is int)
-                return (int)Term1 < (int)Term2;
+                return (int)Term1 < (int)Term2;
-            else if (Term1 is double)
+            else if (Term1 is double)
-                return (double)Term1 < (double)Term2;
+                return (double)Term1 < (double)Term2;
-            else if (Term1 is DateTime)
+            else if (Term1 is DateTime)
-                return (DateTime)Term1 < (DateTime)Term2;
+                return (DateTime)Term1 < (DateTime)Term2;
-            else if (Term1 is String)
+            else if (Term1 is String)
-                return ((String)Term1).CompareTo((String)Term2) < 0;
+                return ((String)Term1).CompareTo((String)Term2) < 0;
-            // Debug: Should we try arrays, etc.?
+            // Debug: Should we try arrays, etc.?
-            if (!Term1.Equals(Term2))
+            if (!Term1.Equals(Term2))
-                // Could be equal or greater than.
+                // Could be equal or greater than.
-                return Term1.GetHashCode() < Term2.GetHashCode();
+                return Term1.GetHashCode() < Term2.GetHashCode();
-            return false;
+            return false;
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Type code is -2 if term is a Variable, 0 if it is an Atom, 
+        /// Type code is -2 if term is a Variable, 0 if it is an Atom, 
-        /// 1 if it is a Functor1, 2 if it is a Functor2, 3 if it is a Functor3, 
+        /// 1 if it is a Functor1, 2 if it is a Functor2, 3 if it is a Functor3, 
-        /// 4 if it is Functor.
+        /// 4 if it is Functor.
-        /// Otherwise, type code is -1.
+        /// Otherwise, type code is -1.
-        /// This does not call YP.getValue(term).
+        /// This does not call YP.getValue(term).
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        private static int getTypeCode(object term)
+        private static int getTypeCode(object term)
-        {
+        {
-            if (term is Variable)
+            if (term is Variable)
-                return -2;
+                return -2;
-            else if (term is Atom)
+            else if (term is Atom)
-                return 0;
+                return 0;
-            else if (term is Functor1)
+            else if (term is Functor1)
-                return 1;
+                return 1;
-            else if (term is Functor2)
+            else if (term is Functor2)
-                return 2;
+                return 2;
-            else if (term is Functor3)
+            else if (term is Functor3)
-                return 3;
+                return 3;
-            else if (term is Functor)
+            else if (term is Functor)
-                return 4;
+                return 4;
-            else
+            else
-                return -1;
+                return -1;
-        }
+        }
-        public static bool termLessThanOrEqual(object Term1, object Term2)
+        public static bool termLessThanOrEqual(object Term1, object Term2)
-        {
+        {
-            if (YP.termEqual(Term1, Term2))
+            if (YP.termEqual(Term1, Term2))
-                return true;
+                return true;
-            return YP.termLessThan(Term1, Term2);
+            return YP.termLessThan(Term1, Term2);
-        }
+        }
-        public static bool termGreaterThan(object Term1, object Term2)
+        public static bool termGreaterThan(object Term1, object Term2)
-        {
+        {
-            return !YP.termLessThanOrEqual(Term1, Term2);
+            return !YP.termLessThanOrEqual(Term1, Term2);
-        }
+        }
-        public static bool termGreaterThanOrEqual(object Term1, object Term2)
+        public static bool termGreaterThanOrEqual(object Term1, object Term2)
-        {
+        {
-            // termLessThan should ensure that it returns false if terms are equal,
+            // termLessThan should ensure that it returns false if terms are equal,
-            //   so that this would return true.
+            //   so that this would return true.
-            return !YP.termLessThan(Term1, Term2);
+            return !YP.termLessThan(Term1, Term2);
-        }
+        }
-        public static int compareTerms(object Term1, object Term2)
+        public static int compareTerms(object Term1, object Term2)
-        {
+        {
-            if (YP.termEqual(Term1, Term2))
+            if (YP.termEqual(Term1, Term2))
-                return 0;
+                return 0;
-            else if (YP.termLessThan(Term1, Term2))
+            else if (YP.termLessThan(Term1, Term2))
-                return -1;
+                return -1;
-            else
+            else
-                return 1;
+                return 1;
-        }
+        }
-        public static bool ground(object Term)
+        public static bool ground(object Term)
-        {
+        {
-            Term = YP.getValue(Term);
+            Term = YP.getValue(Term);
-            if (Term is IUnifiable)
+            if (Term is IUnifiable)
-                return ((IUnifiable)Term).ground();
+                return ((IUnifiable)Term).ground();
-            return true;
+            return true;
-        }
+        }
-        public static IEnumerable<bool> current_op
+        public static IEnumerable<bool> current_op
-            (object Priority, object Specifier, object Operator)
+            (object Priority, object Specifier, object Operator)
-        {
+        {
-            if (_operatorTable == null)
+            if (_operatorTable == null)
-            {
+            {
-                // Initialize.
+                // Initialize.
-                _operatorTable = new List<object[]>();
+                _operatorTable = new List<object[]>();
-                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") });
-                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") });
-                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a(":-") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a(":-") });
-                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a("?-") });
+                _operatorTable.Add(new object[] { 1200, Atom.a("fx"), Atom.a("?-") });
-                _operatorTable.Add(new object[] { 1100, Atom.a("xfy"), Atom.a(";") });
+                _operatorTable.Add(new object[] { 1100, Atom.a("xfy"), Atom.a(";") });
-                _operatorTable.Add(new object[] { 1050, Atom.a("xfy"), Atom.a("->") });
+                _operatorTable.Add(new object[] { 1050, Atom.a("xfy"), Atom.a("->") });
-                _operatorTable.Add(new object[] { 1000, Atom.a("xfy"), Atom.a(",") });
+                _operatorTable.Add(new object[] { 1000, Atom.a("xfy"), Atom.a(",") });
-                _operatorTable.Add(new object[] { 900, Atom.a("fy"), Atom.a("\\+") });
+                _operatorTable.Add(new object[] { 900, Atom.a("fy"), Atom.a("\\+") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("==") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("==") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@<") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=..") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=..") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("is") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("is") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("<") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=<") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a("=<") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">") });
-                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">=") });
+                _operatorTable.Add(new object[] { 700, Atom.a("xfx"), Atom.a(">=") });
-                _operatorTable.Add(new object[] { 600, Atom.a("xfy"), Atom.a(":") });
+                _operatorTable.Add(new object[] { 600, Atom.a("xfy"), Atom.a(":") });
-                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("+") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("+") });
-                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("-") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("-") });
-                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") });
-                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") });
+                _operatorTable.Add(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("*") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("*") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("/") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("/") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("//") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("//") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("rem") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("rem") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("mod") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("mod") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("<<") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a("<<") });
-                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a(">>") });
+                _operatorTable.Add(new object[] { 400, Atom.a("yfx"), Atom.a(">>") });
-                _operatorTable.Add(new object[] { 200, Atom.a("xfx"), Atom.a("**") });
+                _operatorTable.Add(new object[] { 200, Atom.a("xfx"), Atom.a("**") });
-                _operatorTable.Add(new object[] { 200, Atom.a("xfy"), Atom.a("^") });
+                _operatorTable.Add(new object[] { 200, Atom.a("xfy"), Atom.a("^") });
-                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("-") });
+                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("-") });
-                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("\\") });
+                _operatorTable.Add(new object[] { 200, Atom.a("fy"), Atom.a("\\") });
-                // Debug: This is hacked in to run the Prolog test suite until we implement op/3.
+                // Debug: This is hacked in to run the Prolog test suite until we implement op/3.
-                _operatorTable.Add(new object[] { 20, Atom.a("xfx"), Atom.a("<--") });
+                _operatorTable.Add(new object[] { 20, Atom.a("xfx"), Atom.a("<--") });
-            }
+            }
-            object[] args = new object[] { Priority, Specifier, Operator };
+            object[] args = new object[] { Priority, Specifier, Operator };
-            foreach (object[] answer in _operatorTable)
+            foreach (object[] answer in _operatorTable)
-            {
+            {
-                foreach (bool l1 in YP.unifyArrays(args, answer))
+                foreach (bool l1 in YP.unifyArrays(args, answer))
-                    yield return false;
+                    yield return false;
-            }
+            }
-        }
+        }
-        public static IEnumerable<bool> atom_length(object atom, object Length)
+        public static IEnumerable<bool> atom_length(object atom, object Length)
-        {
+        {
-            return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length);
+            return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length);
-        }
+        }
-        public static IEnumerable<bool> atom_concat(object Start, object End, object Whole)
+        public static IEnumerable<bool> atom_concat(object Start, object End, object Whole)
-        {
+        {
-            // Debug: Should implement for var(Start) which is a kind of search.
+            // Debug: Should implement for var(Start) which is a kind of search.
-            // Debug: Should we try to preserve the _declaringClass?
+            // Debug: Should we try to preserve the _declaringClass?
-            return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name +
+            return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name +
-                ((Atom)YP.getValue(End))._name));
+                ((Atom)YP.getValue(End))._name));
-        }
+        }
-        public static IEnumerable<bool> sub_atom
+        public static IEnumerable<bool> sub_atom
-            (object atom, object Before, object Length, object After, object Sub_atom)
+            (object atom, object Before, object Length, object After, object Sub_atom)
-        {
+        {
-            // Debug: Should implement for var(atom) which is a kind of search.
+            // Debug: Should implement for var(atom) which is a kind of search.
-            // Debug: Should we try to preserve the _declaringClass?
+            // Debug: Should we try to preserve the _declaringClass?
-            Atom atomAtom = (Atom)YP.getValue(atom);
+            Atom atomAtom = (Atom)YP.getValue(atom);
-            int beforeInt = YP.convertInt(Before);
+            int beforeInt = YP.convertInt(Before);
-            int lengthInt = YP.convertInt(Length);
+            int lengthInt = YP.convertInt(Length);
-            if (beforeInt < 0)
+            if (beforeInt < 0)
-                throw new Exception("Before must be non-negative");
+                throw new Exception("Before must be non-negative");
-            if (lengthInt < 0)
+            if (lengthInt < 0)
-                throw new Exception("Length must be non-negative");
+                throw new Exception("Length must be non-negative");
-            int afterInt = atomAtom._name.Length - (beforeInt + lengthInt);
+            int afterInt = atomAtom._name.Length - (beforeInt + lengthInt);
-            if (afterInt >= 0)
+            if (afterInt >= 0)
-            {
+            {
-                foreach (bool l1 in YP.unify(After, afterInt))
+                foreach (bool l1 in YP.unify(After, afterInt))
-                {
+                {
-                    foreach (bool l2 in YP.unify
+                    foreach (bool l2 in YP.unify
-                        (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt))))
+                        (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt))))
-                        yield return false;
+                        yield return false;
-                }
+                }
-            }
+            }
-        }
+        }
-        public static IEnumerable<bool> atom_codes(object atom, object List)
+        public static IEnumerable<bool> atom_codes(object atom, object List)
-        {
+        {
-            atom = YP.getValue(atom);
+            atom = YP.getValue(atom);
-            List = YP.getValue(List);
+            List = YP.getValue(List);
-            if (nonvar(atom))
+            if (nonvar(atom))
-            {
+            {
-                string name = ((Atom)atom)._name;
+                string name = ((Atom)atom)._name;
-                object codeList = Atom.NIL;
+                object codeList = Atom.NIL;
-                // Start from the back to make the list.
+                // Start from the back to make the list.
-                for (int i = name.Length - 1; i >= 0; --i)
+                for (int i = name.Length - 1; i >= 0; --i)
-                    codeList = new ListPair((int)name[i], codeList);
+                    codeList = new ListPair((int)name[i], codeList);
-                return YP.unify(List, codeList);
+                return YP.unify(List, codeList);
-            }
+            }
-            {
+            {
-                object[] codeArray = ListPair.toArray(List);
+                object[] codeArray = ListPair.toArray(List);
-                char[] charArray = new char[codeArray.Length];
+                char[] charArray = new char[codeArray.Length];
-                for (int i = 0; i < codeArray.Length; ++i)
+                for (int i = 0; i < codeArray.Length; ++i)
-                    charArray[i] = (char)YP.convertInt(codeArray[i]);
+                    charArray[i] = (char)YP.convertInt(codeArray[i]);
-                return YP.unify(atom, Atom.a(new String(charArray)));
+                return YP.unify(atom, Atom.a(new String(charArray)));
-            }
+            }
-        }
+        }
-        public static IEnumerable<bool> number_codes(object number, object List)
+        public static IEnumerable<bool> number_codes(object number, object List)
-        {
+        {
-            number = YP.getValue(number);
+            number = YP.getValue(number);
-            List = YP.getValue(List);
+            List = YP.getValue(List);
-            if (nonvar(number))
+            if (nonvar(number))
-            {
+            {
-                string numberString = null;
+                string numberString = null;
-                // Try converting to an int first.
+                // Try converting to an int first.
-                int intNumber;
+                int intNumber;
-                if (YP.getInt(number, out intNumber))
+                if (YP.getInt(number, out intNumber))
-                    numberString = intNumber.ToString();
+                    numberString = intNumber.ToString();
-                else
+                else
-                    numberString = YP.doubleToString(YP.convertDouble(number));
+                    numberString = YP.doubleToString(YP.convertDouble(number));
-                object codeList = Atom.NIL;
+                object codeList = Atom.NIL;
-                // Start from the back to make the list.
+                // Start from the back to make the list.
-                for (int i = numberString.Length - 1; i >= 0; --i)
+                for (int i = numberString.Length - 1; i >= 0; --i)
-                    codeList = new ListPair((int)numberString[i], codeList);
+                    codeList = new ListPair((int)numberString[i], codeList);
-                return YP.unify(List, codeList);
+                return YP.unify(List, codeList);
-            }
+            }
-            {
+            {
-                object[] codeArray = ListPair.toArray(List);
+                object[] codeArray = ListPair.toArray(List);
-                char[] charArray = new char[codeArray.Length];
+                char[] charArray = new char[codeArray.Length];
-                for (int i = 0; i < codeArray.Length; ++i)
+                for (int i = 0; i < codeArray.Length; ++i)
-                    charArray[i] = (char)YP.convertInt(codeArray[i]);
+                    charArray[i] = (char)YP.convertInt(codeArray[i]);
-                String numberString = new String(charArray);
+                String numberString = new String(charArray);
-                // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
+                // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
-                try
+                try
-                {
+                {
-                    // Try an int first.
+                    // Try an int first.
-                    return YP.unify(number, Convert.ToInt32(numberString));
+                    return YP.unify(number, Convert.ToInt32(numberString));
-                }
+                }
-                catch (FormatException) { }
+                catch (FormatException) { }
-                return YP.unify(number, Convert.ToDouble(numberString));
+                return YP.unify(number, Convert.ToDouble(numberString));
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// If term is an Atom or functor type, return its name.
+        /// If term is an Atom or functor type, return its name.
-        /// Otherwise, return term.
+        /// Otherwise, return term.
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object getFunctorName(object term)
+        public static object getFunctorName(object term)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is Functor1)
+            if (term is Functor1)
-                return ((Functor1)term)._name;
+                return ((Functor1)term)._name;
-            else if (term is Functor2)
+            else if (term is Functor2)
-                return ((Functor2)term)._name;
+                return ((Functor2)term)._name;
-            else if (term is Functor3)
+            else if (term is Functor3)
-                return ((Functor3)term)._name;
+                return ((Functor3)term)._name;
-            else if (term is Functor)
+            else if (term is Functor)
-                return ((Functor)term)._name;
+                return ((Functor)term)._name;
-            else
+            else
-                return term;
+                return term;
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// If term is an Atom or functor type, return an array of its args.
+        /// If term is an Atom or functor type, return an array of its args.
-        /// Otherwise, return an empty array.
+        /// Otherwise, return an empty array.
-        /// </summary>
+        /// </summary>
-        /// <param name="term"></param>
+        /// <param name="term"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static object[] getFunctorArgs(object term)
+        public static object[] getFunctorArgs(object term)
-        {
+        {
-            term = YP.getValue(term);
+            term = YP.getValue(term);
-            if (term is Functor1)
+            if (term is Functor1)
-            {
+            {
-                Functor1 functor = (Functor1)term;
+                Functor1 functor = (Functor1)term;
-                return new object[] { functor._arg1 };
+                return new object[] { functor._arg1 };
-            }
+            }
-            else if (term is Functor2)
+            else if (term is Functor2)
-            {
+            {
-                Functor2 functor = (Functor2)term;
+                Functor2 functor = (Functor2)term;
-                return new object[] { functor._arg1, functor._arg2 };
+                return new object[] { functor._arg1, functor._arg2 };
-            }
+            }
-            else if (term is Functor3)
+            else if (term is Functor3)
-            {
+            {
-                Functor3 functor = (Functor3)term;
+                Functor3 functor = (Functor3)term;
-                return new object[] { functor._arg1, functor._arg2, functor._arg3 };
+                return new object[] { functor._arg1, functor._arg2, functor._arg3 };
-            }
+            }
-            else if (term is Functor) {
+            else if (term is Functor) {
-                Functor functor = (Functor)term;
+                Functor functor = (Functor)term;
-                return functor._args;
+                return functor._args;
-            }
+            }
-            else
+            else
-                return new object[0];
+                return new object[0];
-        }
+        }
-        public static bool var(object Term)
+        public static bool var(object Term)
-        {
+        {
-            return YP.getValue(Term) is Variable;
+            return YP.getValue(Term) is Variable;
-        }
+        }
-        public static bool nonvar(object Term)
+        public static bool nonvar(object Term)
-        {
+        {
-            return !YP.var(Term);
+            return !YP.var(Term);
-        }
+        }
-        public static bool atom(object Term)
+        public static bool atom(object Term)
-        {
+        {
-            return YP.getValue(Term) is Atom;
+            return YP.getValue(Term) is Atom;
-        }
+        }
-        public static bool number(object Term)
+        public static bool number(object Term)
-        {
+        {
-            Term = getValue(Term);
+            Term = getValue(Term);
-            // Debug: Should exhaustively check for all number types.
+            // Debug: Should exhaustively check for all number types.
-            return Term is int || Term is double;
+            return Term is int || Term is double;
-        }
+        }
-        public static bool atomic(object Term)
+        public static bool atomic(object Term)
-        {
+        {
-            return YP.atom(Term) || YP.number(Term);
+            return YP.atom(Term) || YP.number(Term);
-        }
+        }
-        public static bool compound(object Term)
+        public static bool compound(object Term)
-        {
+        {
-            Term = getValue(Term);
+            Term = getValue(Term);
-            return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor;
+            return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor;
-        }
+        }
-        public static void see(object input)
+        public static void see(object input)
-        {
+        {
-            input = YP.getValue(input);
+            input = YP.getValue(input);
-            if (input is TextReader)
+            if (input is TextReader)
-            {
+            {
-                _inputStream = (TextReader)input;
+                _inputStream = (TextReader)input;
-                return;
+                return;
-            }
+            }
-            else if (input is Atom)
+            else if (input is Atom)
-            {
+            {
-                _inputStream = new StreamReader(((Atom)input)._name);
+                _inputStream = new StreamReader(((Atom)input)._name);
-                return;
+                return;
-            }
+            }
-            else if (input is String)
+            else if (input is String)
-            {
+            {
-                _inputStream = new StreamReader((String)input);
+                _inputStream = new StreamReader((String)input);
-                return;
+                return;
-            }
+            }
-            else
+            else
-                throw new InvalidOperationException("Can't open stream for " + input);
+                throw new InvalidOperationException("Can't open stream for " + input);
-        }
+        }
-        public static void seen()
+        public static void seen()
-        {
+        {
-            if (_inputStream == Console.In)
+            if (_inputStream == Console.In)
-                return;
+                return;
-            _inputStream.Close();
+            _inputStream.Close();
-            _inputStream = Console.In;
+            _inputStream = Console.In;
-        }
+        }
-        public static void tell(object output)
+        public static void tell(object output)
-        {
+        {
-            output = YP.getValue(output);
+            output = YP.getValue(output);
-            if (output is TextWriter)
+            if (output is TextWriter)
-            {
+            {
-                _outputStream = (TextWriter)output;
+                _outputStream = (TextWriter)output;
-                return;
+                return;
-            }
+            }
-            else if (output is Atom)
+            else if (output is Atom)
-            {
+            {
-                _outputStream = new StreamWriter(((Atom)output)._name);
+                _outputStream = new StreamWriter(((Atom)output)._name);
-                return;
+                return;
-            }
+            }
-            else if (output is String)
+            else if (output is String)
-            {
+            {
-                _outputStream = new StreamWriter((String)output);
+                _outputStream = new StreamWriter((String)output);
-                return;
+                return;
-            }
+            }
-            else
+            else
-                throw new InvalidOperationException("Can't open stream for " + output);
+                throw new InvalidOperationException("Can't open stream for " + output);
-        }
+        }
-        public static void told()
+        public static void told()
-        {
+        {
-            if (_outputStream == Console.Out)
+            if (_outputStream == Console.Out)
-                return;
+                return;
-            _outputStream.Close();
+            _outputStream.Close();
-            _outputStream = Console.Out;
+            _outputStream = Console.Out;
-        }
+        }
-        public static void write(object x)
+        public static void write(object x)
-        {
+        {
-            x = YP.getValue(x);
+            x = YP.getValue(x);
-            if (x is double)
+            if (x is double)
-                _outputStream.Write(doubleToString((double)x));
+                _outputStream.Write(doubleToString((double)x));
-            else
+            else
-                _outputStream.Write(x.ToString());
+                _outputStream.Write(x.ToString());
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Format x as a string, making sure that it will parse as an int later.  I.e., for 1.0, don't just
+        /// Format x as a string, making sure that it will parse as an int later.  I.e., for 1.0, don't just
-        /// use "1" which will parse as an int.
+        /// use "1" which will parse as an int.
-        /// </summary>
+        /// </summary>
-        /// <param name="x"></param>
+        /// <param name="x"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        private static string doubleToString(double x)
+        private static string doubleToString(double x)
-        {
+        {
-            string xString = x.ToString();
+            string xString = x.ToString();
-            // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
+            // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception?
-            try
+            try
-            {
+            {
-                Convert.ToInt32(xString);
+                Convert.ToInt32(xString);
-                // The string will parse as an int, not a double, so re-format so that it does.
+                // The string will parse as an int, not a double, so re-format so that it does.
-                // Use float if possible, else exponential if it would be too big.
+                // Use float if possible, else exponential if it would be too big.
-                return x.ToString(x >= 100000.0 ? "E1" : "f1");
+                return x.ToString(x >= 100000.0 ? "E1" : "f1");
-            }
+            }
-            catch (FormatException)
+            catch (FormatException)
-            {
+            {
-                // Assume it will parse as a double.
+                // Assume it will parse as a double.
-            }
+            }
-            return xString;
+            return xString;
-        }
+        }
-        public static void put_code(object x)
+        public static void put_code(object x)
-        {
+        {
-            _outputStream.Write((char)YP.convertInt(x));
+            _outputStream.Write((char)YP.convertInt(x));
-        }
+        }
-        public static void nl()
+        public static void nl()
-        {
+        {
-            _outputStream.WriteLine();
+            _outputStream.WriteLine();
-        }
+        }
-        public static IEnumerable<bool> get_code(object code)
+        public static IEnumerable<bool> get_code(object code)
-        {
+        {
-            return YP.unify(code, _inputStream.Read());
+            return YP.unify(code, _inputStream.Read());
-        }
+        }
-        public static void assertFact(Atom name, object[] values)
+        public static void assertFact(Atom name, object[] values)
-        {
+        {
-            NameArity nameArity = new NameArity(name, values.Length);
+            NameArity nameArity = new NameArity(name, values.Length);
-            List<IClause> clauses;
+            List<IClause> clauses;
-            IndexedAnswers indexedAnswers;
+            IndexedAnswers indexedAnswers;
-            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
+            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
-            {
+            {
-                // Create an IndexedAnswers as the first clause of the predicate.                
+                // Create an IndexedAnswers as the first clause of the predicate.                
-                _predicatesStore[nameArity] = (clauses = new List<IClause>());
+                _predicatesStore[nameArity] = (clauses = new List<IClause>());
-                clauses.Add(indexedAnswers = new IndexedAnswers());
+                clauses.Add(indexedAnswers = new IndexedAnswers());
-            }
+            }
-            else
+            else
-            {
+            {
-                indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers;
+                indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers;
-                if (indexedAnswers == null)
+                if (indexedAnswers == null)
-                    // The latest clause is not an IndexedAnswers, so add one.
+                    // The latest clause is not an IndexedAnswers, so add one.
-                    clauses.Add(indexedAnswers = new IndexedAnswers());
+                    clauses.Add(indexedAnswers = new IndexedAnswers());
-            }
+            }
-            indexedAnswers.addAnswer(values);
+            indexedAnswers.addAnswer(values);
-        }
+        }
-        public static IEnumerable<bool> matchFact(Atom name, object[] arguments)
+        public static IEnumerable<bool> matchFact(Atom name, object[] arguments)
-        {
+        {
-            List<IClause> clauses;
+            List<IClause> clauses;
-            if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses))
+            if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses))
-                throw new UndefinedPredicateException
+                throw new UndefinedPredicateException
-                    ("Undefined fact: " + name + "/" + arguments.Length, name, 
+                    ("Undefined fact: " + name + "/" + arguments.Length, name, 
-                    arguments.Length);
+                    arguments.Length);
-            if (clauses.Count == 1)
+            if (clauses.Count == 1)
-                // Usually there is only one clause, so return it without needing to wrap it in an iterator.
+                // Usually there is only one clause, so return it without needing to wrap it in an iterator.
-                return clauses[0].match(arguments);
+                return clauses[0].match(arguments);
-            else
+            else
-                return matchAllClauses(clauses, arguments);
+                return matchAllClauses(clauses, arguments);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Call match(arguments) for each IClause in clauses.  We make this a separate
+        /// Call match(arguments) for each IClause in clauses.  We make this a separate
-        /// function so that matchFact itself does not need to be an iterator object.
+        /// function so that matchFact itself does not need to be an iterator object.
-        /// </summary>
+        /// </summary>
-        /// <param name="clauses"></param>
+        /// <param name="clauses"></param>
-        /// <param name="arguments"></param>
+        /// <param name="arguments"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        private static IEnumerable<bool> matchAllClauses(List<IClause> clauses, object[] arguments)
+        private static IEnumerable<bool> matchAllClauses(List<IClause> clauses, object[] arguments)
-        {
+        {
-            foreach (IClause clause in clauses)
+            foreach (IClause clause in clauses)
-            {
+            {
-                foreach (bool lastCall in clause.match(arguments))
+                foreach (bool lastCall in clause.match(arguments))
-                    yield return false;
+                    yield return false;
-            }
+            }
-        }
+        }
-        public static void retractFact(Atom name, object[] arguments)
+        public static void retractFact(Atom name, object[] arguments)
-        {
+        {
-            NameArity nameArity = new NameArity(name, arguments.Length);
+            NameArity nameArity = new NameArity(name, arguments.Length);
-            List<IClause> clauses;
+            List<IClause> clauses;
-            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
+            if (!_predicatesStore.TryGetValue(nameArity, out clauses))
-                // Can't find, so ignore.
+                // Can't find, so ignore.
-                return;
+                return;
-            foreach (object arg in arguments)
+            foreach (object arg in arguments)
-            {
+            {
-                if (!YP.var(arg))
+                if (!YP.var(arg))
-                    throw new InvalidOperationException("All arguments must be unbound");
+                    throw new InvalidOperationException("All arguments must be unbound");
-            }
+            }
-            // Set to a fresh empty IndexedAnswers.
+            // Set to a fresh empty IndexedAnswers.
-            _predicatesStore[nameArity] = (clauses = new List<IClause>());
+            _predicatesStore[nameArity] = (clauses = new List<IClause>());
-            clauses.Add(new IndexedAnswers());
+            clauses.Add(new IndexedAnswers());
-        }
+        }
-        public static IEnumerable<bool> current_predicate(object NameSlashArity)
+        public static IEnumerable<bool> current_predicate(object NameSlashArity)
-        {
+        {
-            NameSlashArity = YP.getValue(NameSlashArity);
+            NameSlashArity = YP.getValue(NameSlashArity);
-            // First check if Name and Arity are nonvar so we can do a direct lookup.
+            // First check if Name and Arity are nonvar so we can do a direct lookup.
-            if (YP.ground(NameSlashArity))
+            if (YP.ground(NameSlashArity))
-            {
+            {
-                if (NameSlashArity is Functor2)
+                if (NameSlashArity is Functor2)
-                {
+                {
-                    Functor2 NameArityFunctor = (Functor2)NameSlashArity;
+                    Functor2 NameArityFunctor = (Functor2)NameSlashArity;
-                    if (NameArityFunctor._name == Atom.SLASH)
+                    if (NameArityFunctor._name == Atom.SLASH)
-                    {
+                    {
-                        if (_predicatesStore.ContainsKey(new NameArity
+                        if (_predicatesStore.ContainsKey(new NameArity
-                             ((Atom)YP.getValue(NameArityFunctor._arg1),
+                             ((Atom)YP.getValue(NameArityFunctor._arg1),
-                              (int)YP.getValue(NameArityFunctor._arg2))))
+                              (int)YP.getValue(NameArityFunctor._arg2))))
-                            // The predicate is defined.
+                            // The predicate is defined.
-                            yield return false;
+                            yield return false;
-                    }
+                    }
-                }
+                }
-                yield break;
+                yield break;
-            }
+            }
-            foreach (NameArity key in _predicatesStore.Keys)
+            foreach (NameArity key in _predicatesStore.Keys)
-            {
+            {
-                foreach (bool l1 in YP.unify
+                foreach (bool l1 in YP.unify
-                    (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity))
+                    (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity))
-                    yield return false;
+                    yield return false;
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the 
+        /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the 
-        /// declaringClass, using arguments from YP.getFunctorArgs(Goal).
+        /// declaringClass, using arguments from YP.getFunctorArgs(Goal).
-        /// Note that Goal must be a simple functor, not a complex expression.
+        /// Note that Goal must be a simple functor, not a complex expression.
-        /// If not found, this throws UndefinedPredicateException.
+        /// If not found, this throws UndefinedPredicateException.
-        /// </summary>
+        /// </summary>
-        /// <param name="Goal"></param>
+        /// <param name="Goal"></param>
-        /// <param name="contextClass">the class for looking up default function references</param>
+        /// <param name="contextClass">the class for looking up default function references</param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static IEnumerable<bool> getIterator(object Goal, Type declaringClass)
+        public static IEnumerable<bool> getIterator(object Goal, Type declaringClass)
-        {
+        {
-#if true
+#if true
-            List<Variable> variableSetList = new List<Variable>();
+            List<Variable> variableSetList = new List<Variable>();
-            addUniqueVariables(Goal, variableSetList);
+            addUniqueVariables(Goal, variableSetList);
-            Variable[] variableSet = variableSetList.ToArray();
+            Variable[] variableSet = variableSetList.ToArray();
-            object Head = Functor.make("function", variableSet);
+            object Head = Functor.make("function", variableSet);
-            object Rule = new Functor2(Atom.RULE, Head, Goal);
+            object Rule = new Functor2(Atom.RULE, Head, Goal);
-            object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL));
+            object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL));
-            StringWriter functionCode = new StringWriter();
+            StringWriter functionCode = new StringWriter();
-            TextWriter saveOutputStream = _outputStream;
+            TextWriter saveOutputStream = _outputStream;
-            try
+            try
-            {
+            {
-                tell(functionCode);
+                tell(functionCode);
-                Variable FunctionCode = new Variable();
+                Variable FunctionCode = new Variable();
-                foreach (bool l1 in YPCompiler.makeFunctionPseudoCode(RuleList, FunctionCode))
+                foreach (bool l1 in YPCompiler.makeFunctionPseudoCode(RuleList, FunctionCode))
-                {
+                {
-                    if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass")))
+                    if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass")))
-                        // Ignore getDeclaringClass since we have access to the one passed in.
+                        // Ignore getDeclaringClass since we have access to the one passed in.
-                        continue;
+                        continue;
-                    // Debug: should check if FunctionCode is a single call.
+                    // Debug: should check if FunctionCode is a single call.
-                    YPCompiler.convertFunctionCSharp(FunctionCode);
+                    YPCompiler.convertFunctionCSharp(FunctionCode);
-                }
+                }
-                told();
+                told();
-            }
+            }
-            finally
+            finally
-            {
+            {
-                // Restore after calling tell.
+                // Restore after calling tell.
-                _outputStream = saveOutputStream;
+                _outputStream = saveOutputStream;
-            }
+            }
-            return YPCompiler.compileAnonymousFunction
+            return YPCompiler.compileAnonymousFunction
-                (functionCode.ToString(), variableSet.Length, declaringClass).match(variableSet);
+                (functionCode.ToString(), variableSet.Length, declaringClass).match(variableSet);
-#else
+#else
-            Goal = YP.getValue(Goal);
+            Goal = YP.getValue(Goal);
-            Atom name;
+            Atom name;
-            object[] args;
+            object[] args;
-            while (true)
+            while (true)
-            {
+            {
-                name = (Atom)YP.getFunctorName(Goal);
+                name = (Atom)YP.getFunctorName(Goal);
-                args = YP.getFunctorArgs(Goal);
+                args = YP.getFunctorArgs(Goal);
-                if (name == Atom.HAT && args.Length == 2)
+                if (name == Atom.HAT && args.Length == 2)
-                    // Assume this is called from a bagof operation.  Skip the leading qualifiers.
+                    // Assume this is called from a bagof operation.  Skip the leading qualifiers.
-                    Goal = YP.getValue(((Functor2)Goal)._arg2);
+                    Goal = YP.getValue(((Functor2)Goal)._arg2);
-                else
+                else
-                    break;
+                    break;
-            }
+            }
-            try
+            try
-            {
+            {
-                return (IEnumerable<bool>)declaringClass.InvokeMember
+                return (IEnumerable<bool>)declaringClass.InvokeMember
-                  (name._name, BindingFlags.InvokeMethod, null, null, args);
+                  (name._name, BindingFlags.InvokeMethod, null, null, args);
-            }
+            }
-            catch (TargetInvocationException exception)
+            catch (TargetInvocationException exception)
-            {
+            {
-                throw exception.InnerException;
+                throw exception.InnerException;
-            }
+            }
-            catch (MissingMethodException)
+            catch (MissingMethodException)
-            {
+            {
-                throw new UndefinedPredicateException
+                throw new UndefinedPredicateException
-                    ("Cannot find predicate function: " + name + "/" + args.Length + " in " +
+                    ("Cannot find predicate function: " + name + "/" + args.Length + " in " +
-                     declaringClass.FullName, name, args.Length);
+                     declaringClass.FullName, name, args.Length);
-            }
+            }
-#endif
+#endif
-        }
+        }
-        public static void throwException(object Term)
+        public static void throwException(object Term)
-        {
+        {
-            throw new PrologException(Term);
+            throw new PrologException(Term);
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// script_event calls hosting script with events as a callback method.
+        /// script_event calls hosting script with events as a callback method.
-        /// </summary>
+        /// </summary>
-        /// <param name="script_event"></param>
+        /// <param name="script_event"></param>
-        /// <param name="script_params"></param>
+        /// <param name="script_params"></param>
-        /// <returns></returns>
+        /// <returns></returns>
-        public static void script_event(object script_event, object script_params)
+        public static void script_event(object script_event, object script_params)
-        {
+        {
-            string function = ((Atom)YP.getValue(script_event))._name;
+            string function = ((Atom)YP.getValue(script_event))._name;
-            object[] array = ListPair.toArray(script_params);
+            object[] array = ListPair.toArray(script_params);
-            if (array == null)
+            if (array == null)
-                return; // YP.fail();
+                return; // YP.fail();
-            if (array.Length > 1)
+            if (array.Length > 1)
-            {
+            {
-                //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue
+                //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue
-                //(localID, itemID, function, array);
+                //(localID, itemID, function, array);
-                // sortArray(array);
+                // sortArray(array);
-            }
+            }
-            //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
+            //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array));
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// An enumerator that does zero loops.
+        /// An enumerator that does zero loops.
-        /// </summary>
+        /// </summary>
-        private class Fail : IEnumerator<bool>, IEnumerable<bool>
+        private class Fail : IEnumerator<bool>, IEnumerable<bool>
-        {
+        {
-            public bool MoveNext()
+            public bool MoveNext()
-            {
+            {
-                return false;
+                return false;
-            }
+            }
-            public IEnumerator<bool> GetEnumerator()
+            public IEnumerator<bool> GetEnumerator()
-            {
+            {
-                return (IEnumerator<bool>)this;
+                return (IEnumerator<bool>)this;
-            }
+            }
-            IEnumerator IEnumerable.GetEnumerator()
+            IEnumerator IEnumerable.GetEnumerator()
-            {
+            {
-                return GetEnumerator();
+                return GetEnumerator();
-            }
+            }
-            public bool Current
+            public bool Current
-            {
+            {
-                get { return true; }
+                get { return true; }
-            }
+            }
-            object IEnumerator.Current
+            object IEnumerator.Current
-            {
+            {
-                get { return true; }
+                get { return true; }
-            }
+            }
-            public void Dispose()
+            public void Dispose()
-            {
+            {
-            }
+            }
-            public void Reset()
+            public void Reset()
-            {
+            {
-                throw new NotImplementedException();
+                throw new NotImplementedException();
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// An enumerator that does one iteration.
+        /// An enumerator that does one iteration.
-        /// </summary>
+        /// </summary>
-        private class Succeed : IEnumerator<bool>, IEnumerable<bool>
+        private class Succeed : IEnumerator<bool>, IEnumerable<bool>
-        {
+        {
-            private bool _didIteration = false;
+            private bool _didIteration = false;
-            public bool MoveNext()
+            public bool MoveNext()
-            {
+            {
-                if (!_didIteration)
+                if (!_didIteration)
-                {
+                {
-                    _didIteration = true;
+                    _didIteration = true;
-                    return true;
+                    return true;
-                }
+                }
-                else
+                else
-                    return false;
+                    return false;
-            }
+            }
-            public IEnumerator<bool> GetEnumerator()
+            public IEnumerator<bool> GetEnumerator()
-            {
+            {
-                return (IEnumerator<bool>)this;
+                return (IEnumerator<bool>)this;
-            }
+            }
-            IEnumerator IEnumerable.GetEnumerator()
+            IEnumerator IEnumerable.GetEnumerator()
-            {
+            {
-                return GetEnumerator();
+                return GetEnumerator();
-            }
+            }
-            public bool Current
+            public bool Current
-            {
+            {
-                get { return false; }
+                get { return false; }
-            }
+            }
-            object IEnumerator.Current
+            object IEnumerator.Current
-            {
+            {
-                get { return false; }
+                get { return false; }
-            }
+            }
-            public void Dispose()
+            public void Dispose()
-            {
+            {
-            }
+            }
-            public void Reset()
+            public void Reset()
-            {
+            {
-                throw new NotImplementedException();
+                throw new NotImplementedException();
-            }
+            }
-        }
+        }
-        /// <summary>
+        /// <summary>
-        /// An enumerator that repeats forever.
+        /// An enumerator that repeats forever.
-        /// </summary>
+        /// </summary>
-        private class Repeat : IEnumerator<bool>, IEnumerable<bool>
+        private class Repeat : IEnumerator<bool>, IEnumerable<bool>
-        {
+        {
-            public bool MoveNext()
+            public bool MoveNext()
-            {
+            {
-                return true;
+                return true;
-            }
+            }
-            public IEnumerator<bool> GetEnumerator()
+            public IEnumerator<bool> GetEnumerator()
-            {
+            {
-                return (IEnumerator<bool>)this;
+                return (IEnumerator<bool>)this;
-            }
+            }
-            IEnumerator IEnumerable.GetEnumerator()
+            IEnumerator IEnumerable.GetEnumerator()
-            {
+            {
-                return GetEnumerator();
+                return GetEnumerator();
-            }
+            }
-            public bool Current
+            public bool Current
-            {
+            {
-                get { return false; }
+                get { return false; }
-            }
+            }
-            object IEnumerator.Current
+            object IEnumerator.Current
-            {
+            {
-                get { return false; }
+                get { return false; }
-            }
+            }
-            public void Dispose()
+            public void Dispose()
-            {
+            {
-            }
+            }
-            public void Reset()
+            public void Reset()
-            {
+            {
-                throw new NotImplementedException();
+                throw new NotImplementedException();
-            }
+            }
-        }
+        }
-    }
+    }
-}
+}