/* * Copyright (C) 2007-2008, Jeff Thompson * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 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 * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ using System; using System.Collections; using System.Collections.Generic; using System.IO; using System.Reflection; using System.Net.Sockets; using System.Text; using System.Text.RegularExpressions; using log4net; namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog { /// <summary> /// YP has static methods for general functions in Yield Prolog such as <see cref="getValue"/> /// and <see cref="unify"/>. /// </summary> public class YP { private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static Fail _fail = new Fail(); private static Repeat _repeat = new Repeat(); private static Dictionary<NameArity, List<IClause>> _predicatesStore = new Dictionary<NameArity, List<IClause>>(); private static TextWriter _outputStream = System.Console.Out; private static TextReader _inputStream = System.Console.In; private static IndexedAnswers _operatorTable = null; private static Dictionary<string, object> _prologFlags = new Dictionary<string, object>(); public const int MAX_ARITY = 255; /// <summary> /// An IClause is used so that dynamic predicates can call match. /// </summary> public interface IClause { IEnumerable<bool> match(object[] args); IEnumerable<bool> clause(object Head, object Body); } /// <summary> /// If value is a Variable, then return its getValue. Otherwise, just /// return value. You should call YP.getValue on any object that /// may be a Variable to get the value to pass to other functions in /// your system that are not part of Yield Prolog, such as math functions /// or file I/O. /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html /// </summary> /// <param name="value"></param> /// <returns></returns> public static object getValue(object value) { if (value is Variable) return ((Variable)value).getValue(); else return value; } /// <summary> /// If arg1 or arg2 is an object with a unify method (such as Variable or /// Functor) then just call its unify with the other argument. The object's /// unify method will bind the values or check for equals as needed. /// Otherwise, both arguments are "normal" (atomic) values so if they /// are equal then succeed (yield once), else fail (don't yield). /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html /// </summary> /// <param name="arg1"></param> /// <param name="arg2"></param> /// <returns></returns> public static IEnumerable<bool> unify(object arg1, object arg2) { arg1 = getValue(arg1); arg2 = getValue(arg2); if (arg1 is IUnifiable) return ((IUnifiable)arg1).unify(arg2); else if (arg2 is IUnifiable) return ((IUnifiable)arg2).unify(arg1); else { // Arguments are "normal" types. if (arg1.Equals(arg2)) return new Succeed(); else return _fail; } } /// <summary> /// This is used for the lookup key in _factStore. /// </summary> public struct NameArity { public readonly Atom _name; public readonly int _arity; public NameArity(Atom name, int arity) { _name = name; _arity = arity; } public override bool Equals(object obj) { if (obj is NameArity) { NameArity nameArity = (NameArity)obj; return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity); } else { return false; } } public override int GetHashCode() { return _name.GetHashCode() ^ _arity.GetHashCode(); } } /// <summary> /// Convert term to an int. /// If term is a single-element List, use its first element /// (to handle the char types like "a"). /// If can't convert, throw a PrologException for type_error evaluable (because this is only /// called from arithmetic functions). /// </summary> /// <param name="term"></param> /// <returns></returns> public static int convertInt(object term) { term = YP.getValue(term); if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && YP.getValue(((Functor2)term)._arg2) == Atom.NIL) // Assume it is a char type like "a". term = YP.getValue(((Functor2)term)._arg1); if (term is Variable) throw new PrologException(Atom.a("instantiation_error"), "Expected a number but the argument is an unbound variable"); try { return (int)term; } catch (InvalidCastException) { throw new PrologException (new Functor2 ("type_error", Atom.a("evaluable"), new Functor2(Atom.SLASH, getFunctorName(term), getFunctorArgs(term).Length)), "Term must be an integer"); } } /// <summary> /// 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 /// (to handle the char types like "a"). /// If can't convert, throw a PrologException for type_error evaluable (because this is only /// called from arithmetic functions). /// </summary> /// <param name="term"></param> /// <returns></returns> public static double convertDouble(object term) { term = YP.getValue(term); if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && YP.getValue(((Functor2)term)._arg2) == Atom.NIL) // Assume it is a char type like "a". term = YP.getValue(((Functor2)term)._arg1); if (term is Variable) throw new PrologException(Atom.a("instantiation_error"), "Expected a number but the argument is an unbound variable"); try { return Convert.ToDouble(term); } catch (InvalidCastException) { throw new PrologException (new Functor2 ("type_error", Atom.a("evaluable"), new Functor2(Atom.SLASH, getFunctorName(term), getFunctorArgs(term).Length)), "Term must be an integer"); } } /// <summary> /// If term is an integer, set intTerm. /// 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. /// We use a success return value because throwing an exception is inefficient. /// </summary> /// <param name="term"></param> /// <returns></returns> public static bool getInt(object term, out int intTerm) { term = YP.getValue(term); if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && YP.getValue(((Functor2)term)._arg2) == Atom.NIL) // Assume it is a char type like "a". term = YP.getValue(((Functor2)term)._arg1); if (term is int) { intTerm = (int)term; return true; } intTerm = 0; return false; } public static bool equal(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x == (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) == YP.convertDouble(y); } public static bool notEqual(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x != (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) != YP.convertDouble(y); } public static bool greaterThan(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x > (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) > YP.convertDouble(y); } public static bool lessThan(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x < (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) < YP.convertDouble(y); } public static bool greaterThanOrEqual(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x >= (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) >= YP.convertDouble(y); } public static bool lessThanOrEqual(object x, object y) { x = YP.getValue(x); if (x is DateTime) return (DateTime)x <= (DateTime)YP.getValue(y); // Assume convertDouble converts an int to a double perfectly. return YP.convertDouble(x) <= YP.convertDouble(y); } public static object negate(object x) { int intX; if (getInt(x, out intX)) return -intX; return -convertDouble(x); } public static object abs(object x) { int intX; if (getInt(x, out intX)) return Math.Abs(intX); return Math.Abs(convertDouble(x)); } public static object sign(object x) { int intX; if (getInt(x, out intX)) return Math.Sign(intX); return Math.Sign(convertDouble(x)); } // Use toFloat instead of float because it is a reserved keyword. public static object toFloat(object x) { return convertDouble(x); } /// <summary> /// The ISO standard returns an int. /// </summary> /// <param name="x"></param> /// <returns></returns> public static object floor(object x) { return (int)Math.Floor(convertDouble(x)); } /// <summary> /// The ISO standard returns an int. /// </summary> /// <param name="x"></param> /// <returns></returns> public static object truncate(object x) { return (int)Math.Truncate(convertDouble(x)); } /// <summary> /// The ISO standard returns an int. /// </summary> /// <param name="x"></param> /// <returns></returns> public static object round(object x) { return (int)Math.Round(convertDouble(x)); } /// <summary> /// The ISO standard returns an int. /// </summary> /// <param name="x"></param> /// <returns></returns> public static object ceiling(object x) { return (int)Math.Ceiling(convertDouble(x)); } public static object sin(object x) { return Math.Sin(YP.convertDouble(x)); } public static object cos(object x) { return Math.Cos(YP.convertDouble(x)); } public static object atan(object x) { return Math.Atan(YP.convertDouble(x)); } public static object exp(object x) { return Math.Exp(YP.convertDouble(x)); } public static object log(object x) { return Math.Log(YP.convertDouble(x)); } public static object sqrt(object x) { return Math.Sqrt(convertDouble(x)); } public static object bitwiseComplement(object x) { return ~YP.convertInt(x); } public static object add(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return intX + intY; return convertDouble(x) + convertDouble(y); } public static object subtract(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return intX - intY; return convertDouble(x) - convertDouble(y); } public static object multiply(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return intX * intY; return convertDouble(x) * convertDouble(y); } /// <summary> /// Return floating point, even if both arguments are integer. /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <returns></returns> public static object divide(object x, object y) { return convertDouble(x) / convertDouble(y); } public static object intDivide(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return intX / intY; // Still allow passing a double, but treat as an int. return (int)convertDouble(x) / (int)convertDouble(y); } public static object mod(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return intX % intY; // Still allow passing a double, but treat as an int. return (int)convertDouble(x) % (int)convertDouble(y); } public static object pow(object x, object y) { return Math.Pow(YP.convertDouble(x), YP.convertDouble(y)); } public static object bitwiseShiftRight(object x, object y) { return YP.convertInt(x) >> YP.convertInt(y); } public static object bitwiseShiftLeft(object x, object y) { return YP.convertInt(x) << YP.convertInt(y); } public static object bitwiseAnd(object x, object y) { return YP.convertInt(x) & YP.convertInt(y); } public static object bitwiseOr(object x, object y) { return YP.convertInt(x) | YP.convertInt(y); } public static object min(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return Math.Min(intX, intY); return Math.Min(convertDouble(x), convertDouble(y)); } public static object max(object x, object y) { int intX, intY; if (getInt(x, out intX) && getInt(y, out intY)) return Math.Max(intX, intY); return Math.Max(convertDouble(x), convertDouble(y)); } public static IEnumerable<bool> copy_term(object inTerm, object outTerm) { return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore())); } public static void addUniqueVariables(object term, List<Variable> variableSet) { term = YP.getValue(term); if (term is IUnifiable) ((IUnifiable)term).addUniqueVariables(variableSet); } public static object makeCopy(object term, Variable.CopyStore copyStore) { term = YP.getValue(term); if (term is IUnifiable) return ((IUnifiable)term).makeCopy(copyStore); else // term is a "normal" type. Assume it is ground. return term; } /// <summary> /// Sort the array in place according to termLessThan. This does not remove duplicates /// </summary> /// <param name="array"></param> public static void sortArray(object[] array) { Array.Sort(array, YP.compareTerms); } /// <summary> /// Sort the array in place according to termLessThan. This does not remove duplicates /// </summary> /// <param name="array"></param> public static void sortArray(List<object> array) { array.Sort(YP.compareTerms); } /// <summary> /// Sort List according to termLessThan, remove duplicates and unify with Sorted. /// </summary> /// <param name="List"></param> /// <param name="Sorted"></param> /// <returns></returns> public static IEnumerable<bool> sort(object List, object Sorted) { object[] array = ListPair.toArray(List); if (array == null) return YP.fail(); if (array.Length > 1) sortArray(array); return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); } /// <summary> /// Use YP.unify to unify each of the elements of the two arrays, and yield /// once if they all unify. /// </summary> /// <param name="array1"></param> /// <param name="array2"></param> /// <returns></returns> public static IEnumerable<bool> unifyArrays(object[] array1, object[] array2) { if (array1.Length != array2.Length) yield break; IEnumerator<bool>[] iterators = new IEnumerator<bool>[array1.Length]; bool gotMatch = true; int nIterators = 0; // Try to bind all the arguments. for (int i = 0; i < array1.Length; ++i) { IEnumerator<bool> iterator = YP.unify(array1[i], array2[i]).GetEnumerator(); iterators[nIterators++] = iterator; // MoveNext() is true if YP.unify succeeds. if (!iterator.MoveNext()) { gotMatch = false; break; } } try { if (gotMatch) yield return false; } finally { // Manually finalize all the iterators. for (int i = 0; i < nIterators; ++i) iterators[i].Dispose(); } } /// <summary> /// Return an iterator (which you can use in a for-in loop) which does /// zero iterations. This returns a pre-existing iterator which is /// more efficient than letting the compiler generate a new one. /// </summary> /// <returns></returns> public static IEnumerable<bool> fail() { return _fail; } /// <summary> /// Return an iterator (which you can use in a for-in loop) which does /// one iteration. This returns a pre-existing iterator which is /// more efficient than letting the compiler generate a new one. /// </summary> /// <returns></returns> public static IEnumerable<bool> succeed() { return new Succeed(); } /// <summary> /// Return an iterator (which you can use in a for-in loop) which repeats /// indefinitely. This returns a pre-existing iterator which is /// more efficient than letting the compiler generate a new one. /// </summary> /// <returns></returns> public static IEnumerable<bool> repeat() { return _repeat; } // disable warning on l1, don't see how we can // code this differently #pragma warning disable 0168, 0219 public static IEnumerable<bool> univ(object Term, object List) { Term = YP.getValue(Term); List = YP.getValue(List); if (nonvar(Term)) return YP.unify(new ListPair (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List); Variable Name = new Variable(); Variable ArgList = new Variable(); foreach (bool l1 in new ListPair(Name, ArgList).unify(List)) { object[] args = ListPair.toArray(ArgList); if (args == null) throw new PrologException (new Functor2("type_error", Atom.a("list"), ArgList), "Expected a list. Got: " + ArgList.getValue()); if (args.Length == 0) // Return the Name, even if it is not an Atom. return YP.unify(Term, Name); if (args.Length > MAX_ARITY) throw new PrologException (new Functor1("representation_error", Atom.a("max_arity")), "Functor arity " + args.Length + " may not be greater than " + MAX_ARITY); if (!atom(Name)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Name), "Expected an atom. Got: " + Name.getValue()); return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args)); } return YP.fail(); } public static IEnumerable<bool> functor(object Term, object FunctorName, object Arity) { Term = YP.getValue(Term); FunctorName = YP.getValue(FunctorName); Arity = YP.getValue(Arity); if (Term is Variable) { if (FunctorName is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 2 FunctorName is an unbound variable"); if (Arity is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 3 Arity is an unbound variable"); if (!(Arity is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), Arity), "Arity is not an integer"); if (!YP.atomic(FunctorName)) throw new PrologException (new Functor2("type_error", Atom.a("atomic"), FunctorName), "FunctorName is not atomic"); if ((int)Arity < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), Arity), "Arity may not be less than zero"); else if ((int)Arity == 0) { // Just unify Term with the atomic FunctorName. foreach (bool l1 in YP.unify(Term, FunctorName)) yield return false; } else { if ((int)Arity > MAX_ARITY) throw new PrologException (new Functor1("representation_error", Atom.a("max_arity")), "Functor arity " + Arity + " may not be greater than " + MAX_ARITY); if (!(FunctorName is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), FunctorName), "FunctorName is not an atom"); // Construct a functor with unbound variables. object[] args = new object[(int)Arity]; for (int i = 0; i < args.Length; ++i) args[i] = new Variable(); foreach (bool l1 in YP.unify(Term, Functor.make((Atom)FunctorName, args))) yield return false; } } else { foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term))) { foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length)) yield return false; } } } public static IEnumerable<bool> arg(object ArgNumber, object Term, object Value) { if (var(ArgNumber)) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 ArgNumber is an unbound variable"); int argNumberInt; if (!getInt(ArgNumber, out argNumberInt)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), ArgNumber), "Arg 1 ArgNumber must be integer"); if (argNumberInt < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), argNumberInt), "ArgNumber may not be less than zero"); if (YP.var(Term)) throw new PrologException(Atom.a("instantiation_error"), "Arg 2 Term is an unbound variable"); if (!YP.compound(Term)) throw new PrologException (new Functor2("type_error", Atom.a("compound"), Term), "Arg 2 Term must be compound"); object[] termArgs = YP.getFunctorArgs(Term); // Silently fail if argNumberInt is out of range. if (argNumberInt >= 1 && argNumberInt <= termArgs.Length) { // The first ArgNumber is at 1, not 0. foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1])) yield return false; } } public static bool termEqual(object Term1, object Term2) { Term1 = YP.getValue(Term1); if (Term1 is IUnifiable) return ((IUnifiable)Term1).termEqual(Term2); return Term1.Equals(YP.getValue(Term2)); } public static bool termNotEqual(object Term1, object Term2) { return !termEqual(Term1, Term2); } public static bool termLessThan(object Term1, object Term2) { Term1 = YP.getValue(Term1); Term2 = YP.getValue(Term2); int term1TypeCode = getTypeCode(Term1); int term2TypeCode = getTypeCode(Term2); if (term1TypeCode != term2TypeCode) return term1TypeCode < term2TypeCode; // The terms are the same type code. if (term1TypeCode == -2) { // Variable. // We always check for equality first because we want to be sure // that less than returns false if the terms are equal, in // case that the less than check really behaves like less than or equal. if ((Variable)Term1 != (Variable)Term2) // The hash code should be unique to a Variable object. return Term1.GetHashCode() < Term2.GetHashCode(); return false; } if (term1TypeCode == 0) return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0; if (term1TypeCode == 1) return ((Functor1)Term1).lessThan((Functor1)Term2); if (term1TypeCode == 2) return ((Functor2)Term1).lessThan((Functor2)Term2); if (term1TypeCode == 3) return ((Functor3)Term1).lessThan((Functor3)Term2); if (term1TypeCode == 4) return ((Functor)Term1).lessThan((Functor)Term2); // Type code is -1 for general objects. First compare their type names. // Note that this puts Double before Int32 as required by ISO Prolog. string term1TypeName = Term1.GetType().ToString(); string term2TypeName = Term2.GetType().ToString(); if (term1TypeName != term2TypeName) return term1TypeName.CompareTo(term2TypeName) < 0; // The terms are the same type name. if (Term1 is int) return (int)Term1 < (int)Term2; else if (Term1 is double) return (double)Term1 < (double)Term2; else if (Term1 is DateTime) return (DateTime)Term1 < (DateTime)Term2; else if (Term1 is String) return ((String)Term1).CompareTo((String)Term2) < 0; // Debug: Should we try arrays, etc.? if (!Term1.Equals(Term2)) // Could be equal or greater than. return Term1.GetHashCode() < Term2.GetHashCode(); return false; } /// <summary> /// 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, /// 4 if it is Functor. /// Otherwise, type code is -1. /// This does not call YP.getValue(term). /// </summary> /// <param name="term"></param> /// <returns></returns> private static int getTypeCode(object term) { if (term is Variable) return -2; else if (term is Atom) return 0; else if (term is Functor1) return 1; else if (term is Functor2) return 2; else if (term is Functor3) return 3; else if (term is Functor) return 4; else return -1; } public static bool termLessThanOrEqual(object Term1, object Term2) { if (YP.termEqual(Term1, Term2)) return true; return YP.termLessThan(Term1, Term2); } public static bool termGreaterThan(object Term1, object Term2) { return !YP.termLessThanOrEqual(Term1, Term2); } public static bool termGreaterThanOrEqual(object Term1, object Term2) { // termLessThan should ensure that it returns false if terms are equal, // so that this would return true. return !YP.termLessThan(Term1, Term2); } public static int compareTerms(object Term1, object Term2) { if (YP.termEqual(Term1, Term2)) return 0; else if (YP.termLessThan(Term1, Term2)) return -1; else return 1; } public static bool ground(object Term) { Term = YP.getValue(Term); if (Term is IUnifiable) return ((IUnifiable)Term).ground(); return true; } public static IEnumerable<bool> current_op (object Priority, object Specifier, object Operator) { if (_operatorTable == null) { // Initialize. _operatorTable = new IndexedAnswers(3); _operatorTable.addAnswer(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") }); _operatorTable.addAnswer(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") }); _operatorTable.addAnswer(new object[] { 1200, Atom.a("fx"), Atom.a(":-") }); _operatorTable.addAnswer(new object[] { 1200, Atom.a("fx"), Atom.a("?-") }); _operatorTable.addAnswer(new object[] { 1100, Atom.a("xfy"), Atom.a(";") }); _operatorTable.addAnswer(new object[] { 1050, Atom.a("xfy"), Atom.a("->") }); _operatorTable.addAnswer(new object[] { 1000, Atom.a("xfy"), Atom.a(",") }); _operatorTable.addAnswer(new object[] { 900, Atom.a("fy"), Atom.a("\\+") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("==") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@<") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@>") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=..") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("is") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("<") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=<") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a(">") }); _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a(">=") }); _operatorTable.addAnswer(new object[] { 600, Atom.a("xfy"), Atom.a(":") }); _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("+") }); _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("-") }); _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") }); _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("*") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("/") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("//") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("rem") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("mod") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("<<") }); _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a(">>") }); _operatorTable.addAnswer(new object[] { 200, Atom.a("xfx"), Atom.a("**") }); _operatorTable.addAnswer(new object[] { 200, Atom.a("xfy"), Atom.a("^") }); _operatorTable.addAnswer(new object[] { 200, Atom.a("fy"), Atom.a("-") }); _operatorTable.addAnswer(new object[] { 200, Atom.a("fy"), Atom.a("\\") }); // Debug: This is hacked in to run the Prolog test suite until we implement op/3. _operatorTable.addAnswer(new object[] { 20, Atom.a("xfx"), Atom.a("<--") }); } return _operatorTable.match(new object[] { Priority, Specifier, Operator }); } public static IEnumerable<bool> atom_length(object atom, object Length) { atom = YP.getValue(atom); Length = YP.getValue(Length); if (atom is Variable) throw new PrologException(Atom.a("instantiation_error"), "Expected atom(Arg1) but it is an unbound variable"); if (!(atom is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not an atom"); if (!(Length is Variable)) { if (!(Length is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), Length), "Length must be var or integer"); if ((int)Length < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), Length), "Length must not be less than zero"); } return YP.unify(Length, ((Atom)atom)._name.Length); } public static IEnumerable<bool> atom_concat(object Start, object End, object Whole) { // Debug: Should we try to preserve the _declaringClass? Start = YP.getValue(Start); End = YP.getValue(End); Whole = YP.getValue(Whole); if (Whole is Variable) { if (Start is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Start and arg 3 Whole are both var"); if (End is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 2 End and arg 3 Whole are both var"); if (!(Start is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Start), "Arg 1 Start is not an atom"); if (!(End is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), End), "Arg 2 End is not an atom"); foreach (bool l1 in YP.unify(Whole, Atom.a(((Atom)Start)._name + ((Atom)End)._name))) yield return false; } else { if (!(Whole is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Whole), "Arg 3 Whole is not an atom"); bool gotStartLength = false; int startLength = 0; if (!(Start is Variable)) { if (!(Start is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Start), "Arg 1 Start is not var or atom"); startLength = ((Atom)Start)._name.Length; gotStartLength = true; } bool gotEndLength = false; int endLength = 0; if (!(End is Variable)) { if (!(End is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), End), "Arg 2 End is not var or atom"); endLength = ((Atom)End)._name.Length; gotEndLength = true; } // We are doing a search through all possible Start and End which concatenate to Whole. string wholeString = ((Atom)Whole)._name; for (int i = 0; i <= wholeString.Length; ++i) { // If we got either startLength or endLength, we know the lengths have to match so check // the lengths instead of constructing an Atom to do it. if (gotStartLength && startLength != i) continue; if (gotEndLength && endLength != wholeString.Length - i) continue; foreach (bool l1 in YP.unify(Start, Atom.a(wholeString.Substring(0, i)))) { foreach (bool l2 in YP.unify(End, Atom.a(wholeString.Substring(i, wholeString.Length - i)))) yield return false; } } } } public static IEnumerable<bool> sub_atom (object atom, object Before, object Length, object After, object Sub_atom) { // Debug: Should we try to preserve the _declaringClass? atom = YP.getValue(atom); Before = YP.getValue(Before); Length = YP.getValue(Length); After = YP.getValue(After); Sub_atom = YP.getValue(Sub_atom); if (atom is Variable) throw new PrologException(Atom.a("instantiation_error"), "Expected atom(Arg1) but it is an unbound variable"); if (!(atom is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not an atom"); if (!(Sub_atom is Variable)) { if (!(Sub_atom is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Sub_atom), "Sub_atom is not var or atom"); } bool beforeIsInt = false; bool lengthIsInt = false; bool afterIsInt = false; if (!(Before is Variable)) { if (!(Before is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), Before), "Before must be var or integer"); beforeIsInt = true; if ((int)Before < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), Before), "Before must not be less than zero"); } if (!(Length is Variable)) { if (!(Length is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), Length), "Length must be var or integer"); lengthIsInt = true; if ((int)Length < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), Length), "Length must not be less than zero"); } if (!(After is Variable)) { if (!(After is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), After), "After must be var or integer"); afterIsInt = true; if ((int)After < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), After), "After must not be less than zero"); } Atom atomAtom = (Atom)atom; int atomLength = atomAtom._name.Length; if (beforeIsInt && lengthIsInt) { // Special case: the caller is just trying to extract a substring, so do it quickly. int xAfter = atomLength - (int)Before - (int)Length; if (xAfter >= 0) { foreach (bool l1 in YP.unify(After, xAfter)) { foreach (bool l2 in YP.unify (Sub_atom, Atom.a(atomAtom._name.Substring((int)Before, (int)Length)))) yield return false; } } } else if (afterIsInt && lengthIsInt) { // Special case: the caller is just trying to extract a substring, so do it quickly. int xBefore = atomLength - (int)After - (int)Length; if (xBefore >= 0) { foreach (bool l1 in YP.unify(Before, xBefore)) { foreach (bool l2 in YP.unify (Sub_atom, Atom.a(atomAtom._name.Substring(xBefore, (int)Length)))) yield return false; } } } else { // We are underconstrained and doing a search, so go through all possibilities. for (int xBefore = 0; xBefore <= atomLength; ++xBefore) { foreach (bool l1 in YP.unify(Before, xBefore)) { for (int xLength = 0; xLength <= (atomLength - xBefore); ++xLength) { foreach (bool l2 in YP.unify(Length, xLength)) { foreach (bool l3 in YP.unify(After, atomLength - (xBefore + xLength))) { foreach (bool l4 in YP.unify (Sub_atom, Atom.a(atomAtom._name.Substring(xBefore, xLength)))) yield return false; } } } } } } } public static IEnumerable<bool> atom_chars(object atom, object List) { atom = YP.getValue(atom); List = YP.getValue(List); if (atom is Variable) { if (List is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Atom and arg 2 List are both unbound variables"); object[] codeArray = ListPair.toArray(List); if (codeArray == null) throw new PrologException (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); char[] charArray = new char[codeArray.Length]; for (int i = 0; i < codeArray.Length; ++i) { object listAtom = YP.getValue(codeArray[i]); if (listAtom is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 2 List has an element which is an unbound variable"); if (!(listAtom is Atom && ((Atom)listAtom)._name.Length == 1)) throw new PrologException (new Functor2("type_error", Atom.a("character"), listAtom), "Arg 2 List has an element which is not a one character atom"); charArray[i] = ((Atom)listAtom)._name[0]; } return YP.unify(atom, Atom.a(new String(charArray))); } else { if (!(atom is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not var or atom"); string atomString = ((Atom)atom)._name; object charList = Atom.NIL; // Start from the back to make the list. for (int i = atomString.Length - 1; i >= 0; --i) charList = new ListPair(Atom.a(atomString.Substring(i, 1)), charList); return YP.unify(List, charList); } } public static IEnumerable<bool> atom_codes(object atom, object List) { atom = YP.getValue(atom); List = YP.getValue(List); if (atom is Variable) { if (List is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Atom and arg 2 List are both unbound variables"); object[] codeArray = ListPair.toArray(List); if (codeArray == null) throw new PrologException (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); char[] charArray = new char[codeArray.Length]; for (int i = 0; i < codeArray.Length; ++i) { int codeInt; if (!getInt(codeArray[i], out codeInt) || codeInt < 0) throw new PrologException (new Functor1("representation_error", Atom.a("character_code")), "Element of Arg 2 List is not a character code"); charArray[i] = (char)codeInt; } return YP.unify(atom, Atom.a(new String(charArray))); } else { if (!(atom is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not var or atom"); string atomString = ((Atom)atom)._name; object codeList = Atom.NIL; // Start from the back to make the list. for (int i = atomString.Length - 1; i >= 0; --i) codeList = new ListPair((int)atomString[i], codeList); return YP.unify(List, codeList); } } public static IEnumerable<bool> number_chars(object Number, object List) { Number = YP.getValue(Number); List = YP.getValue(List); if (Number is Variable) { if (List is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Number and arg 2 List are both unbound variables"); object[] codeArray = ListPair.toArray(List); if (codeArray == null) throw new PrologException (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); char[] charArray = new char[codeArray.Length]; for (int i = 0; i < codeArray.Length; ++i) { object listAtom = YP.getValue(codeArray[i]); if (listAtom is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 2 List has an element which is an unbound variable"); if (!(listAtom is Atom && ((Atom)listAtom)._name.Length == 1)) throw new PrologException (new Functor2("type_error", Atom.a("character"), listAtom), "Arg 2 List has an element which is not a one character atom"); charArray[i] = ((Atom)listAtom)._name[0]; } return YP.unify(Number, parseNumberString(charArray)); } else { string numberString = null; // Try converting to an int first. int intNumber; if (YP.getInt(Number, out intNumber)) numberString = intNumber.ToString(); else { if (!YP.number(Number)) throw new PrologException (new Functor2("type_error", Atom.a("number"), Number), "Arg 1 Number is not var or number"); // We just checked, so convertDouble shouldn't throw an exception. numberString = YP.doubleToString(YP.convertDouble(Number)); } object charList = Atom.NIL; // Start from the back to make the list. for (int i = numberString.Length - 1; i >= 0; --i) charList = new ListPair(Atom.a(numberString.Substring(i, 1)), charList); return YP.unify(List, charList); } } public static IEnumerable<bool> number_codes(object Number, object List) { Number = YP.getValue(Number); List = YP.getValue(List); if (Number is Variable) { if (List is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Number and arg 2 List are both unbound variables"); object[] codeArray = ListPair.toArray(List); if (codeArray == null) throw new PrologException (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); char[] charArray = new char[codeArray.Length]; for (int i = 0; i < codeArray.Length; ++i) { int codeInt; if (!getInt(codeArray[i], out codeInt) || codeInt < 0) throw new PrologException (new Functor1("representation_error", Atom.a("character_code")), "Element of Arg 2 List is not a character code"); charArray[i] = (char)codeInt; } return YP.unify(Number, parseNumberString(charArray)); } else { string numberString = null; // Try converting to an int first. int intNumber; if (YP.getInt(Number, out intNumber)) numberString = intNumber.ToString(); else { if (!YP.number(Number)) throw new PrologException (new Functor2("type_error", Atom.a("number"), Number), "Arg 1 Number is not var or number"); // We just checked, so convertDouble shouldn't throw an exception. numberString = YP.doubleToString(YP.convertDouble(Number)); } object codeList = Atom.NIL; // Start from the back to make the list. for (int i = numberString.Length - 1; i >= 0; --i) codeList = new ListPair((int)numberString[i], codeList); return YP.unify(List, codeList); } } /// <summary> /// Used by number_chars and number_codes. Return the number in charArray or /// throw an exception if can't parse. /// </summary> /// <param name="numberString"></param> /// <returns></returns> private static object parseNumberString(char[] charArray) { string numberString = new String(charArray); if (charArray.Length == 3 && numberString.StartsWith("0'")) // This is a char code. return (int)charArray[2]; if (numberString.StartsWith("0x")) { try { return Int32.Parse (numberString.Substring(2), System.Globalization.NumberStyles.AllowHexSpecifier); } catch (FormatException) { throw new PrologException (new Functor1("syntax_error", Atom.a("number_format: " + numberString)), "Arg 2 List is not a list for a hexadecimal number"); } } // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? try { // Try an int first. return Convert.ToInt32(numberString); } catch (FormatException) { } try { return Convert.ToDouble(numberString); } catch (FormatException) { throw new PrologException (new Functor1("syntax_error", Atom.a("number_format: " + numberString)), "Arg 2 List is not a list for a number"); } } public static IEnumerable<bool> char_code(object Char, object Code) { Char = YP.getValue(Char); Code = YP.getValue(Code); int codeInt = 0; if (!(Code is Variable)) { // Get codeInt now so we type check it whether or not Char is Variable. if (!getInt(Code, out codeInt)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), Code), "Arg 2 Code is not var or a character code"); if (codeInt < 0) throw new PrologException (new Functor1("representation_error", Atom.a("character_code")), "Arg 2 Code is not a character code"); } if (Char is Variable) { if (Code is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Char and arg 2 Code are both unbound variables"); return YP.unify(Char, Atom.a(new String(new char[] {(char)codeInt}))); } else { if (!(Char is Atom) || ((Atom)Char)._name.Length != 1) throw new PrologException (new Functor2("type_error", Atom.a("character"), Char), "Arg 1 Char is not var or one-character atom"); if (Code is Variable) return YP.unify(Code, (int)((Atom)Char)._name[0]); else // Use codeInt to handle whether Code is supplied as, e.g., 97 or 0'a . return YP.unify(codeInt, (int)((Atom)Char)._name[0]); } } /// <summary> /// If term is an Atom or functor type, return its name. /// Otherwise, return term. /// </summary> /// <param name="term"></param> /// <returns></returns> public static object getFunctorName(object term) { term = YP.getValue(term); if (term is Functor1) return ((Functor1)term)._name; else if (term is Functor2) return ((Functor2)term)._name; else if (term is Functor3) return ((Functor3)term)._name; else if (term is Functor) return ((Functor)term)._name; else return term; } /// <summary> /// If term is an Atom or functor type, return an array of its args. /// Otherwise, return an empty array. /// </summary> /// <param name="term"></param> /// <returns></returns> public static object[] getFunctorArgs(object term) { term = YP.getValue(term); if (term is Functor1) { Functor1 functor = (Functor1)term; return new object[] { functor._arg1 }; } else if (term is Functor2) { Functor2 functor = (Functor2)term; return new object[] { functor._arg1, functor._arg2 }; } else if (term is Functor3) { Functor3 functor = (Functor3)term; return new object[] { functor._arg1, functor._arg2, functor._arg3 }; } else if (term is Functor) { Functor functor = (Functor)term; return functor._args; } else return new object[0]; } public static bool var(object Term) { return YP.getValue(Term) is Variable; } public static bool nonvar(object Term) { return !YP.var(Term); } public static bool atom(object Term) { return YP.getValue(Term) is Atom; } public static bool integer(object Term) { // Debug: Should exhaustively check for all integer types. return getValue(Term) is int; } // Use isFloat instead of float because it is a reserved keyword. public static bool isFloat(object Term) { // Debug: Should exhaustively check for all float types. return getValue(Term) is double; } public static bool number(object Term) { return YP.integer(Term) || YP.isFloat(Term); } public static bool atomic(object Term) { return YP.atom(Term) || YP.number(Term); } public static bool compound(object Term) { Term = getValue(Term); return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor; } /// <summary> /// If input is a TextReader, use it. If input is an Atom or String, create a StreamReader with the /// input as the filename. If input is a Prolog list, then read character codes from it. /// </summary> /// <param name="input"></param> public static void see(object input) { input = YP.getValue(input); if (input is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg is an unbound variable"); if (input == null) { _inputStream = null; return; } if (input is TextReader) { _inputStream = (TextReader)input; return; } else if (input is Atom) { _inputStream = new StreamReader(((Atom)input)._name); return; } else if (input is String) { _inputStream = new StreamReader((String)input); return; } else if (input is Functor2 && ((Functor2)input)._name == Atom.DOT) { _inputStream = new CodeListReader(input); return; } else throw new PrologException (new Functor2("domain_error", Atom.a("stream_or_alias"), input), "Input stream specifier not recognized"); } public static void seen() { if (_inputStream == null) return; if (_inputStream == Console.In) return; _inputStream.Close(); _inputStream = Console.In; } public static IEnumerable<bool> current_input(object Stream) { return YP.unify(Stream, _inputStream); } /// <summary> /// If output is a TextWriter, use it. If output is an Atom or a String, create a StreamWriter /// with the input as the filename. /// </summary> /// <param name="output"></param> public static void tell(object output) { output = YP.getValue(output); if (output is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg is an unbound variable"); if (output == null) { _outputStream = null; return; } if (output is TextWriter) { _outputStream = (TextWriter)output; return; } else if (output is Atom) { _outputStream = new StreamWriter(((Atom)output)._name); return; } else if (output is String) { _outputStream = new StreamWriter((String)output); return; } else throw new PrologException (new Functor2("domain_error", Atom.a("stream_or_alias"), output), "Can't open stream for " + output); } public static void told() { if (_outputStream == null) return; if (_outputStream == Console.Out) return; _outputStream.Close(); _outputStream = Console.Out; } public static IEnumerable<bool> current_output(object Stream) { return YP.unify(Stream, _outputStream); } public static void write(object x) { if (_outputStream == null) return; x = YP.getValue(x); if (x is double) _outputStream.Write(doubleToString((double)x)); else _outputStream.Write(x.ToString()); } /// <summary> /// Format x as a string, making sure that it won't parse as an int later. I.e., for 1.0, don't just /// use "1" which will parse as an int. /// </summary> /// <param name="x"></param> /// <returns></returns> private static string doubleToString(double x) { string xString = x.ToString(); // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? try { Convert.ToInt32(xString); // 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. return x.ToString(x >= 100000.0 ? "E1" : "f1"); } catch (FormatException) { // Assume it will parse as a double. } return xString; } public static void put_code(object x) { if (_outputStream == null) return; if (var(x)) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 is an unbound variable"); int xInt; if (!getInt(x, out xInt)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), x), "Arg 1 must be integer"); _outputStream.Write((char)xInt); } public static void nl() { if (_outputStream == null) return; _outputStream.WriteLine(); } public static IEnumerable<bool> get_code(object code) { if (_inputStream == null) return YP.unify(code, -1); else return YP.unify(code, _inputStream.Read()); } public static void asserta(object Term, Type declaringClass) { assertDynamic(Term, declaringClass, true); } public static void assertz(object Term, Type declaringClass) { assertDynamic(Term, declaringClass, false); } public static void assertDynamic(object Term, Type declaringClass, bool prepend) { Term = getValue(Term); if (Term is Variable) throw new PrologException("instantiation_error", "Term to assert is an unbound variable"); Variable.CopyStore copyStore = new Variable.CopyStore(); object TermCopy = makeCopy(Term, copyStore); object Head, Body; if (TermCopy is Functor2 && ((Functor2)TermCopy)._name == Atom.RULE) { Head = YP.getValue(((Functor2)TermCopy)._arg1); Body = YP.getValue(((Functor2)TermCopy)._arg2); if (Head is Variable) throw new PrologException("instantiation_error", "Head to assert is an unbound variable"); if (Body is Variable) throw new PrologException("instantiation_error", "Body to assert is an unbound variable"); } else { Head = TermCopy; Body = Atom.a("true"); } Atom name = getFunctorName(Head) as Atom; if (name == null) // name is a non-Atom, such as a number. throw new PrologException (new Functor2("type_error", Atom.a("callable"), Head), "Term to assert is not callable"); object[] args = getFunctorArgs(Head); if (isSystemPredicate(name, args.Length)) throw new PrologException (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), new Functor2(Atom.SLASH, name, args.Length)), "Assert cannot modify static predicate " + name + "/" + args.Length); if (copyStore.getNUniqueVariables() == 0 && Body == Atom.a("true")) { // This is a fact with no unbound variables // assertFact and prependFact use IndexedAnswers, so don't we don't need to compile. if (prepend) prependFact(name, args); else assertFact(name, args); return; } IClause clause = YPCompiler.compileAnonymousClause(Head, Body, declaringClass); // We expect clause to be a ClauseHeadAndBody (from Compiler.compileAnonymousFunction) // so we can set the Head and Body. if (clause is ClauseHeadAndBody) ((ClauseHeadAndBody)clause).setHeadAndBody(Head, Body); // Add the clause to the entry in _predicatesStore. NameArity nameArity = new NameArity(name, args.Length); List<IClause> clauses; if (!_predicatesStore.TryGetValue(nameArity, out clauses)) // Create an entry for the nameArity. _predicatesStore[nameArity] = (clauses = new List<IClause>()); if (prepend) clauses.Insert(0, clause); else clauses.Add(clause); } private static bool isSystemPredicate(Atom name, int arity) { if (arity == 2 && (name == Atom.a(",") || name == Atom.a(";") || name == Atom.DOT)) return true; // Use the same mapping to static predicates in YP as the compiler. foreach (bool l1 in YPCompiler.functorCallYPFunctionName(name, arity, new Variable())) return true; // Debug: Do we need to check if name._module is null? return false; } /// <summary> /// Assert values at the end of the set of facts for the predicate with the /// name and with arity values.Length. /// </summary> /// <param name="name">must be an Atom</param> /// <param name="values">the array of arguments to the fact predicate. /// It is an error if an value has an unbound variable.</param> public static void assertFact(Atom name, object[] values) { NameArity nameArity = new NameArity(name, values.Length); List<IClause> clauses; IndexedAnswers indexedAnswers; if (!_predicatesStore.TryGetValue(nameArity, out clauses)) { // Create an IndexedAnswers as the only clause of the predicate. _predicatesStore[nameArity] = (clauses = new List<IClause>()); clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); } else { indexedAnswers = null; if (clauses.Count >= 1) indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers; if (indexedAnswers == null) // The latest clause is not an IndexedAnswers, so add one. clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); } indexedAnswers.addAnswer(values); } /// <summary> /// Assert values, prepending to the front of the set of facts for the predicate with the /// name and with arity values.Length. /// </summary> /// <param name="name">must be an Atom</param> /// <param name="values">the array of arguments to the fact predicate. /// It is an error if an value has an unbound variable.</param> public static void prependFact(Atom name, object[] values) { NameArity nameArity = new NameArity(name, values.Length); List<IClause> clauses; IndexedAnswers indexedAnswers; if (!_predicatesStore.TryGetValue(nameArity, out clauses)) { // Create an IndexedAnswers as the only clause of the predicate. _predicatesStore[nameArity] = (clauses = new List<IClause>()); clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); } else { indexedAnswers = null; if (clauses.Count >= 1) indexedAnswers = clauses[0] as IndexedAnswers; if (indexedAnswers == null) // The first clause is not an IndexedAnswers, so prepend one. clauses.Insert(0, indexedAnswers = new IndexedAnswers(values.Length)); } indexedAnswers.prependAnswer(values); } /// <summary> /// Match all clauses of the dynamic predicate with the name and with arity /// arguments.Length. /// If the predicate is not defined, return the result of YP.unknownPredicate. /// </summary> /// <param name="name">must be an Atom</param> /// <param name="arguments">an array of arity number of arguments</param> /// <returns>an iterator which you can use in foreach</returns> public static IEnumerable<bool> matchDynamic(Atom name, object[] arguments) { List<IClause> clauses; if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses)) return unknownPredicate(name, arguments.Length, "Undefined dynamic predicate: " + name + "/" + arguments.Length); if (clauses.Count == 1) // Usually there is only one clause, so return it without needing to wrap it in an iterator. return clauses[0].match(arguments); else return matchAllClauses(clauses, arguments); } /// <summary> /// Call match(arguments) for each IClause in clauses. We make this a separate /// function so that matchDynamic itself does not need to be an iterator object. /// </summary> /// <param name="clauses"></param> /// <param name="arguments"></param> /// <returns></returns> private static IEnumerable<bool> matchAllClauses(List<IClause> clauses, object[] arguments) { // Debug: If the caller asserts another clause into this same predicate during yield, the iterator // over clauses will be corrupted. Should we take the time to copy clauses? foreach (IClause clause in clauses) { foreach (bool lastCall in clause.match(arguments)) { yield return false; if (lastCall) // This happens after a cut in a clause. yield break; } } } /// <summary> /// If _prologFlags["unknown"] is fail then return fail(), else if /// _prologFlags["unknown"] is warning then write the message to YP.write and /// return fail(), else throw a PrologException for existence_error. . /// </summary> /// <param name="name"></param> /// <param name="arity"></param> /// <param name="message"></param> /// <returns></returns> public static IEnumerable<bool> unknownPredicate(Atom name, int arity, string message) { establishPrologFlags(); if (_prologFlags["unknown"] == Atom.a("fail")) return fail(); else if (_prologFlags["unknown"] == Atom.a("warning")) { write(message); nl(); return fail(); } else throw new PrologException (new Functor2 (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.SLASH, name, arity)), message); } /// <summary> /// This is deprecated and just calls matchDynamic. This matches all clauses, /// not just the ones defined with assertFact. /// </summary> /// <param name="name"></param> /// <param name="arguments"></param> /// <returns></returns> public static IEnumerable<bool> matchFact(Atom name, object[] arguments) { return matchDynamic(name, arguments); } public static IEnumerable<bool> clause(object Head, object Body) { Head = getValue(Head); Body = getValue(Body); if (Head is Variable) throw new PrologException("instantiation_error", "Head is an unbound variable"); Atom name = getFunctorName(Head) as Atom; if (name == null) // name is a non-Atom, such as a number. throw new PrologException (new Functor2("type_error", Atom.a("callable"), Head), "Head is not callable"); object[] args = getFunctorArgs(Head); if (isSystemPredicate(name, args.Length)) throw new PrologException (new Functor3("permission_error", Atom.a("access"), Atom.a("private_procedure"), new Functor2(Atom.SLASH, name, args.Length)), "clause cannot access private predicate " + name + "/" + args.Length); if (!(Body is Variable) && !(YP.getFunctorName(Body) is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("callable"), Body), "Body is not callable"); List<IClause> clauses; if (!_predicatesStore.TryGetValue(new NameArity(name, args.Length), out clauses)) yield break; // The caller can assert another clause into this same predicate during yield, so we have to // make a copy of the clauses. foreach (IClause predicateClause in clauses.ToArray()) { foreach (bool l1 in predicateClause.clause(Head, Body)) yield return false; } } public static IEnumerable<bool> retract(object Term) { Term = getValue(Term); if (Term is Variable) throw new PrologException("instantiation_error", "Term to retract is an unbound variable"); object Head, Body; if (Term is Functor2 && ((Functor2)Term)._name == Atom.RULE) { Head = YP.getValue(((Functor2)Term)._arg1); Body = YP.getValue(((Functor2)Term)._arg2); } else { Head = Term; Body = Atom.a("true"); } if (Head is Variable) throw new PrologException("instantiation_error", "Head is an unbound variable"); Atom name = getFunctorName(Head) as Atom; if (name == null) // name is a non-Atom, such as a number. throw new PrologException (new Functor2("type_error", Atom.a("callable"), Head), "Head is not callable"); object[] args = getFunctorArgs(Head); if (isSystemPredicate(name, args.Length)) throw new PrologException (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), new Functor2(Atom.SLASH, name, args.Length)), "clause cannot access private predicate " + name + "/" + args.Length); if (!(Body is Variable) && !(YP.getFunctorName(Body) is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("callable"), Body), "Body is not callable"); List<IClause> clauses; if (!_predicatesStore.TryGetValue(new NameArity(name, args.Length), out clauses)) yield break; // The caller can assert another clause into this same predicate during yield, so we have to // make a copy of the clauses. foreach (IClause predicateClause in clauses.ToArray()) { if (predicateClause is IndexedAnswers) { // IndexedAnswers handles its own retract. Even if it removes all of its // answers, it is OK to leave it empty as one of the elements in clauses. foreach (bool l1 in ((IndexedAnswers)predicateClause).retract(Head, Body)) yield return false; } else { foreach (bool l1 in predicateClause.clause(Head, Body)) { clauses.Remove(predicateClause); yield return false; } } } } /// <summary> /// This is deprecated for backward compatibility. You should use retractall. /// </summary> /// <param name="name">must be an Atom</param> /// <param name="arguments">an array of arity number of arguments</param> public static void retractFact(Atom name, object[] arguments) { retractall(Functor.make(name, arguments)); } /// <summary> /// Retract all dynamic clauses which unify with Head. If this matches all clauses in a predicate, /// the predicate is still defined. To completely remove the predicate, see abolish. /// </summary> /// <param name="Head"></param> public static void retractall(object Head) { object name = YP.getFunctorName(Head); object[] arguments = getFunctorArgs(Head); if (!(name is Atom)) return; NameArity nameArity = new NameArity((Atom)name, arguments.Length); List<IClause> clauses; if (!_predicatesStore.TryGetValue(nameArity, out clauses)) // Can't find, so ignore. return; foreach (object arg in arguments) { if (!YP.var(arg)) throw new InvalidOperationException ("Until matching retractall is supported, all arguments must be unbound to retract all clauses"); } // Clear all clauses. _predicatesStore[nameArity] = new List<IClause>(); } /// <summary> /// If NameSlashArity is var, match with all the dynamic predicates using the /// Name/Artity form. /// If NameSlashArity is not var, check if the Name/Arity exists as a static or /// dynamic predicate. /// </summary> /// <param name="NameSlashArity"></param> /// <param name="declaringClass">if not null, used to resolve references to the default /// module Atom.a("")</param> /// <returns></returns> public static IEnumerable<bool> current_predicate(object NameSlashArity, Type declaringClass) { NameSlashArity = YP.getValue(NameSlashArity); // First check if Name and Arity are nonvar so we can do a direct lookup. if (YP.ground(NameSlashArity)) { Functor2 NameArityFunctor = NameSlashArity as Functor2; if (!(NameArityFunctor != null && NameArityFunctor._name == Atom.SLASH)) throw new PrologException (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), "Must be a name/arity predicate indicator"); object name = YP.getValue(NameArityFunctor._arg1); object arity = YP.getValue(NameArityFunctor._arg2); if (name is Variable || arity is Variable) throw new PrologException ("instantiation_error", "Predicate indicator name or arity is an unbound variable"); if (!(name is Atom && arity is int)) throw new PrologException (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), "Must be a name/arity predicate indicator"); if ((int)arity < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), arity), "Arity may not be less than zero"); if (YPCompiler.isCurrentPredicate((Atom)name, (int)arity, declaringClass)) // The predicate is defined. yield return false; } else { foreach (NameArity key in _predicatesStore.Keys) { foreach (bool l1 in YP.unify (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity)) yield return false; } } } /// <summary> /// Return true if the dynamic predicate store has an entry for the predicate /// with name and arity. /// </summary> /// <param name="name"></param> /// <param name="arity"></param> /// <returns></returns> public static bool isDynamicCurrentPredicate(Atom name, int arity) { return _predicatesStore.ContainsKey(new NameArity(name, arity)); } public static void abolish(object NameSlashArity) { NameSlashArity = YP.getValue(NameSlashArity); if (NameSlashArity is Variable) throw new PrologException ("instantiation_error", "Predicate indicator is an unbound variable"); Functor2 NameArityFunctor = NameSlashArity as Functor2; if (!(NameArityFunctor != null && NameArityFunctor._name == Atom.SLASH)) throw new PrologException (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), "Must be a name/arity predicate indicator"); object name = YP.getValue(NameArityFunctor._arg1); object arity = YP.getValue(NameArityFunctor._arg2); if (name is Variable || arity is Variable) throw new PrologException ("instantiation_error", "Predicate indicator name or arity is an unbound variable"); if (!(name is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), name), "Predicate indicator name must be an atom"); if (!(arity is int)) throw new PrologException (new Functor2("type_error", Atom.a("integer"), arity), "Predicate indicator arity must be an integer"); if ((int)arity < 0) throw new PrologException (new Functor2("domain_error", Atom.a("not_less_than_zero"), arity), "Arity may not be less than zero"); if ((int)arity > MAX_ARITY) throw new PrologException (new Functor1("representation_error", Atom.a("max_arity")), "Arity may not be greater than " + MAX_ARITY); if (isSystemPredicate((Atom)name, (int)arity)) throw new PrologException (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), new Functor2(Atom.SLASH, name, arity)), "Abolish cannot modify static predicate " + name + "/" + arity); _predicatesStore.Remove(new NameArity((Atom)name, (int)arity)); } /// <summary> /// If Goal is a simple predicate, call YP.getFunctorName(Goal) using arguments from /// YP.getFunctorArgs(Goal). If not found, this throws a PrologException for existence_error. /// Otherwise, compile the goal as a single clause predicate and invoke it. /// </summary> /// <param name="Goal"></param> /// <param name="declaringClass">if not null, used to resolve references to the default /// module Atom.a("")</param> /// <returns></returns> public static IEnumerable<bool> getIterator(object Goal, Type declaringClass) { Atom name; object[] args; while (true) { Goal = YP.getValue(Goal); if (Goal is Variable) throw new PrologException("instantiation_error", "Goal to call is an unbound variable"); name = YP.getFunctorName(Goal) as Atom; if (name == null) throw new PrologException (new Functor2("type_error", Atom.a("callable"), Goal), "Goal to call is not callable"); args = YP.getFunctorArgs(Goal); if (name == Atom.HAT && args.Length == 2) // Assume this is called from a bagof operation. Skip the leading qualifiers. Goal = YP.getValue(((Functor2)Goal)._arg2); else break; } IEnumerable<bool> simpleIterator = YPCompiler.getSimpleIterator(name, args, declaringClass); if (simpleIterator != null) // We don't need to compile since the goal is a simple predicate which we call directly. return simpleIterator; // Compile the goal as a clause. List<Variable> variableSetList = new List<Variable>(); addUniqueVariables(Goal, variableSetList); Variable[] variableSet = variableSetList.ToArray(); // Use Atom.F since it is ignored. return YPCompiler.compileAnonymousClause (Functor.make(Atom.F, variableSet), Goal, declaringClass).match(variableSet); } public static void throwException(object Term) { throw new PrologException(Term); } /// <summary> /// This must be called by any function that uses YP._prologFlags to make sure /// the initial defaults are loaded. /// </summary> private static void establishPrologFlags() { if (_prologFlags.Count > 0) // Already established. return; // List these in the order they appear in the ISO standard. _prologFlags["bounded"] = Atom.a("true"); _prologFlags["max_integer"] = Int32.MaxValue; _prologFlags["min_integer"] = Int32.MinValue; _prologFlags["integer_rounding_function"] = Atom.a("toward_zero"); _prologFlags["char_conversion"] = Atom.a("off"); _prologFlags["debug"] = Atom.a("off"); _prologFlags["max_arity"] = MAX_ARITY; _prologFlags["unknown"] = Atom.a("error"); _prologFlags["double_quotes"] = Atom.a("codes"); } public static IEnumerable<bool> current_prolog_flag(object Key, object Value) { establishPrologFlags(); Key = YP.getValue(Key); Value = YP.getValue(Value); if (Key is Variable) { // Bind all key values. foreach (string key in _prologFlags.Keys) { foreach (bool l1 in YP.unify(Key, Atom.a(key))) { foreach (bool l2 in YP.unify(Value, _prologFlags[key])) yield return false; } } } else { if (!(Key is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Key), "Arg 1 Key is not an atom"); if (!_prologFlags.ContainsKey(((Atom)Key)._name)) throw new PrologException (new Functor2("domain_error", Atom.a("prolog_flag"), Key), "Arg 1 Key is not a recognized flag"); foreach (bool l1 in YP.unify(Value, _prologFlags[((Atom)Key)._name])) yield return false; } } public static void set_prolog_flag(object Key, object Value) { establishPrologFlags(); Key = YP.getValue(Key); Value = YP.getValue(Value); if (Key is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Key is an unbound variable"); if (Value is Variable) throw new PrologException(Atom.a("instantiation_error"), "Arg 1 Key is an unbound variable"); if (!(Key is Atom)) throw new PrologException (new Functor2("type_error", Atom.a("atom"), Key), "Arg 1 Key is not an atom"); string keyName = ((Atom)Key)._name; if (!_prologFlags.ContainsKey(keyName)) throw new PrologException (new Functor2("domain_error", Atom.a("prolog_flag"), Key), "Arg 1 Key " + Key + " is not a recognized flag"); bool valueIsOK = false; if (keyName == "char_conversion") valueIsOK = (Value == _prologFlags[keyName]); else if (keyName == "debug") valueIsOK = (Value == _prologFlags[keyName]); else if (keyName == "unknown") valueIsOK = (Value == Atom.a("fail") || Value == Atom.a("warning") || Value == Atom.a("error")); else if (keyName == "double_quotes") valueIsOK = (Value == Atom.a("codes") || Value == Atom.a("chars") || Value == Atom.a("atom")); else throw new PrologException (new Functor3("permission_error", Atom.a("modify"), Atom.a("flag"), Key), "May not modify Prolog flag " + Key); if (!valueIsOK) throw new PrologException (new Functor2("domain_error", Atom.a("flag_value"), new Functor2("+", Key, Value)), "May not set arg 1 Key " + Key + " to arg 2 Value " + Value); _prologFlags[keyName] = Value; } /// <summary> /// script_event calls hosting script with events as a callback method. /// </summary> /// <param name="script_event"></param> /// <param name="script_params"></param> /// <returns></returns> public static IEnumerable<bool> script_event(object script_event, object script_params) { // string function = ((Atom)YP.getValue(script_event))._name; object[] array = ListPair.toArray(script_params); if (array == null) yield return false; // return; // YP.fail(); if (array.Length > 1) { //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue //(localID, itemID, function, array); // sortArray(array); } //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); yield return false; } /* Non-prolog-ish functions for inline coding */ public static string regexString(string inData, string inPattern, string presep,string postsep) { //string str=cycMessage; //string strMatch = @"\. \#\$(.*)\)"; string results = ""; for (Match m = Regex.Match(inData,inPattern); m.Success; m=m.NextMatch()) { //m_log.Debug(m); results += presep+ m + postsep; } return results; } public static string cycComm(object msgobj) { string cycInputString = msgobj.ToString(); string cycOutputString=""; TcpClient socketForServer; try { socketForServer = new TcpClient("localHost", 3601); } catch { m_log.Error("Failed to connect to server at localhost:999"); return ""; } NetworkStream networkStream = socketForServer.GetStream(); System.IO.StreamReader streamReader = new System.IO.StreamReader(networkStream); System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(networkStream); try { // read the data from the host and display it { streamWriter.WriteLine(cycInputString); streamWriter.Flush(); cycOutputString = streamReader.ReadLine(); m_log.Debug("Cycoutput:" + cycOutputString); //streamWriter.WriteLine("Client Message"); //m_log.Debug("Client Message"); streamWriter.Flush(); } } catch { m_log.Error("Exception reading from Server"); return ""; } // tidy up networkStream.Close(); return cycOutputString; } //public static void throwException(object Term) //{ // throw new PrologException(Term); //} /// <summary> /// An enumerator that does zero loops. /// </summary> private class Fail : IEnumerator<bool>, IEnumerable<bool> { public bool MoveNext() { return false; } public IEnumerator<bool> GetEnumerator() { return (IEnumerator<bool>)this; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Current { get { return true; } } object IEnumerator.Current { get { return true; } } public void Dispose() { } public void Reset() { throw new NotImplementedException(); } } /// <summary> /// An enumerator that does one iteration. /// </summary> private class Succeed : IEnumerator<bool>, IEnumerable<bool> { private bool _didIteration = false; public bool MoveNext() { if (!_didIteration) { _didIteration = true; return true; } else return false; } public IEnumerator<bool> GetEnumerator() { return (IEnumerator<bool>)this; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Current { get { return false; } } object IEnumerator.Current { get { return false; } } public void Dispose() { } public void Reset() { throw new NotImplementedException(); } } /// <summary> /// An enumerator that repeats forever. /// </summary> private class Repeat : IEnumerator<bool>, IEnumerable<bool> { public bool MoveNext() { return true; } public IEnumerator<bool> GetEnumerator() { return (IEnumerator<bool>)this; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Current { get { return false; } } object IEnumerator.Current { get { return false; } } public void Dispose() { } public void Reset() { throw new NotImplementedException(); } } /// <summary> /// An enumerator that wraps another enumerator in order to catch a PrologException. /// </summary> public class Catch : IEnumerator<bool>, IEnumerable<bool> { private IEnumerator<bool> _enumerator; private PrologException _exception = null; /// <summary> /// Call YP.getIterator(Goal, declaringClass) and save the returned iterator. /// If getIterator throws an exception, save it the same as MoveNext(). /// </summary> /// <param name="Goal"></param> /// <param name="declaringClass"></param> public Catch(object Goal, Type declaringClass) { try { _enumerator = getIterator(Goal, declaringClass).GetEnumerator(); } catch (PrologException exception) { // MoveNext() will check this. _exception = exception; } } /// <summary> /// Call _enumerator.MoveNext(). If it throws a PrologException, set _exception /// and return false. After this returns false, call unifyExceptionOrThrow. /// </summary> /// <returns></returns> public bool MoveNext() { if (_exception != null) return false; try { return _enumerator.MoveNext(); } catch (PrologException exception) { _exception = exception; return false; } } /// <summary> /// Call this after MoveNext() returns false to check for an exception. If /// MoveNext did not get a PrologException, don't yield. /// Otherwise, unify the exception with Catcher and yield so the caller can /// do the handler code. However, if can't unify with Catcher then throw the exception. /// </summary> /// <param name="Catcher"></param> /// <returns></returns> public IEnumerable<bool> unifyExceptionOrThrow(object Catcher) { if (_exception != null) { bool didUnify = false; foreach (bool l1 in YP.unify(_exception._term, Catcher)) { didUnify = true; yield return false; } if (!didUnify) throw _exception; } } public IEnumerator<bool> GetEnumerator() { return (IEnumerator<bool>)this; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Current { get { return _enumerator.Current; } } object IEnumerator.Current { get { return _enumerator.Current; } } public void Dispose() { if (_enumerator != null) _enumerator.Dispose(); } public void Reset() { throw new NotImplementedException(); } } #pragma warning restore 0168, 0219 /// <summary> /// A ClauseHeadAndBody is used in Compiler.compileAnonymousFunction as a base class /// in order to implement YP.IClause. After creating the object, you must call setHeadAndBody. /// </summary> public class ClauseHeadAndBody { private object _Head; private object _Body; public void setHeadAndBody(object Head, object Body) { _Head = Head; _Body = Body; } public IEnumerable<bool> clause(object Head, object Body) { if (_Head == null || _Body == null) yield break; #pragma warning disable 0168, 0219 foreach (bool l1 in YP.unify(Head, _Head)) { foreach (bool l2 in YP.unify(Body, _Body)) yield return false; } #pragma warning restore 0168, 0219 } } /// <summary> /// CodeListReader extends TextReader and overrides Read to read the next code from /// the CodeList which is a Prolog list of integer character codes. /// </summary> public class CodeListReader : TextReader { private object _CodeList; public CodeListReader(object CodeList) { _CodeList = YP.getValue(CodeList); } /// <summary> /// If the head of _CodeList is an integer, return it and advance the list. Otherwise, /// return -1 for end of file. /// </summary> /// <returns></returns> public override int Read() { Functor2 CodeListPair = _CodeList as Functor2; int code; if (!(CodeListPair != null && CodeListPair._name == Atom.DOT && getInt(CodeListPair._arg1, out code))) { _CodeList = Atom.NIL; return -1; } // Advance. _CodeList = YP.getValue(CodeListPair._arg2); return code; } } } }