From d22a54a19568f8d5e9b6dab1f76f9c5c58682aa5 Mon Sep 17 00:00:00 2001 From: Jeff Ames Date: Sun, 1 Jun 2008 03:01:33 +0000 Subject: Update svn properties. --- .../Modules/World/Archiver/ArchiveConstants.cs | 90 +- .../DotNetEngine/Compiler/LSL/YP2CSConverter.cs | 165 +- .../DotNetEngine/Compiler/YieldProlog/Atom.cs | 436 +- .../Compiler/YieldProlog/BagofAnswers.cs | 468 +- .../Compiler/YieldProlog/FindallAnswers.cs | 206 +- .../DotNetEngine/Compiler/YieldProlog/Functor.cs | 376 +- .../DotNetEngine/Compiler/YieldProlog/Functor1.cs | 222 +- .../DotNetEngine/Compiler/YieldProlog/Functor2.cs | 308 +- .../DotNetEngine/Compiler/YieldProlog/Functor3.cs | 266 +- .../Compiler/YieldProlog/IndexedAnswers.cs | 576 +- .../DotNetEngine/Compiler/YieldProlog/ListPair.cs | 312 +- .../DotNetEngine/Compiler/YieldProlog/Parser.cs | 8914 ++++++++-------- .../Compiler/YieldProlog/PrologException.cs | 142 +- .../DotNetEngine/Compiler/YieldProlog/README.TXT | 810 +- .../YieldProlog/UndefinedPredicateException.cs | 124 +- .../DotNetEngine/Compiler/YieldProlog/Variable.cs | 392 +- .../DotNetEngine/Compiler/YieldProlog/YP.cs | 2880 ++--- .../Compiler/YieldProlog/YPCompiler.cs | 10494 +++++++++---------- doc/doxygen.conf | 2712 ++--- update-svn-properties.py | 1 + 20 files changed, 14945 insertions(+), 14949 deletions(-) diff --git a/OpenSim/Region/Environment/Modules/World/Archiver/ArchiveConstants.cs b/OpenSim/Region/Environment/Modules/World/Archiver/ArchiveConstants.cs index d98814b..faffa2b 100644 --- a/OpenSim/Region/Environment/Modules/World/Archiver/ArchiveConstants.cs +++ b/OpenSim/Region/Environment/Modules/World/Archiver/ArchiveConstants.cs @@ -1,50 +1,50 @@ -/* - * Copyright (c) Contributors, http://opensimulator.org/ - * See CONTRIBUTORS.TXT for a full list of copyright holders. - * - * 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 OpenSim Project 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 DEVELOPERS ``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 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. - */ - -namespace OpenSim.Region.Environment.Modules.World.Archiver -{ - /// - /// Constants for the archiving module - /// - public class ArchiveConstants - { - /// - /// Path for the assets held in an archive - /// +/* + * Copyright (c) Contributors, http://opensimulator.org/ + * See CONTRIBUTORS.TXT for a full list of copyright holders. + * + * 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 OpenSim Project 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 DEVELOPERS ``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 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. + */ + +namespace OpenSim.Region.Environment.Modules.World.Archiver +{ + /// + /// Constants for the archiving module + /// + public class ArchiveConstants + { + /// + /// Path for the assets held in an archive + /// public static readonly string ASSETS_PATH = "assets/"; /// /// Extension used for texture assets in archive /// - public static readonly string TEXTURE_EXTENSION = ".jp2"; - - /// - /// Path for the prims file - /// - public static readonly string PRIMS_PATH = "prims.xml"; - } -} + public static readonly string TEXTURE_EXTENSION = ".jp2"; + + /// + /// Path for the prims file + /// + public static readonly string PRIMS_PATH = "prims.xml"; + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/YP2CSConverter.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/YP2CSConverter.cs index 3fc9e00..557c1c9 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/YP2CSConverter.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/LSL/YP2CSConverter.cs @@ -26,88 +26,83 @@ * */ -using System; -using System.IO; -using System.Collections.Generic; -using System.Text; -using System.Text.RegularExpressions; -using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSL -{ - public class YP2CSConverter - { - public YP2CSConverter() - { - } - - public string Convert(string Script) - { - string CS_code = GenCode(Script); - return CS_code; - } - - - static string GenCode(string myCode) - { - Variable TermList = new Variable(); - Variable FunctionCode = new Variable(); - - string CS_code = ""; - - int cs_pointer = myCode.IndexOf("\n//cs"); - if (cs_pointer > 0) - { - CS_code = myCode.Substring(cs_pointer); // CS code comes after - myCode = myCode.Substring(0, cs_pointer); - } - myCode.Replace("//yp", "%YPCode"); - - - StringWriter myCS_SW = new StringWriter(); - StringReader myCode_SR = new StringReader(" yp_nop_header_nop. \n "+myCode + "\n"); - - YP.see(myCode_SR); - YP.tell(myCS_SW); - - //Console.WriteLine("Mycode\n ===================================\n" + myCode+"\n"); - foreach (bool l1 in Parser.parseInput(TermList)) - { - foreach (bool l2 in YPCompiler.makeFunctionPseudoCode(TermList, FunctionCode)) - { - ListPair VFC = new ListPair(FunctionCode, new Variable()); - //Console.WriteLine("-------------------------") - //Console.WriteLine( FunctionCode.ToString()) - //Console.WriteLine("-------------------------") - YPCompiler.convertFunctionCSharp(FunctionCode); - //YPCompiler.convertStringCodesCSharp(VFC); - - } - } - YP.seen(); - myCS_SW.Close(); - YP.told(); - StringBuilder bu = myCS_SW.GetStringBuilder(); - string finalcode = "//YPEncoded\n" + bu.ToString(); - // FIX script events (we're in the same script) - // 'YP.script_event(Atom.a(@"sayit"),' ==> 'sayit(' - finalcode = Regex.Replace(finalcode, - @"YP.script_event\(Atom.a\(\@\""(.*?)""\)\,", - @"this.$1(", - RegexOptions.Compiled | RegexOptions.Singleline); - finalcode = Regex.Replace(finalcode, - @" static ", - @" ", - RegexOptions.Compiled | RegexOptions.Singleline); - - finalcode = CS_code+"\n\r"+ finalcode; - finalcode = Regex.Replace(finalcode, - @"PrologCallback", - @"public IEnumerable ", - RegexOptions.Compiled | RegexOptions.Singleline); - return finalcode; - } - - - } -} +using System; +using System.IO; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.LSL +{ + public class YP2CSConverter + { + public YP2CSConverter() + { + } + + public string Convert(string Script) + { + string CS_code = GenCode(Script); + return CS_code; + } + + static string GenCode(string myCode) + { + Variable TermList = new Variable(); + Variable FunctionCode = new Variable(); + + string CS_code = ""; + + int cs_pointer = myCode.IndexOf("\n//cs"); + if (cs_pointer > 0) + { + CS_code = myCode.Substring(cs_pointer); // CS code comes after + myCode = myCode.Substring(0, cs_pointer); + } + myCode.Replace("//yp", "%YPCode"); + + StringWriter myCS_SW = new StringWriter(); + StringReader myCode_SR = new StringReader(" yp_nop_header_nop. \n "+myCode + "\n"); + + YP.see(myCode_SR); + YP.tell(myCS_SW); + + //Console.WriteLine("Mycode\n ===================================\n" + myCode+"\n"); + foreach (bool l1 in Parser.parseInput(TermList)) + { + foreach (bool l2 in YPCompiler.makeFunctionPseudoCode(TermList, FunctionCode)) + { + ListPair VFC = new ListPair(FunctionCode, new Variable()); + //Console.WriteLine("-------------------------") + //Console.WriteLine( FunctionCode.ToString()) + //Console.WriteLine("-------------------------") + YPCompiler.convertFunctionCSharp(FunctionCode); + //YPCompiler.convertStringCodesCSharp(VFC); + } + } + YP.seen(); + myCS_SW.Close(); + YP.told(); + StringBuilder bu = myCS_SW.GetStringBuilder(); + string finalcode = "//YPEncoded\n" + bu.ToString(); + // FIX script events (we're in the same script) + // 'YP.script_event(Atom.a(@"sayit"),' ==> 'sayit(' + finalcode = Regex.Replace(finalcode, + @"YP.script_event\(Atom.a\(\@\""(.*?)""\)\,", + @"this.$1(", + RegexOptions.Compiled | RegexOptions.Singleline); + finalcode = Regex.Replace(finalcode, + @" static ", + @" ", + RegexOptions.Compiled | RegexOptions.Singleline); + + finalcode = CS_code+"\n\r"+ finalcode; + finalcode = Regex.Replace(finalcode, + @"PrologCallback", + @"public IEnumerable ", + RegexOptions.Compiled | RegexOptions.Singleline); + return finalcode; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Atom.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Atom.cs index 9b4ca6a..7387ef4 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Atom.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Atom.cs @@ -1,218 +1,218 @@ -/* - * 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.Generic; -using System.Text; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Atom : IUnifiable - { - private static Dictionary _atomStore = new Dictionary(); - public readonly string _name; - public readonly Atom _module; - - /// - /// You should not call this constructor, but use Atom.a instead. - /// - /// - /// - private Atom(string name, Atom module) - { - _name = name; - _module = module; - } - - /// - /// Return the unique Atom object for name where module is null. You should use this to create - /// an Atom instead of calling the Atom constructor. - /// - /// - /// - public static Atom a(string name) - { - Atom atom; - if (!_atomStore.TryGetValue(name, out atom)) - { - atom = new Atom(name, null); - _atomStore[name] = atom; - } - return atom; - } - - /// - /// Return an Atom object with the name and module. If module is null or Atom.NIL, - /// this behaves like Atom.a(name) and returns the unique object where the module is null. - /// If module is not null or Atom.NIL, this may or may not be the same object as another Atom - /// with the same name and module. - /// - /// - /// - /// - public static Atom a(string name, Atom module) - { - if (module == null || module == Atom.NIL) - return a(name); - return new Atom(name, module); - } - - /// - /// If Obj is an Atom unify its _module with Module. If the Atom's _module is null, use Atom.NIL. - /// - /// - /// - /// - public static IEnumerable module(object Obj, object Module) - { - Obj = YP.getValue(Obj); - if (Obj is Atom) - { - if (((Atom)Obj)._module == null) - return YP.unify(Module, Atom.NIL); - else - return YP.unify(Module, ((Atom)Obj)._module); - } - return YP.fail(); - } - - public static readonly Atom NIL = Atom.a("[]"); - public static readonly Atom DOT = Atom.a("."); - public static readonly Atom F = Atom.a("f"); - public static readonly Atom SLASH = Atom.a("/"); - public static readonly Atom HAT = Atom.a("^"); - public static readonly Atom RULE = Atom.a(":-"); - - public IEnumerable unify(object arg) - { - arg = YP.getValue(arg); - if (arg is Atom) - return Equals(arg) ? YP.succeed() : YP.fail(); - else if (arg is Variable) - return ((Variable)arg).unify(this); - else - return YP.fail(); - } - - public void addUniqueVariables(List variableSet) - { - // Atom does not contain variables. - } - - public object makeCopy(Variable.CopyStore copyStore) - { - // Atom does not contain variables that need to be copied. - return this; - } - - public bool termEqual(object term) - { - return Equals(YP.getValue(term)); - } - - public bool ground() - { - // Atom is always ground. - return true; - } - - public override bool Equals(object obj) - { - if (obj is Atom) - { - if (_module == null && ((Atom)obj)._module == null) - // When _declaringClass is null, we always use an identical object from _atomStore. - return this == obj; - // Otherwise, ignore _declaringClass and do a normal string compare on the _name. - return _name == ((Atom)obj)._name; - } - return false; - } - - public override string ToString() - { - return _name; - } - - public override int GetHashCode() - { - // Debug: need to check _declaringClass. - return _name.GetHashCode(); - } - - public string toQuotedString() - { - if (_name.Length == 0) - return "''"; - else if (this == Atom.NIL) - return "[]"; - - StringBuilder result = new StringBuilder(_name.Length); - bool useQuotes = false; - foreach (char c in _name) - { - int cInt = (int)c; - if (c == '\'') - { - result.Append("''"); - useQuotes = true; - } - else if (c == '_' || cInt >= (int)'a' && cInt <= (int)'z' || - cInt >= (int)'A' && cInt <= (int)'Z' || cInt >= (int)'0' && cInt <= (int)'9') - result.Append(c); - else - { - // Debug: Need to handle non-printable chars. - result.Append(c); - useQuotes = true; - } - } - - if (!useQuotes && (int)_name[0] >= (int)'a' && (int)_name[0] <= (int)'z') - return result.ToString(); - else - { - // Surround in single quotes. - result.Append('\''); - return "'" + result; - } - } - - /// - /// Return true if _name is lexicographically less than atom._name. - /// - /// - /// - public bool lessThan(Atom atom) - { - return _name.CompareTo(atom._name) < 0; - } - } -} +/* + * 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.Generic; +using System.Text; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Atom : IUnifiable + { + private static Dictionary _atomStore = new Dictionary(); + public readonly string _name; + public readonly Atom _module; + + /// + /// You should not call this constructor, but use Atom.a instead. + /// + /// + /// + private Atom(string name, Atom module) + { + _name = name; + _module = module; + } + + /// + /// Return the unique Atom object for name where module is null. You should use this to create + /// an Atom instead of calling the Atom constructor. + /// + /// + /// + public static Atom a(string name) + { + Atom atom; + if (!_atomStore.TryGetValue(name, out atom)) + { + atom = new Atom(name, null); + _atomStore[name] = atom; + } + return atom; + } + + /// + /// Return an Atom object with the name and module. If module is null or Atom.NIL, + /// this behaves like Atom.a(name) and returns the unique object where the module is null. + /// If module is not null or Atom.NIL, this may or may not be the same object as another Atom + /// with the same name and module. + /// + /// + /// + /// + public static Atom a(string name, Atom module) + { + if (module == null || module == Atom.NIL) + return a(name); + return new Atom(name, module); + } + + /// + /// If Obj is an Atom unify its _module with Module. If the Atom's _module is null, use Atom.NIL. + /// + /// + /// + /// + public static IEnumerable module(object Obj, object Module) + { + Obj = YP.getValue(Obj); + if (Obj is Atom) + { + if (((Atom)Obj)._module == null) + return YP.unify(Module, Atom.NIL); + else + return YP.unify(Module, ((Atom)Obj)._module); + } + return YP.fail(); + } + + public static readonly Atom NIL = Atom.a("[]"); + public static readonly Atom DOT = Atom.a("."); + public static readonly Atom F = Atom.a("f"); + public static readonly Atom SLASH = Atom.a("/"); + public static readonly Atom HAT = Atom.a("^"); + public static readonly Atom RULE = Atom.a(":-"); + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Atom) + return Equals(arg) ? YP.succeed() : YP.fail(); + else if (arg is Variable) + return ((Variable)arg).unify(this); + else + return YP.fail(); + } + + public void addUniqueVariables(List variableSet) + { + // Atom does not contain variables. + } + + public object makeCopy(Variable.CopyStore copyStore) + { + // Atom does not contain variables that need to be copied. + return this; + } + + public bool termEqual(object term) + { + return Equals(YP.getValue(term)); + } + + public bool ground() + { + // Atom is always ground. + return true; + } + + public override bool Equals(object obj) + { + if (obj is Atom) + { + if (_module == null && ((Atom)obj)._module == null) + // When _declaringClass is null, we always use an identical object from _atomStore. + return this == obj; + // Otherwise, ignore _declaringClass and do a normal string compare on the _name. + return _name == ((Atom)obj)._name; + } + return false; + } + + public override string ToString() + { + return _name; + } + + public override int GetHashCode() + { + // Debug: need to check _declaringClass. + return _name.GetHashCode(); + } + + public string toQuotedString() + { + if (_name.Length == 0) + return "''"; + else if (this == Atom.NIL) + return "[]"; + + StringBuilder result = new StringBuilder(_name.Length); + bool useQuotes = false; + foreach (char c in _name) + { + int cInt = (int)c; + if (c == '\'') + { + result.Append("''"); + useQuotes = true; + } + else if (c == '_' || cInt >= (int)'a' && cInt <= (int)'z' || + cInt >= (int)'A' && cInt <= (int)'Z' || cInt >= (int)'0' && cInt <= (int)'9') + result.Append(c); + else + { + // Debug: Need to handle non-printable chars. + result.Append(c); + useQuotes = true; + } + } + + if (!useQuotes && (int)_name[0] >= (int)'a' && (int)_name[0] <= (int)'z') + return result.ToString(); + else + { + // Surround in single quotes. + result.Append('\''); + return "'" + result; + } + } + + /// + /// Return true if _name is lexicographically less than atom._name. + /// + /// + /// + public bool lessThan(Atom atom) + { + return _name.CompareTo(atom._name) < 0; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/BagofAnswers.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/BagofAnswers.cs index 6aea6f7..88ffdb7 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/BagofAnswers.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/BagofAnswers.cs @@ -1,234 +1,234 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// A BagofAnswers holds answers for bagof and setof. - /// - public class BagofAnswers - { - private object _template; - private Variable[] _freeVariables; - private Dictionary> _bagForFreeVariables; - private List _findallBagArray; - private static TermArrayEqualityComparer _termArrayEqualityComparer = - new TermArrayEqualityComparer(); - - /// - /// To get the free variables, split off any existential qualifiers from Goal such as the X in - /// "X ^ f(Y)", get the set of unbound variables in Goal that are not qualifiers, then remove - /// the unbound variables that are qualifiers as well as the unbound variables in Template. - /// - /// - /// - public BagofAnswers(object Template, object Goal) - { - _template = Template; - - // First get the set of variables that are not free variables. - List variableSet = new List(); - YP.addUniqueVariables(Template, variableSet); - object UnqualifiedGoal = YP.getValue(Goal); - while (UnqualifiedGoal is Functor2 && ((Functor2)UnqualifiedGoal)._name == Atom.HAT) - { - YP.addUniqueVariables(((Functor2)UnqualifiedGoal)._arg1, variableSet); - UnqualifiedGoal = YP.getValue(((Functor2)UnqualifiedGoal)._arg2); - } - - // Remember how many non-free variables there are so we can find the unique free variables - // that are added. - int nNonFreeVariables = variableSet.Count; - YP.addUniqueVariables(UnqualifiedGoal, variableSet); - int nFreeVariables = variableSet.Count - nNonFreeVariables; - if (nFreeVariables == 0) - { - // There were no free variables added, so we won't waste time with _bagForFreeVariables. - _freeVariables = null; - _findallBagArray = new List(); - } - else - { - // Copy the free variables. - _freeVariables = new Variable[nFreeVariables]; - for (int i = 0; i < nFreeVariables; ++i) - _freeVariables[i] = variableSet[i + nNonFreeVariables]; - - _bagForFreeVariables = new Dictionary>(_termArrayEqualityComparer); - } - } - - public void add() - { - if (_freeVariables == null) - // The goal has bound the values in _template but we don't bother with _freeVariables. - _findallBagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); - else - { - // The goal has bound the values in _template and _freeVariables. - // Find the entry for this set of _freeVariables values. - object[] freeVariableValues = new object[_freeVariables.Length]; - for (int i = 0; i < _freeVariables.Length; ++i) - freeVariableValues[i] = YP.getValue(_freeVariables[i]); - List bagArray; - if (!_bagForFreeVariables.TryGetValue(freeVariableValues, out bagArray)) - { - bagArray = new List(); - _bagForFreeVariables[freeVariableValues] = bagArray; - } - - // Now copy the template and add to the bag for the freeVariables values. - bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); - } - } - - /// - /// For each result, unify the _freeVariables and unify bagArrayVariable with the associated bag. - /// - /// this is unified with the List of matches for template that - /// corresponds to the bindings for freeVariables. Be very careful: this does not unify with a Prolog - /// list. - /// - public IEnumerable resultArray(Variable bagArrayVariable) - { - if (_freeVariables == null) - { - // No unbound free variables, so we only filled one bag. If empty, bagof fails. - if (_findallBagArray.Count > 0) - { - foreach (bool l1 in bagArrayVariable.unify(_findallBagArray)) - yield return false; - } - } - else - { - foreach (KeyValuePair> valuesAndBag in _bagForFreeVariables) - { - foreach (bool l1 in YP.unifyArrays(_freeVariables, valuesAndBag.Key)) - { - foreach (bool l2 in bagArrayVariable.unify(valuesAndBag.Value)) - yield return false; - } - // Debug: Should we free memory of the answers already returned? - } - } - } - - /// - /// For each result, unify the _freeVariables and unify Bag with the associated bag. - /// - /// - /// - public IEnumerable result(object Bag) - { - Variable bagArrayVariable = new Variable(); - foreach (bool l1 in resultArray(bagArrayVariable)) - { - foreach (bool l2 in YP.unify(Bag, ListPair.make((List)bagArrayVariable.getValue()))) - yield return false; - } - } - - /// - /// For each result, unify the _freeVariables and unify Bag with the associated bag which is sorted - /// with duplicates removed, as in setof. - /// - /// - /// - public IEnumerable resultSet(object Bag) - { - Variable bagArrayVariable = new Variable(); - foreach (bool l1 in resultArray(bagArrayVariable)) - { - List bagArray = (List)bagArrayVariable.getValue(); - YP.sortArray(bagArray); - foreach (bool l2 in YP.unify(Bag, ListPair.makeWithoutRepeatedTerms(bagArray))) - yield return false; - } - } - - public static IEnumerable bagofArray - (object Template, object Goal, IEnumerable goalIterator, Variable bagArrayVariable) - { - BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); - foreach (bool l1 in goalIterator) - bagOfAnswers.add(); - return bagOfAnswers.resultArray(bagArrayVariable); - } - - public static IEnumerable bagof - (object Template, object Goal, IEnumerable goalIterator, object Bag) - { - BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); - foreach (bool l1 in goalIterator) - bagOfAnswers.add(); - return bagOfAnswers.result(Bag); - } - - public static IEnumerable setof - (object Template, object Goal, IEnumerable goalIterator, object Bag) - { - BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); - foreach (bool l1 in goalIterator) - bagOfAnswers.add(); - return bagOfAnswers.resultSet(Bag); - } - - /// - /// A TermArrayEqualityComparer implements IEqualityComparer to compare two object arrays using YP.termEqual. - /// - private class TermArrayEqualityComparer : IEqualityComparer - { - public bool Equals(object[] array1, object[] array2) - { - if (array1.Length != array2.Length) - return false; - for (int i = 0; i < array1.Length; ++i) - { - if (!YP.termEqual(array1[i], array2[i])) - return false; - } - return true; - } - - public int GetHashCode(object[] array) - { - int hashCode = 0; - for (int i = 0; i < array.Length; ++i) - hashCode ^= array[i].GetHashCode(); - return hashCode; - } - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// A BagofAnswers holds answers for bagof and setof. + /// + public class BagofAnswers + { + private object _template; + private Variable[] _freeVariables; + private Dictionary> _bagForFreeVariables; + private List _findallBagArray; + private static TermArrayEqualityComparer _termArrayEqualityComparer = + new TermArrayEqualityComparer(); + + /// + /// To get the free variables, split off any existential qualifiers from Goal such as the X in + /// "X ^ f(Y)", get the set of unbound variables in Goal that are not qualifiers, then remove + /// the unbound variables that are qualifiers as well as the unbound variables in Template. + /// + /// + /// + public BagofAnswers(object Template, object Goal) + { + _template = Template; + + // First get the set of variables that are not free variables. + List variableSet = new List(); + YP.addUniqueVariables(Template, variableSet); + object UnqualifiedGoal = YP.getValue(Goal); + while (UnqualifiedGoal is Functor2 && ((Functor2)UnqualifiedGoal)._name == Atom.HAT) + { + YP.addUniqueVariables(((Functor2)UnqualifiedGoal)._arg1, variableSet); + UnqualifiedGoal = YP.getValue(((Functor2)UnqualifiedGoal)._arg2); + } + + // Remember how many non-free variables there are so we can find the unique free variables + // that are added. + int nNonFreeVariables = variableSet.Count; + YP.addUniqueVariables(UnqualifiedGoal, variableSet); + int nFreeVariables = variableSet.Count - nNonFreeVariables; + if (nFreeVariables == 0) + { + // There were no free variables added, so we won't waste time with _bagForFreeVariables. + _freeVariables = null; + _findallBagArray = new List(); + } + else + { + // Copy the free variables. + _freeVariables = new Variable[nFreeVariables]; + for (int i = 0; i < nFreeVariables; ++i) + _freeVariables[i] = variableSet[i + nNonFreeVariables]; + + _bagForFreeVariables = new Dictionary>(_termArrayEqualityComparer); + } + } + + public void add() + { + if (_freeVariables == null) + // The goal has bound the values in _template but we don't bother with _freeVariables. + _findallBagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + else + { + // The goal has bound the values in _template and _freeVariables. + // Find the entry for this set of _freeVariables values. + object[] freeVariableValues = new object[_freeVariables.Length]; + for (int i = 0; i < _freeVariables.Length; ++i) + freeVariableValues[i] = YP.getValue(_freeVariables[i]); + List bagArray; + if (!_bagForFreeVariables.TryGetValue(freeVariableValues, out bagArray)) + { + bagArray = new List(); + _bagForFreeVariables[freeVariableValues] = bagArray; + } + + // Now copy the template and add to the bag for the freeVariables values. + bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + } + } + + /// + /// For each result, unify the _freeVariables and unify bagArrayVariable with the associated bag. + /// + /// this is unified with the List of matches for template that + /// corresponds to the bindings for freeVariables. Be very careful: this does not unify with a Prolog + /// list. + /// + public IEnumerable resultArray(Variable bagArrayVariable) + { + if (_freeVariables == null) + { + // No unbound free variables, so we only filled one bag. If empty, bagof fails. + if (_findallBagArray.Count > 0) + { + foreach (bool l1 in bagArrayVariable.unify(_findallBagArray)) + yield return false; + } + } + else + { + foreach (KeyValuePair> valuesAndBag in _bagForFreeVariables) + { + foreach (bool l1 in YP.unifyArrays(_freeVariables, valuesAndBag.Key)) + { + foreach (bool l2 in bagArrayVariable.unify(valuesAndBag.Value)) + yield return false; + } + // Debug: Should we free memory of the answers already returned? + } + } + } + + /// + /// For each result, unify the _freeVariables and unify Bag with the associated bag. + /// + /// + /// + public IEnumerable result(object Bag) + { + Variable bagArrayVariable = new Variable(); + foreach (bool l1 in resultArray(bagArrayVariable)) + { + foreach (bool l2 in YP.unify(Bag, ListPair.make((List)bagArrayVariable.getValue()))) + yield return false; + } + } + + /// + /// For each result, unify the _freeVariables and unify Bag with the associated bag which is sorted + /// with duplicates removed, as in setof. + /// + /// + /// + public IEnumerable resultSet(object Bag) + { + Variable bagArrayVariable = new Variable(); + foreach (bool l1 in resultArray(bagArrayVariable)) + { + List bagArray = (List)bagArrayVariable.getValue(); + YP.sortArray(bagArray); + foreach (bool l2 in YP.unify(Bag, ListPair.makeWithoutRepeatedTerms(bagArray))) + yield return false; + } + } + + public static IEnumerable bagofArray + (object Template, object Goal, IEnumerable goalIterator, Variable bagArrayVariable) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.resultArray(bagArrayVariable); + } + + public static IEnumerable bagof + (object Template, object Goal, IEnumerable goalIterator, object Bag) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.result(Bag); + } + + public static IEnumerable setof + (object Template, object Goal, IEnumerable goalIterator, object Bag) + { + BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); + foreach (bool l1 in goalIterator) + bagOfAnswers.add(); + return bagOfAnswers.resultSet(Bag); + } + + /// + /// A TermArrayEqualityComparer implements IEqualityComparer to compare two object arrays using YP.termEqual. + /// + private class TermArrayEqualityComparer : IEqualityComparer + { + public bool Equals(object[] array1, object[] array2) + { + if (array1.Length != array2.Length) + return false; + for (int i = 0; i < array1.Length; ++i) + { + if (!YP.termEqual(array1[i], array2[i])) + return false; + } + return true; + } + + public int GetHashCode(object[] array) + { + int hashCode = 0; + for (int i = 0; i < array.Length; ++i) + hashCode ^= array[i].GetHashCode(); + return hashCode; + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/FindallAnswers.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/FindallAnswers.cs index 2978cee..dcd4250 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/FindallAnswers.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/FindallAnswers.cs @@ -1,103 +1,103 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// A FindallAnswers holds answers for findall. - /// - public class FindallAnswers - { - private object _template; - private List _bagArray; - - public FindallAnswers(object Template) - { - _template = Template; - _bagArray = new List(); - } - - public void add() - { - _bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); - } - - public List resultArray() - { - return _bagArray; - } - - /// - /// Unify Bag with the result. This frees the internal answers, so you can only call this once. - /// - /// - /// - public IEnumerable result(object Bag) - { - object result = ListPair.make(_bagArray); - // Try to free the memory. - _bagArray = null; - return YP.unify(Bag, result); - } - - /// - /// This is a simplified findall when the goal is a single call. - /// - /// - /// - /// - /// - public static IEnumerable findall(object Template, IEnumerable goal, object Bag) - { - FindallAnswers findallAnswers = new FindallAnswers(Template); - foreach (bool l1 in goal) - findallAnswers.add(); - return findallAnswers.result(Bag); - } - - /// - /// Like findall, except return an array of the results. - /// - /// - /// - /// - public static List findallArray(object Template, IEnumerable goal) - { - FindallAnswers findallAnswers = new FindallAnswers(Template); - foreach (bool l1 in goal) - findallAnswers.add(); - return findallAnswers.resultArray(); - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// A FindallAnswers holds answers for findall. + /// + public class FindallAnswers + { + private object _template; + private List _bagArray; + + public FindallAnswers(object Template) + { + _template = Template; + _bagArray = new List(); + } + + public void add() + { + _bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); + } + + public List resultArray() + { + return _bagArray; + } + + /// + /// Unify Bag with the result. This frees the internal answers, so you can only call this once. + /// + /// + /// + public IEnumerable result(object Bag) + { + object result = ListPair.make(_bagArray); + // Try to free the memory. + _bagArray = null; + return YP.unify(Bag, result); + } + + /// + /// This is a simplified findall when the goal is a single call. + /// + /// + /// + /// + /// + public static IEnumerable findall(object Template, IEnumerable goal, object Bag) + { + FindallAnswers findallAnswers = new FindallAnswers(Template); + foreach (bool l1 in goal) + findallAnswers.add(); + return findallAnswers.result(Bag); + } + + /// + /// Like findall, except return an array of the results. + /// + /// + /// + /// + public static List findallArray(object Template, IEnumerable goal) + { + FindallAnswers findallAnswers = new FindallAnswers(Template); + foreach (bool l1 in goal) + findallAnswers.add(); + return findallAnswers.resultArray(); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor.cs index 3ba1021..58c0e4b 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor.cs @@ -1,188 +1,188 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Functor : IUnifiable - { - public readonly Atom _name; - public readonly object[] _args; - - public Functor(Atom name, object[] args) - { - if (args.Length <= 3) - { - if (args.Length == 0) - throw new Exception("For arity 0 functor, just use name as an Atom"); - else if (args.Length == 1) - throw new Exception("For arity 1 functor, use Functor1"); - else if (args.Length == 2) - throw new Exception("For arity 2 functor, use Functor2"); - else if (args.Length == 3) - throw new Exception("For arity 3 functor, use Functor3"); - else - // (This shouldn't happen, but include it for completeness. - throw new Exception("Cannot create a Functor of arity " + args.Length); - } - - _name = name; - _args = args; - } - - public Functor(string name, object[] args) - : this(Atom.a(name), args) - { - } - - /// - /// Return an Atom, Functor1, Functor2, Functor3 or Functor depending on the - /// length of args. - /// Note that this is different than the Functor constructor which requires - /// the length of args to be greater than 3. - /// - /// - /// - /// - public static object make(Atom name, object[] args) - { - if (args.Length <= 0) - return name; - else if (args.Length == 1) - return new Functor1(name, args[0]); - else if (args.Length == 2) - return new Functor2(name, args[0], args[1]); - else if (args.Length == 3) - return new Functor3(name, args[0], args[1], args[2]); - else - return new Functor(name, args); - } - - /// - /// Call the main make, first converting name to an Atom. - /// - /// - /// - /// - public static object make(string name, object[] args) - { - return make(Atom.a(name), args); - } - - public IEnumerable unify(object arg) - { - arg = YP.getValue(arg); - if (arg is Functor) - { - Functor argFunctor = (Functor)arg; - if (_name.Equals(argFunctor._name)) - return YP.unifyArrays(_args, argFunctor._args); - else - return YP.fail(); - } - else if (arg is Variable) - return ((Variable)arg).unify(this); - else - return YP.fail(); - } - - public override string ToString() - { - string result = _name + "(" + YP.getValue(_args[0]); - for (int i = 1; i < _args.Length; ++i) - result += ", " + YP.getValue(_args[i]); - result += ")"; - return result; - } - - public bool termEqual(object term) - { - term = YP.getValue(term); - if (term is Functor) - { - Functor termFunctor = (Functor)term; - if (_name.Equals(termFunctor._name) && _args.Length == termFunctor._args.Length) - { - for (int i = 0; i < _args.Length; ++i) - { - if (!YP.termEqual(_args[i], termFunctor._args[i])) - return false; - } - return true; - } - } - return false; - } - - public bool lessThan(Functor functor) - { - // Do the equal check first since it is faster. - if (!_name.Equals(functor._name)) - return _name.lessThan(functor._name); - - if (_args.Length != functor._args.Length) - return _args.Length < functor._args.Length; - - for (int i = 0; i < _args.Length; ++i) - { - if (!YP.termEqual(_args[i], functor._args[i])) - return YP.termLessThan(_args[i], functor._args[i]); - } - - return false; - } - - public bool ground() - { - for (int i = 0; i < _args.Length; ++i) - { - if (!YP.ground(_args[i])) - return false; - } - return true; - } - - public void addUniqueVariables(List variableSet) - { - for (int i = 0; i < _args.Length; ++i) - YP.addUniqueVariables(_args[i], variableSet); - } - - public object makeCopy(Variable.CopyStore copyStore) - { - object[] argsCopy = new object[_args.Length]; - for (int i = 0; i < _args.Length; ++i) - argsCopy[i] = YP.makeCopy(_args[i], copyStore); - return new Functor(_name, argsCopy); - } - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Functor : IUnifiable + { + public readonly Atom _name; + public readonly object[] _args; + + public Functor(Atom name, object[] args) + { + if (args.Length <= 3) + { + if (args.Length == 0) + throw new Exception("For arity 0 functor, just use name as an Atom"); + else if (args.Length == 1) + throw new Exception("For arity 1 functor, use Functor1"); + else if (args.Length == 2) + throw new Exception("For arity 2 functor, use Functor2"); + else if (args.Length == 3) + throw new Exception("For arity 3 functor, use Functor3"); + else + // (This shouldn't happen, but include it for completeness. + throw new Exception("Cannot create a Functor of arity " + args.Length); + } + + _name = name; + _args = args; + } + + public Functor(string name, object[] args) + : this(Atom.a(name), args) + { + } + + /// + /// Return an Atom, Functor1, Functor2, Functor3 or Functor depending on the + /// length of args. + /// Note that this is different than the Functor constructor which requires + /// the length of args to be greater than 3. + /// + /// + /// + /// + public static object make(Atom name, object[] args) + { + if (args.Length <= 0) + return name; + else if (args.Length == 1) + return new Functor1(name, args[0]); + else if (args.Length == 2) + return new Functor2(name, args[0], args[1]); + else if (args.Length == 3) + return new Functor3(name, args[0], args[1], args[2]); + else + return new Functor(name, args); + } + + /// + /// Call the main make, first converting name to an Atom. + /// + /// + /// + /// + public static object make(string name, object[] args) + { + return make(Atom.a(name), args); + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor) + { + Functor argFunctor = (Functor)arg; + if (_name.Equals(argFunctor._name)) + return YP.unifyArrays(_args, argFunctor._args); + else + return YP.fail(); + } + else if (arg is Variable) + return ((Variable)arg).unify(this); + else + return YP.fail(); + } + + public override string ToString() + { + string result = _name + "(" + YP.getValue(_args[0]); + for (int i = 1; i < _args.Length; ++i) + result += ", " + YP.getValue(_args[i]); + result += ")"; + return result; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor) + { + Functor termFunctor = (Functor)term; + if (_name.Equals(termFunctor._name) && _args.Length == termFunctor._args.Length) + { + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.termEqual(_args[i], termFunctor._args[i])) + return false; + } + return true; + } + } + return false; + } + + public bool lessThan(Functor functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (_args.Length != functor._args.Length) + return _args.Length < functor._args.Length; + + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.termEqual(_args[i], functor._args[i])) + return YP.termLessThan(_args[i], functor._args[i]); + } + + return false; + } + + public bool ground() + { + for (int i = 0; i < _args.Length; ++i) + { + if (!YP.ground(_args[i])) + return false; + } + return true; + } + + public void addUniqueVariables(List variableSet) + { + for (int i = 0; i < _args.Length; ++i) + YP.addUniqueVariables(_args[i], variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + object[] argsCopy = new object[_args.Length]; + for (int i = 0; i < _args.Length; ++i) + argsCopy[i] = YP.makeCopy(_args[i], copyStore); + return new Functor(_name, argsCopy); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor1.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor1.cs index 33e2a32..582cd20 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor1.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor1.cs @@ -1,111 +1,111 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Functor1 : IUnifiable - { - public readonly Atom _name; - public readonly object _arg1; - - public Functor1(Atom name, object arg1) - { - _name = name; - _arg1 = arg1; - } - - public Functor1(string name, object arg1) - : this(Atom.a(name), arg1) - { - } - - public IEnumerable unify(object arg) - { - arg = YP.getValue(arg); - if (arg is Functor1) - { - Functor1 argFunctor = (Functor1)arg; - if (_name.Equals(argFunctor._name)) - { - foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) - yield return false; - } - } - else if (arg is Variable) - { - foreach (bool l1 in ((Variable)arg).unify(this)) - yield return false; - } - } - - public override string ToString() - { - return _name + "(" + YP.getValue(_arg1) + ")"; - } - - public bool termEqual(object term) - { - term = YP.getValue(term); - if (term is Functor1) - { - Functor1 termFunctor = (Functor1)term; - return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1); - } - return false; - } - - public bool lessThan(Functor1 functor) - { - // Do the equal check first since it is faster. - if (!_name.Equals(functor._name)) - return _name.lessThan(functor._name); - - return YP.termLessThan(_arg1, functor._arg1); - } - - public bool ground() - { - return YP.ground(_arg1); - } - - public void addUniqueVariables(List variableSet) - { - YP.addUniqueVariables(_arg1, variableSet); - } - - public object makeCopy(Variable.CopyStore copyStore) - { - return new Functor1(_name, YP.makeCopy(_arg1, copyStore)); - } - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Functor1 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + + public Functor1(Atom name, object arg1) + { + _name = name; + _arg1 = arg1; + } + + public Functor1(string name, object arg1) + : this(Atom.a(name), arg1) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor1) + { + Functor1 argFunctor = (Functor1)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + yield return false; + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + return _name + "(" + YP.getValue(_arg1) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor1) + { + Functor1 termFunctor = (Functor1)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1); + } + return false; + } + + public bool lessThan(Functor1 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + return YP.termLessThan(_arg1, functor._arg1); + } + + public bool ground() + { + return YP.ground(_arg1); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor1(_name, YP.makeCopy(_arg1, copyStore)); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor2.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor2.cs index 87c5f1b..138a44c 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor2.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor2.cs @@ -1,154 +1,154 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Functor2 : IUnifiable - { - public readonly Atom _name; - public readonly object _arg1; - public readonly object _arg2; - - public Functor2(Atom name, object arg1, object arg2) - { - _name = name; - _arg1 = arg1; - _arg2 = arg2; - } - - public Functor2(string name, object arg1, object arg2) - : this(Atom.a(name), arg1, arg2) - { - } - - public IEnumerable unify(object arg) - { - arg = YP.getValue(arg); - if (arg is Functor2) - { - Functor2 argFunctor = (Functor2)arg; - if (_name.Equals(argFunctor._name)) - { - foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) - { - foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) - yield return false; - } - } - } - else if (arg is Variable) - { - foreach (bool l1 in ((Variable)arg).unify(this)) - yield return false; - } - } - - public override string ToString() - { - if (_name == Atom.DOT) - return listPairToString(this); - else - return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ")"; - } - - public bool termEqual(object term) - { - term = YP.getValue(term); - if (term is Functor2) - { - Functor2 termFunctor = (Functor2)term; - return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) - && YP.termEqual(_arg2, termFunctor._arg2); - } - return false; - } - - public bool lessThan(Functor2 functor) - { - // Do the equal check first since it is faster. - if (!_name.Equals(functor._name)) - return _name.lessThan(functor._name); - - if (!YP.termEqual(_arg1, functor._arg1)) - return YP.termLessThan(_arg1, functor._arg1); - - return YP.termLessThan(_arg2, functor._arg2); - } - - public bool ground() - { - return YP.ground(_arg1) && YP.ground(_arg2); - } - - public void addUniqueVariables(List variableSet) - { - YP.addUniqueVariables(_arg1, variableSet); - YP.addUniqueVariables(_arg2, variableSet); - } - - public object makeCopy(Variable.CopyStore copyStore) - { - return new Functor2(_name, YP.makeCopy(_arg1, copyStore), - YP.makeCopy(_arg2, copyStore)); - } - - private static string listPairToString(Functor2 listPair) - { - string result = "["; - while (true) - { - object head = YP.getValue(listPair._arg1); - object tail = YP.getValue(listPair._arg2); - if (tail == (object)Atom.NIL) - { - result += head; - break; - } - else if (tail is Functor2 && ((Functor2)tail)._name == Atom.DOT) - { - result += head + ", "; - listPair = (Functor2)tail; - // Loop again. - } - else - { - // The list is not terminated with NIL. - result += head + "|" + tail; - break; - } - } - result += "]"; - return result; - } - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Functor2 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + public readonly object _arg2; + + public Functor2(Atom name, object arg1, object arg2) + { + _name = name; + _arg1 = arg1; + _arg2 = arg2; + } + + public Functor2(string name, object arg1, object arg2) + : this(Atom.a(name), arg1, arg2) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor2) + { + Functor2 argFunctor = (Functor2)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + { + foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) + yield return false; + } + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + if (_name == Atom.DOT) + return listPairToString(this); + else + return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor2) + { + Functor2 termFunctor = (Functor2)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) + && YP.termEqual(_arg2, termFunctor._arg2); + } + return false; + } + + public bool lessThan(Functor2 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (!YP.termEqual(_arg1, functor._arg1)) + return YP.termLessThan(_arg1, functor._arg1); + + return YP.termLessThan(_arg2, functor._arg2); + } + + public bool ground() + { + return YP.ground(_arg1) && YP.ground(_arg2); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + YP.addUniqueVariables(_arg2, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor2(_name, YP.makeCopy(_arg1, copyStore), + YP.makeCopy(_arg2, copyStore)); + } + + private static string listPairToString(Functor2 listPair) + { + string result = "["; + while (true) + { + object head = YP.getValue(listPair._arg1); + object tail = YP.getValue(listPair._arg2); + if (tail == (object)Atom.NIL) + { + result += head; + break; + } + else if (tail is Functor2 && ((Functor2)tail)._name == Atom.DOT) + { + result += head + ", "; + listPair = (Functor2)tail; + // Loop again. + } + else + { + // The list is not terminated with NIL. + result += head + "|" + tail; + break; + } + } + result += "]"; + return result; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor3.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor3.cs index 74418c4..b52fdf3 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor3.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Functor3.cs @@ -1,133 +1,133 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Functor3 : IUnifiable - { - public readonly Atom _name; - public readonly object _arg1; - public readonly object _arg2; - public readonly object _arg3; - - public Functor3(Atom name, object arg1, object arg2, object arg3) - { - _name = name; - _arg1 = arg1; - _arg2 = arg2; - _arg3 = arg3; - } - - public Functor3(string name, object arg1, object arg2, object arg3) - : this(Atom.a(name), arg1, arg2, arg3) - { - } - - public IEnumerable unify(object arg) - { - arg = YP.getValue(arg); - if (arg is Functor3) - { - Functor3 argFunctor = (Functor3)arg; - if (_name.Equals(argFunctor._name)) - { - foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) - { - foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) - { - foreach (bool l3 in YP.unify(_arg3, argFunctor._arg3)) - yield return false; - } - } - } - } - else if (arg is Variable) - { - foreach (bool l1 in ((Variable)arg).unify(this)) - yield return false; - } - } - - public override string ToString() - { - return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ", " + - YP.getValue(_arg3) + ")"; - } - - public bool termEqual(object term) - { - term = YP.getValue(term); - if (term is Functor3) - { - Functor3 termFunctor = (Functor3)term; - return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) - && YP.termEqual(_arg2, termFunctor._arg2) - && YP.termEqual(_arg3, termFunctor._arg3); - } - return false; - } - - public bool lessThan(Functor3 functor) - { - // Do the equal check first since it is faster. - if (!_name.Equals(functor._name)) - return _name.lessThan(functor._name); - - if (!YP.termEqual(_arg1, functor._arg1)) - return YP.termLessThan(_arg1, functor._arg1); - - if (!YP.termEqual(_arg2, functor._arg2)) - return YP.termLessThan(_arg2, functor._arg2); - - return YP.termLessThan(_arg3, functor._arg3); - } - - public bool ground() - { - return YP.ground(_arg1) && YP.ground(_arg2) && YP.ground(_arg3); - } - - public void addUniqueVariables(List variableSet) - { - YP.addUniqueVariables(_arg1, variableSet); - YP.addUniqueVariables(_arg2, variableSet); - YP.addUniqueVariables(_arg3, variableSet); - } - - public object makeCopy(Variable.CopyStore copyStore) - { - return new Functor3(_name, YP.makeCopy(_arg1, copyStore), - YP.makeCopy(_arg2, copyStore), YP.makeCopy(_arg3, copyStore)); - } - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Functor3 : IUnifiable + { + public readonly Atom _name; + public readonly object _arg1; + public readonly object _arg2; + public readonly object _arg3; + + public Functor3(Atom name, object arg1, object arg2, object arg3) + { + _name = name; + _arg1 = arg1; + _arg2 = arg2; + _arg3 = arg3; + } + + public Functor3(string name, object arg1, object arg2, object arg3) + : this(Atom.a(name), arg1, arg2, arg3) + { + } + + public IEnumerable unify(object arg) + { + arg = YP.getValue(arg); + if (arg is Functor3) + { + Functor3 argFunctor = (Functor3)arg; + if (_name.Equals(argFunctor._name)) + { + foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) + { + foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) + { + foreach (bool l3 in YP.unify(_arg3, argFunctor._arg3)) + yield return false; + } + } + } + } + else if (arg is Variable) + { + foreach (bool l1 in ((Variable)arg).unify(this)) + yield return false; + } + } + + public override string ToString() + { + return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ", " + + YP.getValue(_arg3) + ")"; + } + + public bool termEqual(object term) + { + term = YP.getValue(term); + if (term is Functor3) + { + Functor3 termFunctor = (Functor3)term; + return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) + && YP.termEqual(_arg2, termFunctor._arg2) + && YP.termEqual(_arg3, termFunctor._arg3); + } + return false; + } + + public bool lessThan(Functor3 functor) + { + // Do the equal check first since it is faster. + if (!_name.Equals(functor._name)) + return _name.lessThan(functor._name); + + if (!YP.termEqual(_arg1, functor._arg1)) + return YP.termLessThan(_arg1, functor._arg1); + + if (!YP.termEqual(_arg2, functor._arg2)) + return YP.termLessThan(_arg2, functor._arg2); + + return YP.termLessThan(_arg3, functor._arg3); + } + + public bool ground() + { + return YP.ground(_arg1) && YP.ground(_arg2) && YP.ground(_arg3); + } + + public void addUniqueVariables(List variableSet) + { + YP.addUniqueVariables(_arg1, variableSet); + YP.addUniqueVariables(_arg2, variableSet); + YP.addUniqueVariables(_arg3, variableSet); + } + + public object makeCopy(Variable.CopyStore copyStore) + { + return new Functor3(_name, YP.makeCopy(_arg1, copyStore), + YP.makeCopy(_arg2, copyStore), YP.makeCopy(_arg3, copyStore)); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/IndexedAnswers.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/IndexedAnswers.cs index 3eac5fa..05b0a01 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/IndexedAnswers.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/IndexedAnswers.cs @@ -1,288 +1,288 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// An IndexedAnswers holds answers to a query based on the values of index arguments. - /// - public class IndexedAnswers : YP.IClause - { - // addAnswer adds the answer here and indexes it later. - private List _allAnswers = new List(); - // The key has the arity of answers with non-null values for each indexed arg. The value - // is a list of the matching answers. The signature is implicit in the pattern on non-null index args. - private Dictionary> _indexedAnswers = - new Dictionary>(); - // Keeps track of whether we have started adding entries to _indexedAnswers for the signature. - private Dictionary _gotAnswersForSignature = new Dictionary(); - private const int MAX_INDEX_ARGS = 31; - - public IndexedAnswers() - { - } - - /// - /// Elements of answer must be ground, since arguments with unbound variables make this - /// into a dynamic rule which we don't index. - /// - /// - public void addAnswer(object[] answer) - { - // Store a copy of the answer array. - object[] answerCopy = new object[answer.Length]; - Variable.CopyStore copyStore = new Variable.CopyStore(); - for (int i = 0; i < answer.Length; ++i) - answerCopy[i] = YP.makeCopy(answer[i], copyStore); - if (copyStore.getNUniqueVariables() > 0) - throw new InvalidOperationException - ("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() + - " unbound variables"); - _allAnswers.Add(answerCopy); - - // If match has already indexed answers for a signature, we need to add - // this to the existing indexed answers. - foreach(int signature in _gotAnswersForSignature.Keys) - indexAnswerForSignature(answerCopy, signature); - } - - private void indexAnswerForSignature(object[] answer, int signature) - { - // First find out which of the answer values can be used as an index. - object[] indexValues = new object[answer.Length]; - for (int i = 0; i < answer.Length; ++i) - { - // We limit the number of indexed args in a 32-bit signature. - if (i >= MAX_INDEX_ARGS) - indexValues[i] = null; - else - indexValues[i] = getIndexValue(YP.getValue(answer[i])); - } - - // We need an entry in indexArgs from indexValues for each 1 bit in signature. - HashedList indexArgs = new HashedList(indexValues.Length); - for (int i = 0; i < indexValues.Length; ++i) - { - if ((signature & (1 << i)) == 0) - indexArgs.Add(null); - else - { - if (indexValues[i] == null) - // The signature wants an index value here, but we don't have one so - // we can't add it as an answer for this signature. - return; - else - indexArgs.Add(indexValues[i]); - } - } - - // Add the answer to the answers list for indexArgs, creating the entry if needed. - List answers; - if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) - { - answers = new List(); - _indexedAnswers[indexArgs] = answers; - } - answers.Add(answer); - } - - public IEnumerable match(object[] arguments) - { - // Set up indexArgs, up to arg position MAX_INDEX_ARGS. The signature has a 1 bit for - // each non-null index arg. - HashedList indexArgs = new HashedList(arguments.Length); - bool gotAllIndexArgs = true; - int signature = 0; - for (int i = 0; i < arguments.Length; ++i) - { - object indexValue = null; - if (i < MAX_INDEX_ARGS) - { - // We limit the number of args in a 32-bit signature. - indexValue = getIndexValue(YP.getValue(arguments[i])); - if (indexValue != null) - signature += (1 << i); - } - if (indexValue == null) - gotAllIndexArgs = false; - indexArgs.Add(indexValue); - } - - List answers; - if (signature == 0) - // No index args, so we have to match from _allAnswers. - answers = _allAnswers; - else - { - if (!_gotAnswersForSignature.ContainsKey(signature)) - { - // We need to create the entry in _indexedAnswers. - foreach (object[] answer in _allAnswers) - indexAnswerForSignature(answer, signature); - // Mark that we did this signature. - _gotAnswersForSignature[signature] = null; - } - if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) - yield break; - } - - if (gotAllIndexArgs) - { - // All the arguments were already bound, so we don't need to do bindings. - yield return false; - yield break; - } - - // Find matches in answers. - IEnumerator[] iterators = new IEnumerator[arguments.Length]; - foreach (object[] answer in answers) - { - bool gotMatch = true; - int nIterators = 0; - // Try to bind all the arguments. - for (int i = 0; i < arguments.Length; ++i) - { - if (indexArgs[i] != null) - // We already matched this argument by looking up _indexedAnswers. - continue; - - IEnumerator iterator = YP.unify(arguments[i], answer[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(); - } - } - } - - /// - /// A HashedList extends an ArrayList with methods to get a hash and to check equality - /// based on the elements of the list. - /// - public class HashedList : ArrayList - { - private bool _gotHashCode = false; - private int _hashCode; - - public HashedList() - : base() - { - } - - public HashedList(int capacity) - : base(capacity) - { - } - - public HashedList(ICollection c) - : base(c) - { - } - - // Debug: Should override all the other methods that change this. - public override int Add(object value) - { - _gotHashCode = false; - return base.Add(value); - } - - public override int GetHashCode() - { - if (!_gotHashCode) - { - int hashCode = 1; - foreach (object obj in this) - hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode()); - _hashCode = hashCode; - _gotHashCode = true; - } - return _hashCode; - } - - public override bool Equals(object obj) - { - if (!(obj is ArrayList)) - return false; - - ArrayList objList = (ArrayList)obj; - if (objList.Count != Count) - return false; - - for (int i = 0; i < Count; ++i) - { - object value = objList[i]; - if (value == null) - { - if (this[i] != null) - return false; - } - else - { - if (!value.Equals(this[i])) - return false; - } - } - return true; - } - } - - /// - /// If we keep an index on value, return the value, or null if we don't index it. - /// - /// the term to examine. Assume you already called YP.getValue(value) - /// - public static object getIndexValue(object value) - { - if (value is Atom || value is string || value is Int32 || value is DateTime) - return value; - else - return null; - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// An IndexedAnswers holds answers to a query based on the values of index arguments. + /// + public class IndexedAnswers : YP.IClause + { + // addAnswer adds the answer here and indexes it later. + private List _allAnswers = new List(); + // The key has the arity of answers with non-null values for each indexed arg. The value + // is a list of the matching answers. The signature is implicit in the pattern on non-null index args. + private Dictionary> _indexedAnswers = + new Dictionary>(); + // Keeps track of whether we have started adding entries to _indexedAnswers for the signature. + private Dictionary _gotAnswersForSignature = new Dictionary(); + private const int MAX_INDEX_ARGS = 31; + + public IndexedAnswers() + { + } + + /// + /// Elements of answer must be ground, since arguments with unbound variables make this + /// into a dynamic rule which we don't index. + /// + /// + public void addAnswer(object[] answer) + { + // Store a copy of the answer array. + object[] answerCopy = new object[answer.Length]; + Variable.CopyStore copyStore = new Variable.CopyStore(); + for (int i = 0; i < answer.Length; ++i) + answerCopy[i] = YP.makeCopy(answer[i], copyStore); + if (copyStore.getNUniqueVariables() > 0) + throw new InvalidOperationException + ("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() + + " unbound variables"); + _allAnswers.Add(answerCopy); + + // If match has already indexed answers for a signature, we need to add + // this to the existing indexed answers. + foreach(int signature in _gotAnswersForSignature.Keys) + indexAnswerForSignature(answerCopy, signature); + } + + private void indexAnswerForSignature(object[] answer, int signature) + { + // First find out which of the answer values can be used as an index. + object[] indexValues = new object[answer.Length]; + for (int i = 0; i < answer.Length; ++i) + { + // We limit the number of indexed args in a 32-bit signature. + if (i >= MAX_INDEX_ARGS) + indexValues[i] = null; + else + indexValues[i] = getIndexValue(YP.getValue(answer[i])); + } + + // We need an entry in indexArgs from indexValues for each 1 bit in signature. + HashedList indexArgs = new HashedList(indexValues.Length); + for (int i = 0; i < indexValues.Length; ++i) + { + if ((signature & (1 << i)) == 0) + indexArgs.Add(null); + else + { + if (indexValues[i] == null) + // The signature wants an index value here, but we don't have one so + // we can't add it as an answer for this signature. + return; + else + indexArgs.Add(indexValues[i]); + } + } + + // Add the answer to the answers list for indexArgs, creating the entry if needed. + List answers; + if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) + { + answers = new List(); + _indexedAnswers[indexArgs] = answers; + } + answers.Add(answer); + } + + public IEnumerable match(object[] arguments) + { + // Set up indexArgs, up to arg position MAX_INDEX_ARGS. The signature has a 1 bit for + // each non-null index arg. + HashedList indexArgs = new HashedList(arguments.Length); + bool gotAllIndexArgs = true; + int signature = 0; + for (int i = 0; i < arguments.Length; ++i) + { + object indexValue = null; + if (i < MAX_INDEX_ARGS) + { + // We limit the number of args in a 32-bit signature. + indexValue = getIndexValue(YP.getValue(arguments[i])); + if (indexValue != null) + signature += (1 << i); + } + if (indexValue == null) + gotAllIndexArgs = false; + indexArgs.Add(indexValue); + } + + List answers; + if (signature == 0) + // No index args, so we have to match from _allAnswers. + answers = _allAnswers; + else + { + if (!_gotAnswersForSignature.ContainsKey(signature)) + { + // We need to create the entry in _indexedAnswers. + foreach (object[] answer in _allAnswers) + indexAnswerForSignature(answer, signature); + // Mark that we did this signature. + _gotAnswersForSignature[signature] = null; + } + if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) + yield break; + } + + if (gotAllIndexArgs) + { + // All the arguments were already bound, so we don't need to do bindings. + yield return false; + yield break; + } + + // Find matches in answers. + IEnumerator[] iterators = new IEnumerator[arguments.Length]; + foreach (object[] answer in answers) + { + bool gotMatch = true; + int nIterators = 0; + // Try to bind all the arguments. + for (int i = 0; i < arguments.Length; ++i) + { + if (indexArgs[i] != null) + // We already matched this argument by looking up _indexedAnswers. + continue; + + IEnumerator iterator = YP.unify(arguments[i], answer[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(); + } + } + } + + /// + /// A HashedList extends an ArrayList with methods to get a hash and to check equality + /// based on the elements of the list. + /// + public class HashedList : ArrayList + { + private bool _gotHashCode = false; + private int _hashCode; + + public HashedList() + : base() + { + } + + public HashedList(int capacity) + : base(capacity) + { + } + + public HashedList(ICollection c) + : base(c) + { + } + + // Debug: Should override all the other methods that change this. + public override int Add(object value) + { + _gotHashCode = false; + return base.Add(value); + } + + public override int GetHashCode() + { + if (!_gotHashCode) + { + int hashCode = 1; + foreach (object obj in this) + hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode()); + _hashCode = hashCode; + _gotHashCode = true; + } + return _hashCode; + } + + public override bool Equals(object obj) + { + if (!(obj is ArrayList)) + return false; + + ArrayList objList = (ArrayList)obj; + if (objList.Count != Count) + return false; + + for (int i = 0; i < Count; ++i) + { + object value = objList[i]; + if (value == null) + { + if (this[i] != null) + return false; + } + else + { + if (!value.Equals(this[i])) + return false; + } + } + return true; + } + } + + /// + /// If we keep an index on value, return the value, or null if we don't index it. + /// + /// the term to examine. Assume you already called YP.getValue(value) + /// + public static object getIndexValue(object value) + { + if (value is Atom || value is string || value is Int32 || value is DateTime) + return value; + else + return null; + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/ListPair.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/ListPair.cs index b16e8a4..681c445 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/ListPair.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/ListPair.cs @@ -1,156 +1,156 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class ListPair : Functor2 - { - public ListPair(object head, object tail) : base(Atom.DOT, head, tail) - { - } - - public static object make(List list) - { - if (list.Count <= 0) - return Atom.NIL; - - object result = Atom.NIL; - // Start from the end. - for (int i = list.Count - 1; i >= 0; --i) - result = new ListPair(list[i], result); - return result; - } - - public static object make(object[] array) - { - if (array.Length <= 0) - return Atom.NIL; - - object result = Atom.NIL; - // Start from the end. - for (int i = array.Length - 1; i >= 0; --i) - result = new ListPair(array[i], result); - return result; - } - - /// - /// Return a ListPair version of array, where repeated elements - /// (according to YP.termEqual) are removed. - /// - /// - /// - public static object makeWithoutRepeatedTerms(object[] array) - { - if (array.Length <= 0) - return Atom.NIL; - - // Start from the end. - object previousTerm = array[array.Length - 1]; - object result = new ListPair(previousTerm, Atom.NIL); - for (int i = array.Length - 2; i >= 0; --i) - { - object term = array[i]; - if (YP.termEqual(term, previousTerm)) - continue; - result = new ListPair(term, result); - previousTerm = term; - } - return result; - } - - /// - /// Return a ListPair version of array, where repeated elements - /// (according to YP.termEqual) are removed. - /// - /// - /// - public static object makeWithoutRepeatedTerms(List array) - { - if (array.Count <= 0) - return Atom.NIL; - - // Start from the end. - object previousTerm = array[array.Count - 1]; - object result = new ListPair(previousTerm, Atom.NIL); - for (int i = array.Count - 2; i >= 0; --i) - { - object term = array[i]; - if (YP.termEqual(term, previousTerm)) - continue; - result = new ListPair(term, result); - previousTerm = term; - } - return result; - } - - public static object make(object element1) - { - return new ListPair(element1, Atom.NIL); - } - - public static object make(object element1, object element2) - { - return new ListPair(element1, new ListPair(element2, Atom.NIL)); - } - - public static object make(object element1, object element2, object element3) - { - return new ListPair(element1, - new ListPair(element2, new ListPair(element3, Atom.NIL))); - } - - /// - /// Return an array of the elements in list or null if it is not - /// a proper list. If list is Atom.NIL, return an array of zero elements. - /// This does not call YP.getValue on each element. - /// - /// - /// - public static object[] toArray(object list) - { - list = YP.getValue(list); - if (list.Equals(Atom.NIL)) - return new object[0]; - - List result = new List(); - for (object element = list; - element is Functor2 && ((Functor2)element)._name == Atom.DOT; - element = YP.getValue(((Functor2)element)._arg2)) - result.Add(((Functor2)element)._arg1); - - if (result.Count <= 0) - return null; - return result.ToArray(); - } - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class ListPair : Functor2 + { + public ListPair(object head, object tail) : base(Atom.DOT, head, tail) + { + } + + public static object make(List list) + { + if (list.Count <= 0) + return Atom.NIL; + + object result = Atom.NIL; + // Start from the end. + for (int i = list.Count - 1; i >= 0; --i) + result = new ListPair(list[i], result); + return result; + } + + public static object make(object[] array) + { + if (array.Length <= 0) + return Atom.NIL; + + object result = Atom.NIL; + // Start from the end. + for (int i = array.Length - 1; i >= 0; --i) + result = new ListPair(array[i], result); + return result; + } + + /// + /// Return a ListPair version of array, where repeated elements + /// (according to YP.termEqual) are removed. + /// + /// + /// + public static object makeWithoutRepeatedTerms(object[] array) + { + if (array.Length <= 0) + return Atom.NIL; + + // Start from the end. + object previousTerm = array[array.Length - 1]; + object result = new ListPair(previousTerm, Atom.NIL); + for (int i = array.Length - 2; i >= 0; --i) + { + object term = array[i]; + if (YP.termEqual(term, previousTerm)) + continue; + result = new ListPair(term, result); + previousTerm = term; + } + return result; + } + + /// + /// Return a ListPair version of array, where repeated elements + /// (according to YP.termEqual) are removed. + /// + /// + /// + public static object makeWithoutRepeatedTerms(List array) + { + if (array.Count <= 0) + return Atom.NIL; + + // Start from the end. + object previousTerm = array[array.Count - 1]; + object result = new ListPair(previousTerm, Atom.NIL); + for (int i = array.Count - 2; i >= 0; --i) + { + object term = array[i]; + if (YP.termEqual(term, previousTerm)) + continue; + result = new ListPair(term, result); + previousTerm = term; + } + return result; + } + + public static object make(object element1) + { + return new ListPair(element1, Atom.NIL); + } + + public static object make(object element1, object element2) + { + return new ListPair(element1, new ListPair(element2, Atom.NIL)); + } + + public static object make(object element1, object element2, object element3) + { + return new ListPair(element1, + new ListPair(element2, new ListPair(element3, Atom.NIL))); + } + + /// + /// Return an array of the elements in list or null if it is not + /// a proper list. If list is Atom.NIL, return an array of zero elements. + /// This does not call YP.getValue on each element. + /// + /// + /// + public static object[] toArray(object list) + { + list = YP.getValue(list); + if (list.Equals(Atom.NIL)) + return new object[0]; + + List result = new List(); + for (object element = list; + element is Functor2 && ((Functor2)element)._name == Atom.DOT; + element = YP.getValue(((Functor2)element)._arg2)) + result.Add(((Functor2)element)._arg1); + + if (result.Count <= 0) + return null; + return result.ToArray(); + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Parser.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Parser.cs index 7ef5c51..a21a471 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Parser.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Parser.cs @@ -1,4457 +1,4457 @@ -/* - * 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.Generic; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class Parser - { - public static IEnumerable formatError(object Output, object Format, object Arguments) - { - // Debug: Simple implementation for now. - YP.write(Format); - YP.write(Arguments); - YP.nl(); - yield return false; - } - - // Debug: Hand-modify this central predicate to do tail recursion. - public static IEnumerable read_tokens(object arg1, object arg2, object arg3) - { - bool repeat = true; - while (repeat) - { - repeat = false; - { - object C1 = arg1; - object Dict = arg2; - object Tokens = arg3; - Variable C2 = new Variable(); - if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) - { - if (YP.greaterThanOrEqual(C1, 0)) - { - foreach (bool l4 in YP.get_code(C2)) - { -#if false - foreach (bool l5 in read_tokens(C2, Dict, Tokens)) - { - yield return false; - } -#endif - arg1 = YP.getValue(C2); - arg2 = YP.getValue(Dict); - arg3 = YP.getValue(Tokens); - repeat = true; - } - } - goto cutIf1; - } - if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) - { - foreach (bool l4 in read_identifier(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf2; - } - } - if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) - { - foreach (bool l4 in read_variable(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf3; - } - } - if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) - { - foreach (bool l4 in read_number(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf4; - } - } - if (YP.lessThan(C1, 127)) - { - foreach (bool l3 in read_special(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf5; - } - if (YP.lessThanOrEqual(C1, 160)) - { - foreach (bool l3 in YP.get_code(C2)) - { -#if false - foreach (bool l4 in read_tokens(C2, Dict, Tokens)) - { - yield return false; - } -#endif - arg1 = YP.getValue(C2); - arg2 = YP.getValue(Dict); - arg3 = YP.getValue(Tokens); - repeat = true; - } - goto cutIf6; - } - if (YP.greaterThanOrEqual(C1, 223)) - { - if (YP.notEqual(C1, 247)) - { - foreach (bool l4 in read_identifier(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf7; - } - } - if (YP.greaterThanOrEqual(C1, 192)) - { - if (YP.notEqual(C1, 215)) - { - foreach (bool l4 in read_variable(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf8; - } - } - if (YP.notEqual(C1, 170)) - { - if (YP.notEqual(C1, 186)) - { - foreach (bool l4 in read_symbol(C1, Dict, Tokens)) - { - yield return false; - } - goto cutIf9; - } - } - foreach (bool l2 in read_identifier(C1, Dict, Tokens)) - { - yield return false; - } - cutIf9: - cutIf8: - cutIf7: - cutIf6: - cutIf5: - cutIf4: - cutIf3: - cutIf2: - cutIf1: - { } - } - } - } - - // Compiler output follows. - - class YPInnerClass { } - static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } - - public static IEnumerable parseInput(object TermList) - { - { - Variable TermAndVariables = new Variable(); - FindallAnswers findallAnswers1 = new FindallAnswers(TermAndVariables); - foreach (bool l2 in parseInputHelper(TermAndVariables)) - { - findallAnswers1.add(); - } - foreach (bool l2 in findallAnswers1.result(TermList)) - { - yield return false; - } - } - } - - public static IEnumerable parseInputHelper(object arg1) - { - { - Variable Term = new Variable(); - Variable Variables = new Variable(); - Variable Answer = new Variable(); - Variable x4 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"f", Term, Variables))) - { - foreach (bool l3 in YP.repeat()) - { - foreach (bool l4 in portable_read3(Answer, Variables, x4)) - { - foreach (bool l5 in remove_pos(Answer, Term)) - { - if (YP.termEqual(Term, Atom.a(@"end_of_file"))) - { - yield break; - goto cutIf1; - } - yield return false; - cutIf1: - { } - } - } - } - } - } - } - - public static IEnumerable clear_errors() - { - { - yield return false; - } - } - - public static IEnumerable remove_pos(object arg1, object arg2) - { - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, X)) - { - foreach (bool l3 in YP.unify(arg2, X)) - { - if (YP.var(X)) - { - yield return true; - yield break; - } - } - } - } - { - object X = arg2; - Variable _Pos = new Variable(); - Variable _Name = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"$VAR", _Pos, _Name, X))) - { - if (YP.var(X)) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - Variable H = new Variable(); - Variable T = new Variable(); - Variable NH = new Variable(); - Variable NT = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(NH, NT))) - { - foreach (bool l4 in remove_pos(H, NH)) - { - foreach (bool l5 in remove_pos(T, NT)) - { - yield return false; - } - } - yield break; - } - } - } - { - Variable A = new Variable(); - Variable B = new Variable(); - Variable NA = new Variable(); - Variable NB = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - foreach (bool l3 in YP.unify(arg2, new Functor2(@",", NA, NB))) - { - foreach (bool l4 in remove_pos(A, NA)) - { - foreach (bool l5 in remove_pos(B, NB)) - { - yield return false; - } - } - yield break; - } - } - } - { - Variable Atom_1 = new Variable(); - Variable _F = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom_1)) - { - foreach (bool l3 in YP.unify(arg2, Atom_1)) - { - foreach (bool l4 in YP.functor(Atom_1, _F, 0)) - { - yield return false; - } - } - } - } - { - object Term = arg1; - object NewTerm = arg2; - Variable Func = new Variable(); - Variable _Pos = new Variable(); - Variable Args = new Variable(); - Variable NArgs = new Variable(); - if (YP.nonvar(Term)) - { - foreach (bool l3 in YP.univ(Term, new ListPair(Func, new ListPair(_Pos, Args)))) - { - foreach (bool l4 in remove_pos(Args, NArgs)) - { - foreach (bool l5 in YP.univ(NewTerm, new ListPair(Func, NArgs))) - { - yield return false; - } - } - } - } - } - } - - public static IEnumerable portable_read_position(object Term, object PosTerm, object Syntax) - { - { - foreach (bool l2 in portable_read(PosTerm, Syntax)) - { - foreach (bool l3 in remove_pos(PosTerm, Term)) - { - yield return false; - } - } - } - } - - public static IEnumerable portable_read(object Answer, object Syntax) - { - { - Variable Tokens = new Variable(); - Variable ParseTokens = new Variable(); - foreach (bool l2 in read_tokens1(Tokens)) - { - foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) - { - foreach (bool l4 in parse2(ParseTokens, Answer)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable portable_read3(object Answer, object Variables, object Syntax) - { - { - Variable Tokens = new Variable(); - Variable ParseTokens = new Variable(); - foreach (bool l2 in read_tokens2(Tokens, Variables)) - { - foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) - { - foreach (bool l4 in parse2(ParseTokens, Answer)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable remove_comments(object arg1, object arg2, object arg3) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - foreach (bool l4 in YP.unify(arg3, Atom.NIL)) - { - yield return false; - } - } - } - } - { - object Ys = arg2; - Variable S = new Variable(); - Variable E = new Variable(); - Variable Xs = new Variable(); - Variable Zs = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"comment", S, E), Xs))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", S, E), Zs))) - { - foreach (bool l4 in remove_comments(Xs, Ys, Zs)) - { - yield return false; - } - yield break; - } - } - } - { - Variable Pos = new Variable(); - Variable Xs = new Variable(); - Variable Ys = new Variable(); - Variable Pos2 = new Variable(); - Variable Zs = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Xs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"["), Ys))) - { - foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) - { - foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) - { - foreach (bool l6 in remove_comments(Xs, Ys, Zs)) - { - yield return false; - } - } - yield break; - } - } - } - } - { - Variable Pos = new Variable(); - Variable Xs = new Variable(); - Variable Ys = new Variable(); - Variable Pos2 = new Variable(); - Variable Zs = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Xs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), Ys))) - { - foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) - { - foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) - { - foreach (bool l6 in remove_comments(Xs, Ys, Zs)) - { - yield return false; - } - } - yield break; - } - } - } - } - { - object Zs = arg3; - Variable Token = new Variable(); - Variable Xs = new Variable(); - Variable Ys = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Xs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Token, Ys))) - { - foreach (bool l4 in remove_comments(Xs, Ys, Zs)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable expect(object Token, object arg2, object arg3) - { - { - object Rest = arg3; - foreach (bool l2 in YP.unify(arg2, new ListPair(Token, Rest))) - { - yield return true; - yield break; - } - } - { - object S0 = arg2; - object x3 = arg3; - foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"or"), new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), Atom.NIL)))), S0)) - { - yield return false; - } - } - } - - public static IEnumerable parse2(object Tokens, object Answer) - { - { - Variable Term = new Variable(); - Variable LeftOver = new Variable(); - foreach (bool l2 in clear_errors()) - { - foreach (bool l3 in parse(Tokens, 1200, Term, LeftOver)) - { - foreach (bool l4 in all_read(LeftOver)) - { - foreach (bool l5 in YP.unify(Answer, Term)) - { - yield return false; - } - yield break; - } - } - foreach (bool l3 in syntax_error(Tokens)) - { - yield return false; - } - } - } - } - - public static IEnumerable all_read(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - yield return false; - } - } - { - Variable Token = new Variable(); - Variable S = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S))) - { - foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"after"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(Token, S))) - { - yield return false; - } - } - } - } - - public static IEnumerable parse(object arg1, object arg2, object arg3, object arg4) - { - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"expression"), new ListPair(Atom.a(@"expected"), Atom.NIL)), Atom.NIL)) - { - yield return false; - } - } - } - { - object Precedence = arg2; - object Term = arg3; - object LeftOver = arg4; - Variable Token = new Variable(); - Variable RestTokens = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, RestTokens))) - { - foreach (bool l3 in parse5(Token, RestTokens, Precedence, Term, LeftOver)) - { - yield return false; - } - } - } - } - - public static IEnumerable parse5(object arg1, object arg2, object arg3, object arg4, object arg5) - { - { - object S0 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) - { - foreach (bool l3 in cannot_start(Atom.a(@"}"), S0)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) - { - foreach (bool l3 in cannot_start(Atom.a(@"]"), S0)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) - { - foreach (bool l3 in cannot_start(Atom.a(@")"), S0)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - foreach (bool l3 in cannot_start(Atom.a(@","), S0)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - foreach (bool l3 in cannot_start(Atom.a(@"|"), S0)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Chars = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", Chars))) - { - foreach (bool l3 in exprtl0(S0, Chars, Precedence, Answer, S)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Number = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", Number))) - { - foreach (bool l3 in exprtl0(S0, Number, Precedence, Answer, S)) - { - yield return false; - } - } - } - { - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), S1))) - { - foreach (bool l4 in read_atom(new Functor2(@"/", Atom.NIL, 0), S1, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - { - object S1 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Arg1 = new Variable(); - Variable S2 = new Variable(); - Variable RestArgs = new Variable(); - Variable S3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in parse(S1, 999, Arg1, S2)) - { - foreach (bool l4 in read_list(S2, RestArgs, S3)) - { - foreach (bool l5 in exprtl0(S3, new ListPair(Arg1, RestArgs), Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - } - { - object S1 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Term = new Variable(); - Variable S2 = new Variable(); - Variable S3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) - { - foreach (bool l3 in parse(S1, 1200, Term, S2)) - { - foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) - { - foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - } - { - object S1 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Term = new Variable(); - Variable S2 = new Variable(); - Variable S3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) - { - foreach (bool l3 in parse(S1, 1200, Term, S2)) - { - foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) - { - foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - } - { - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable _Pos = new Variable(); - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), _Pos))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"}"), S1))) - { - foreach (bool l4 in read_atom(Atom.a(@"{}"), S1, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - { - object S1 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Pos = new Variable(); - Variable Term = new Variable(); - Variable S2 = new Variable(); - Variable S3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), Pos))) - { - foreach (bool l3 in parse(S1, 1200, Term, S2)) - { - foreach (bool l4 in expect(Atom.a(@"}"), S2, S3)) - { - foreach (bool l5 in exprtl0(S3, new Functor2(@"{}", Pos, Term), Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - } - { - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Variable_1 = new Variable(); - Variable Name = new Variable(); - Variable Pos = new Variable(); - Variable S1 = new Variable(); - Variable Arg1 = new Variable(); - Variable S2 = new Variable(); - Variable RestArgs = new Variable(); - Variable S3 = new Variable(); - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) - { - foreach (bool l4 in parse(S1, 999, Arg1, S2)) - { - foreach (bool l5 in read_args(S2, RestArgs, S3)) - { - foreach (bool l6 in YP.univ(Term, new ListPair(Atom.a(@"call"), new ListPair(new Functor3(@"$VAR", Pos, Name, Variable_1), new ListPair(Arg1, RestArgs))))) - { - foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - } - yield break; - } - } - } - { - object S0 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Variable_1 = new Variable(); - Variable Name = new Variable(); - Variable Pos = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) - { - foreach (bool l3 in exprtl0(S0, new Functor3(@"$VAR", Pos, Name, Variable_1), Precedence, Answer, S)) - { - yield return false; - } - } - } - { - object S0 = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Atom_1 = new Variable(); - Variable P = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", Atom_1, P))) - { - foreach (bool l3 in read_atom(new Functor2(@"/", Atom_1, P), S0, Precedence, Answer, S)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_atom(object arg1, object arg2, object Precedence, object Answer, object S) - { - { - Variable _Pos = new Variable(); - Variable Number = new Variable(); - Variable S1 = new Variable(); - Variable Negative = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"-"), _Pos))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"number", Number), S1))) - { - foreach (bool l4 in YP.unify(Negative, YP.negate(Number))) - { - foreach (bool l5 in exprtl0(S1, Negative, Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - } - } - { - Variable Functor_1 = new Variable(); - Variable Pos = new Variable(); - Variable S1 = new Variable(); - Variable Arg1 = new Variable(); - Variable S2 = new Variable(); - Variable RestArgs = new Variable(); - Variable S3 = new Variable(); - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Functor_1, Pos))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) - { - foreach (bool l4 in parse(S1, 999, Arg1, S2)) - { - foreach (bool l5 in read_args(S2, RestArgs, S3)) - { - foreach (bool l6 in YP.univ(Term, new ListPair(Functor_1, new ListPair(Pos, new ListPair(Arg1, RestArgs))))) - { - foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - } - yield break; - } - } - } - { - object S0 = arg2; - Variable Op = new Variable(); - Variable Pos = new Variable(); - Variable Oprec = new Variable(); - Variable Aprec = new Variable(); - Variable Flag = new Variable(); - Variable Term = new Variable(); - Variable Arg = new Variable(); - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Op, Pos))) - { - foreach (bool l3 in prefixop(Op, Oprec, Aprec)) - { - foreach (bool l4 in possible_right_operand(S0, Flag)) - { - if (YP.lessThan(Flag, 0)) - { - foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, Atom.NIL)))) - { - foreach (bool l7 in exprtl0(S0, Term, Precedence, Answer, S)) - { - yield return false; - } - } - goto cutIf1; - } - if (YP.greaterThan(Oprec, Precedence)) - { - foreach (bool l6 in syntax_error(new ListPair(Atom.a(@"prefix"), new ListPair(Atom.a(@"operator"), new ListPair(Op, new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"context"), new ListPair(Atom.a(@"with"), new ListPair(Atom.a(@"precedence"), new ListPair(Precedence, Atom.NIL)))))))), S0)) - { - yield return false; - } - goto cutIf2; - } - if (YP.greaterThan(Flag, 0)) - { - foreach (bool l6 in parse(S0, Aprec, Arg, S1)) - { - foreach (bool l7 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) - { - foreach (bool l8 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - goto cutIf3; - } - foreach (bool l5 in peepop(S0, S1)) - { - foreach (bool l6 in prefix_is_atom(S1, Oprec)) - { - foreach (bool l7 in exprtl(S1, Oprec, new Functor2(@"/", Op, Pos), Precedence, Answer, S)) - { - yield return false; - } - } - } - foreach (bool l5 in parse(S0, Aprec, Arg, S1)) - { - foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) - { - foreach (bool l7 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - cutIf3: - cutIf2: - cutIf1: - { } - } - yield break; - } - } - } - { - object S0 = arg2; - Variable Atom_1 = new Variable(); - Variable Pos = new Variable(); - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom_1, Pos))) - { - foreach (bool l3 in YP.univ(Term, new ListPair(Atom_1, new ListPair(Pos, Atom.NIL)))) - { - foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable cannot_start(object Token, object S0) - { - { - foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"cannot"), new ListPair(Atom.a(@"start"), new ListPair(Atom.a(@"an"), new ListPair(Atom.a(@"expression"), Atom.NIL))))), S0)) - { - yield return false; - } - } - } - - public static IEnumerable read_args(object arg1, object arg2, object arg3) - { - { - object S = arg3; - Variable S1 = new Variable(); - Variable Term = new Variable(); - Variable Rest = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@","), S1))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(Term, Rest))) - { - foreach (bool l4 in parse(S1, 999, Term, S2)) - { - foreach (bool l5 in read_args(S2, Rest, S)) - { - yield return false; - } - yield break; - } - yield break; - } - } - } - { - object S = arg3; - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@")"), S))) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - object S = arg1; - object x2 = arg2; - object x3 = arg3; - foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", or )"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"arguments"), Atom.NIL)))), S)) - { - yield return false; - } - } - } - - public static IEnumerable read_list(object arg1, object arg2, object arg3) - { - { - object x1 = arg2; - object x2 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), Atom.NIL)) - { - yield return false; - } - } - } - { - object Rest = arg2; - object S = arg3; - Variable Token = new Variable(); - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) - { - foreach (bool l3 in read_list4(Token, S1, Rest, S)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_list4(object arg1, object arg2, object arg3, object arg4) - { - { - object S1 = arg2; - object S = arg4; - Variable Term = new Variable(); - Variable Rest = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Term, Rest))) - { - foreach (bool l4 in parse(S1, 999, Term, S2)) - { - foreach (bool l5 in read_list(S2, Rest, S)) - { - yield return false; - } - yield break; - } - yield break; - } - } - } - { - object S1 = arg2; - object Rest = arg3; - object S = arg4; - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - foreach (bool l3 in parse(S1, 999, Rest, S2)) - { - foreach (bool l4 in expect(Atom.a(@"]"), S2, S)) - { - yield return false; - } - yield break; - } - yield break; - } - } - { - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) - { - foreach (bool l3 in YP.unify(arg2, S1)) - { - foreach (bool l4 in YP.unify(arg3, Atom.NIL)) - { - foreach (bool l5 in YP.unify(arg4, S1)) - { - yield return true; - yield break; - } - } - } - } - } - { - object Token = arg1; - object S1 = arg2; - object x3 = arg3; - object x4 = arg4; - foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), new ListPair(Token, S1))) - { - yield return false; - } - } - } - - public static IEnumerable possible_right_operand(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - object Flag = arg2; - Variable H = new Variable(); - Variable T = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) - { - foreach (bool l3 in possible_right_operand3(H, Flag, T)) - { - yield return false; - } - } - } - } - - public static IEnumerable possible_right_operand3(object arg1, object arg2, object arg3) - { - { - object x4 = arg3; - Variable x1 = new Variable(); - Variable x2 = new Variable(); - Variable x3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", x1, x2, x3))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x2 = arg3; - Variable x1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", x1))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x2 = arg3; - Variable x1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", x1))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) - { - foreach (bool l3 in YP.unify(arg2, 0)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - Variable x1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in YP.unify(arg2, 0)) - { - foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"]"), x1))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - Variable x1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) - { - foreach (bool l3 in YP.unify(arg2, 0)) - { - foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"}"), x1))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) - { - foreach (bool l3 in YP.unify(arg2, 1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - object x1 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - object x3 = arg3; - Variable x1 = new Variable(); - Variable x2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", x1, x2))) - { - foreach (bool l3 in YP.unify(arg2, 0)) - { - yield return false; - } - } - } - } - - public static IEnumerable peepop(object arg1, object arg2) - { - { - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) - { - yield return true; - yield break; - } - } - } - { - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable S1 = new Variable(); - Variable L = new Variable(); - Variable P = new Variable(); - Variable R = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, P, R }), S1))) - { - foreach (bool l4 in infixop(F, L, P, R)) - { - yield return false; - } - } - } - } - { - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable S1 = new Variable(); - Variable L = new Variable(); - Variable P = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, P), S1))) - { - foreach (bool l4 in postfixop(F, L, P)) - { - yield return false; - } - } - } - } - { - Variable S0 = new Variable(); - foreach (bool l2 in YP.unify(arg1, S0)) - { - foreach (bool l3 in YP.unify(arg2, S0)) - { - yield return false; - } - } - } - } - - public static IEnumerable prefix_is_atom(object arg1, object arg2) - { - { - object Precedence = arg2; - Variable Token = new Variable(); - Variable x2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, x2))) - { - foreach (bool l3 in prefix_is_atom(Token, Precedence)) - { - yield return false; - } - } - } - { - object P = arg2; - Variable x1 = new Variable(); - Variable L = new Variable(); - Variable x3 = new Variable(); - Variable x4 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { x1, L, x3, x4 }))) - { - if (YP.greaterThanOrEqual(L, P)) - { - yield return false; - } - } - } - { - object P = arg2; - Variable x1 = new Variable(); - Variable L = new Variable(); - Variable x3 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), x1, L, x3))) - { - if (YP.greaterThanOrEqual(L, P)) - { - yield return false; - } - } - } - { - object x1 = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) - { - yield return false; - } - } - { - object x1 = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) - { - yield return false; - } - } - { - object x1 = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) - { - yield return false; - } - } - { - object P = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - if (YP.greaterThanOrEqual(1100, P)) - { - yield return false; - } - } - } - { - object P = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - if (YP.greaterThanOrEqual(1000, P)) - { - yield return false; - } - } - } - { - object x1 = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - yield return false; - } - } - } - - public static IEnumerable exprtl0(object arg1, object arg2, object arg3, object arg4, object arg5) - { - { - object x2 = arg3; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, Term)) - { - foreach (bool l4 in YP.unify(arg4, Term)) - { - foreach (bool l5 in YP.unify(arg5, Atom.NIL)) - { - yield return false; - } - } - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable Token = new Variable(); - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) - { - foreach (bool l3 in exprtl0_6(Token, Term, Precedence, Answer, S, S1)) - { - yield return false; - } - } - } - } - - public static IEnumerable exprtl0_6(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) - { - { - object x2 = arg3; - object S1 = arg6; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) - { - foreach (bool l3 in YP.unify(arg2, Term)) - { - foreach (bool l4 in YP.unify(arg4, Term)) - { - foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"}"), S1))) - { - yield return false; - } - } - } - } - } - { - object x2 = arg3; - object S1 = arg6; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) - { - foreach (bool l3 in YP.unify(arg2, Term)) - { - foreach (bool l4 in YP.unify(arg4, Term)) - { - foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"]"), S1))) - { - yield return false; - } - } - } - } - } - { - object x2 = arg3; - object S1 = arg6; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) - { - foreach (bool l3 in YP.unify(arg2, Term)) - { - foreach (bool l4 in YP.unify(arg4, Term)) - { - foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@")"), S1))) - { - yield return false; - } - } - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - object S1 = arg6; - Variable Next = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - if (YP.greaterThanOrEqual(Precedence, 1000)) - { - foreach (bool l4 in parse(S1, 1000, Next, S2)) - { - foreach (bool l5 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - goto cutIf1; - } - foreach (bool l3 in YP.unify(Answer, Term)) - { - foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@","), S1))) - { - yield return false; - } - } - cutIf1: - { } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - object S1 = arg6; - Variable Next = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - if (YP.greaterThanOrEqual(Precedence, 1100)) - { - foreach (bool l4 in parse(S1, 1100, Next, S2)) - { - foreach (bool l5 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - goto cutIf2; - } - foreach (bool l3 in YP.unify(Answer, Term)) - { - foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@"|"), S1))) - { - yield return false; - } - } - cutIf2: - { } - } - } - { - object x2 = arg2; - object x3 = arg3; - object x4 = arg4; - object x5 = arg5; - object S1 = arg6; - Variable S = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", S))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"chars"), new Functor1(@"string", S), S1)) - { - yield return false; - } - } - } - { - object x2 = arg2; - object x3 = arg3; - object x4 = arg4; - object x5 = arg5; - object S1 = arg6; - Variable N = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", N))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"number"), new Functor1(@"number", N), S1)) - { - yield return false; - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) - { - foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"}"), S1))) - { - foreach (bool l4 in exprtl0_atom(Atom.a(@"{}"), Term, Precedence, Answer, S, S1)) - { - yield return false; - } - yield break; - } - } - } - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - object S1 = arg6; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"brace"), Atom.a(@"{"), S1)) - { - yield return false; - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable S1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"]"), S1))) - { - foreach (bool l4 in exprtl0_atom(Atom.NIL, Term, Precedence, Answer, S, S1)) - { - yield return false; - } - yield break; - } - } - } - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - object S1 = arg6; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"bracket"), Atom.a(@"["), S1)) - { - yield return false; - } - } - } - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - object S1 = arg6; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) - { - yield return false; - } - } - } - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - object x4 = arg5; - object S1 = arg6; - foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) - { - yield return false; - } - } - } - { - object x4 = arg2; - object x5 = arg3; - object x6 = arg4; - object x7 = arg5; - object S1 = arg6; - Variable A = new Variable(); - Variable B = new Variable(); - Variable P = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", A, B, P))) - { - foreach (bool l3 in cannot_follow(Atom.a(@"variable"), new Functor3(@"var", A, B, P), S1)) - { - yield return false; - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - object S1 = arg6; - Variable F = new Variable(); - Variable P = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", F, P))) - { - foreach (bool l3 in exprtl0_atom(new Functor2(@"/", F, P), Term, Precedence, Answer, S, S1)) - { - yield return false; - } - } - } - } - - public static IEnumerable exprtl0_atom(object arg1, object arg2, object arg3, object arg4, object arg5, object S1) - { - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable L1 = new Variable(); - Variable O1 = new Variable(); - Variable R1 = new Variable(); - Variable L2 = new Variable(); - Variable O2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) - { - foreach (bool l3 in ambigop(F, Precedence, L1, O1, R1, L2, O2)) - { - foreach (bool l4 in prefix_is_atom(S1, Precedence)) - { - foreach (bool l5 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) - { - yield return false; - } - foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable L1 = new Variable(); - Variable O1 = new Variable(); - Variable R1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) - { - foreach (bool l3 in infixop(F, L1, O1, R1)) - { - foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - { - object Term = arg2; - object Precedence = arg3; - object Answer = arg4; - object S = arg5; - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable L2 = new Variable(); - Variable O2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) - { - foreach (bool l3 in postfixop(F, L2, O2)) - { - foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) - { - yield return false; - } - yield break; - } - } - } - { - object X = arg1; - object x2 = arg2; - object x3 = arg3; - object x4 = arg4; - object x5 = arg5; - Variable x7 = new Variable(); - foreach (bool l2 in syntax_error(new ListPair(new Functor2(@"-", Atom.a(@"non"), Atom.a(@"operator")), new ListPair(X, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(new Functor2(@"atom", X, x7), S1))) - { - yield return false; - } - yield break; - } - } - - public static IEnumerable cannot_follow(object Type, object Token, object Tokens) - { - { - foreach (bool l2 in syntax_error(new ListPair(Type, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL))), new ListPair(Token, Tokens))) - { - yield return false; - } - } - } - - public static IEnumerable exprtl(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) - { - { - object x1 = arg2; - object x3 = arg4; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, Term)) - { - foreach (bool l4 in YP.unify(arg5, Term)) - { - foreach (bool l5 in YP.unify(arg6, Atom.NIL)) - { - yield return false; - } - } - } - } - } - { - object C = arg2; - object Term = arg3; - object Precedence = arg4; - object Answer = arg5; - object S = arg6; - Variable Token = new Variable(); - Variable Tokens = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Tokens))) - { - foreach (bool l3 in exprtl_7(Token, C, Term, Precedence, Answer, S, Tokens)) - { - yield return false; - } - } - } - } - - public static IEnumerable exprtl_7(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7) - { - { - object C = arg2; - object Term = arg3; - object Precedence = arg4; - object Answer = arg5; - object S = arg6; - object S1 = arg7; - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable L = new Variable(); - Variable O = new Variable(); - Variable R = new Variable(); - Variable Other = new Variable(); - Variable S2 = new Variable(); - Variable Expr = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, O, R }))) - { - if (YP.greaterThanOrEqual(Precedence, O)) - { - if (YP.lessThanOrEqual(C, L)) - { - foreach (bool l5 in parse(S1, R, Other, S2)) - { - foreach (bool l6 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, new ListPair(Other, Atom.NIL)))))) - { - foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) - { - yield return false; - } - } - } - yield break; - } - } - } - } - { - object C = arg2; - object Term = arg3; - object Precedence = arg4; - object Answer = arg5; - object S = arg6; - object S1 = arg7; - Variable F = new Variable(); - Variable Pos = new Variable(); - Variable L = new Variable(); - Variable O = new Variable(); - Variable Expr = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, O))) - { - if (YP.greaterThanOrEqual(Precedence, O)) - { - if (YP.lessThanOrEqual(C, L)) - { - foreach (bool l5 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, Atom.NIL))))) - { - foreach (bool l6 in peepop(S1, S2)) - { - foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) - { - yield return false; - } - } - } - yield break; - } - } - } - } - { - object C = arg2; - object Term = arg3; - object Precedence = arg4; - object Answer = arg5; - object S = arg6; - object S1 = arg7; - Variable Next = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) - { - if (YP.greaterThanOrEqual(Precedence, 1000)) - { - if (YP.lessThan(C, 1000)) - { - foreach (bool l5 in parse(S1, 1000, Next, S2)) - { - foreach (bool l6 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - } - } - } - { - object C = arg2; - object Term = arg3; - object Precedence = arg4; - object Answer = arg5; - object S = arg6; - object S1 = arg7; - Variable Next = new Variable(); - Variable S2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) - { - if (YP.greaterThanOrEqual(Precedence, 1100)) - { - if (YP.lessThan(C, 1100)) - { - foreach (bool l5 in parse(S1, 1100, Next, S2)) - { - foreach (bool l6 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) - { - yield return false; - } - } - yield break; - } - } - } - } - { - object Token = arg1; - object x2 = arg2; - object x4 = arg4; - object Tokens = arg7; - Variable Term = new Variable(); - foreach (bool l2 in YP.unify(arg3, Term)) - { - foreach (bool l3 in YP.unify(arg5, Term)) - { - foreach (bool l4 in YP.unify(arg6, new ListPair(Token, Tokens))) - { - yield return false; - } - } - } - } - } - - public static IEnumerable syntax_error(object _Message, object _List) - { - { - yield break; - } - } - - public static IEnumerable syntax_error(object _List) - { - { - yield break; - } - } - - public static IEnumerable prefixop(object F, object O, object Q) - { - { - foreach (bool l2 in YP.current_op(O, Atom.a(@"fx"), F)) - { - foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) - { - yield return false; - } - goto cutIf1; - } - foreach (bool l2 in YP.current_op(O, Atom.a(@"fy"), F)) - { - foreach (bool l3 in YP.unify(Q, O)) - { - yield return false; - } - goto cutIf2; - } - cutIf2: - cutIf1: - { } - } - } - - public static IEnumerable postfixop(object F, object P, object O) - { - { - foreach (bool l2 in YP.current_op(O, Atom.a(@"xf"), F)) - { - foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) - { - yield return false; - } - goto cutIf1; - } - foreach (bool l2 in YP.current_op(O, Atom.a(@"yf"), F)) - { - foreach (bool l3 in YP.unify(P, O)) - { - yield return false; - } - goto cutIf2; - } - cutIf2: - cutIf1: - { } - } - } - - public static IEnumerable infixop(object F, object P, object O, object Q) - { - { - foreach (bool l2 in YP.current_op(O, Atom.a(@"xfy"), F)) - { - foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) - { - foreach (bool l4 in YP.unify(Q, O)) - { - yield return false; - } - } - goto cutIf1; - } - foreach (bool l2 in YP.current_op(O, Atom.a(@"xfx"), F)) - { - foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) - { - foreach (bool l4 in YP.unify(Q, P)) - { - yield return false; - } - } - goto cutIf2; - } - foreach (bool l2 in YP.current_op(O, Atom.a(@"yfx"), F)) - { - foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) - { - foreach (bool l4 in YP.unify(P, O)) - { - yield return false; - } - } - goto cutIf3; - } - cutIf3: - cutIf2: - cutIf1: - { } - } - } - - public static IEnumerable ambigop(object F, object Precedence, object L1, object O1, object R1, object L2, object O2) - { - { - foreach (bool l2 in postfixop(F, L2, O2)) - { - if (YP.lessThanOrEqual(O2, Precedence)) - { - foreach (bool l4 in infixop(F, L1, O1, R1)) - { - if (YP.lessThanOrEqual(O1, Precedence)) - { - yield return false; - } - } - } - } - } - } - - public static IEnumerable read_tokens1(object arg1) - { - { - object TokenList = arg1; - Variable C1 = new Variable(); - Variable _X = new Variable(); - Variable ListOfTokens = new Variable(); - foreach (bool l2 in YP.get_code(C1)) - { - foreach (bool l3 in read_tokens(C1, _X, ListOfTokens)) - { - foreach (bool l4 in YP.unify(TokenList, ListOfTokens)) - { - yield return false; - } - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) - { - yield return false; - } - } - } - - public static IEnumerable read_tokens2(object arg1, object arg2) - { - { - object TokenList = arg1; - object Dictionary = arg2; - Variable C1 = new Variable(); - Variable Dict = new Variable(); - Variable ListOfTokens = new Variable(); - foreach (bool l2 in YP.get_code(C1)) - { - foreach (bool l3 in read_tokens(C1, Dict, ListOfTokens)) - { - foreach (bool l4 in terminate_list(Dict)) - { - foreach (bool l5 in YP.unify(Dictionary, Dict)) - { - foreach (bool l6 in YP.unify(TokenList, ListOfTokens)) - { - yield return false; - } - } - yield break; - } - } - } - } - { - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - yield return false; - } - } - } - } - - public static IEnumerable terminate_list(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - yield return false; - } - } - { - Variable x1 = new Variable(); - Variable Tail = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Tail))) - { - foreach (bool l3 in terminate_list(Tail)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_special(object arg1, object Dict, object arg3) - { - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 95)) - { - foreach (bool l3 in read_variable(95, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 247)) - { - foreach (bool l3 in read_symbol(247, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 215)) - { - foreach (bool l3 in read_symbol(215, Dict, Tokens)) - { - yield return false; - } - } - } - { - Variable StartPos = new Variable(); - Variable EndPos = new Variable(); - Variable Tokens = new Variable(); - Variable Ch = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 37)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) - { - foreach (bool l4 in get_current_position(StartPos)) - { - foreach (bool l5 in YP.repeat()) - { - foreach (bool l6 in YP.get_code(Ch)) - { - if (YP.lessThan(Ch, new ListPair(32, Atom.NIL))) - { - if (YP.notEqual(Ch, 9)) - { - if (YP.termNotEqual(Ch, -1)) - { - foreach (bool l10 in get_current_position(EndPos)) - { - foreach (bool l11 in YP.get_code(NextCh)) - { - foreach (bool l12 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - yield break; - } - } - } - } - } - } - } - } - { - object T = arg3; - Variable C2 = new Variable(); - Variable StartPos = new Variable(); - Variable EndPos = new Variable(); - Variable Tokens = new Variable(); - Variable StartPos1 = new Variable(); - Variable NextCh = new Variable(); - Variable Chars = new Variable(); - foreach (bool l2 in YP.unify(arg1, 47)) - { - foreach (bool l3 in YP.get_code(C2)) - { - if (YP.equal(C2, new ListPair(42, Atom.NIL))) - { - foreach (bool l5 in YP.unify(T, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) - { - foreach (bool l6 in get_current_position(StartPos1)) - { - foreach (bool l7 in YP.unify(StartPos, YP.subtract(StartPos1, 1))) - { - foreach (bool l8 in read_solidus(32, NextCh)) - { - foreach (bool l9 in get_current_position(EndPos)) - { - foreach (bool l10 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - goto cutIf1; - } - foreach (bool l4 in YP.unify(T, Tokens)) - { - foreach (bool l5 in rest_symbol(C2, Chars, NextCh)) - { - foreach (bool l6 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(47, Chars))) - { - yield return false; - } - } - } - cutIf1: - { } - } - } - } - { - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 33)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@"!"), Pos), Tokens))) - { - foreach (bool l4 in get_current_position(Pos)) - { - foreach (bool l5 in YP.get_code(NextCh)) - { - foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 40)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@" ("), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 41)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@")"), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 44)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@","), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 59)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@";"), Pos), Tokens))) - { - foreach (bool l4 in get_current_position(Pos)) - { - foreach (bool l5 in YP.get_code(NextCh)) - { - foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - { - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 91)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Tokens))) - { - foreach (bool l4 in get_current_position(Pos)) - { - foreach (bool l5 in YP.get_code(NextCh)) - { - foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - { - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 93)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Tokens))) - { - foreach (bool l4 in get_current_position(Pos)) - { - foreach (bool l5 in YP.get_code(NextCh)) - { - foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - { - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 123)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"{"), Pos), Tokens))) - { - foreach (bool l4 in get_current_position(Pos)) - { - foreach (bool l5 in YP.get_code(NextCh)) - { - foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 124)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"|"), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 125)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"}"), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - object Tokens = arg3; - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 46)) - { - foreach (bool l3 in YP.get_code(NextCh)) - { - foreach (bool l4 in read_fullstop(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - { - Variable Chars = new Variable(); - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 34)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"string", Chars), Tokens))) - { - foreach (bool l4 in read_string(Chars, 34, NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - { - object Tokens = arg3; - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 39)) - { - foreach (bool l3 in read_string(Chars, 39, NextCh)) - { - foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, Chars)) - { - yield return false; - } - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 35)) - { - foreach (bool l3 in read_symbol(35, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 36)) - { - foreach (bool l3 in read_symbol(36, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 38)) - { - foreach (bool l3 in read_symbol(38, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 42)) - { - foreach (bool l3 in read_symbol(42, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 43)) - { - foreach (bool l3 in read_symbol(43, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 45)) - { - foreach (bool l3 in read_symbol(45, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 58)) - { - foreach (bool l3 in read_symbol(58, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 60)) - { - foreach (bool l3 in read_symbol(60, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 61)) - { - foreach (bool l3 in read_symbol(61, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 62)) - { - foreach (bool l3 in read_symbol(62, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 63)) - { - foreach (bool l3 in read_symbol(63, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 64)) - { - foreach (bool l3 in read_symbol(64, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 92)) - { - foreach (bool l3 in read_symbol(92, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 94)) - { - foreach (bool l3 in read_symbol(94, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 96)) - { - foreach (bool l3 in read_symbol(96, Dict, Tokens)) - { - yield return false; - } - } - } - { - object Tokens = arg3; - foreach (bool l2 in YP.unify(arg1, 126)) - { - foreach (bool l3 in read_symbol(126, Dict, Tokens)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_symbol(object C1, object Dict, object Tokens) - { - { - Variable C2 = new Variable(); - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.get_code(C2)) - { - foreach (bool l3 in rest_symbol(C2, Chars, NextCh)) - { - foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(C1, Chars))) - { - yield return false; - } - } - } - } - } - - public static IEnumerable rest_symbol(object arg1, object arg2, object arg3) - { - { - object C2 = arg1; - object LastCh = arg3; - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(C2, Chars))) - { - if (YP.greaterThan(C2, 160)) - { - if (YP.lessThan(C2, 192)) - { - if (YP.notEqual(C2, 186)) - { - if (YP.notEqual(C2, 170)) - { - foreach (bool l7 in YP.get_code(NextCh)) - { - foreach (bool l8 in rest_symbol(NextCh, Chars, LastCh)) - { - yield return false; - } - } - yield break; - } - } - } - goto cutIf1; - } - foreach (bool l3 in symbol_char(C2)) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in rest_symbol(NextCh, Chars, LastCh)) - { - yield return false; - } - } - yield break; - } - cutIf1: - { } - } - } - { - Variable C2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, C2)) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - foreach (bool l4 in YP.unify(arg3, C2)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable symbol_char(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, 35)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 36)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 38)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 42)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 43)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 45)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 46)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 47)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 58)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 60)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 61)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 62)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 63)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 64)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 92)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 94)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 96)) - { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, 126)) - { - yield return false; - } - } - } - - public static IEnumerable get_current_position(object Pos) - { - { - foreach (bool l2 in YP.unify(Pos, 0)) - { - yield return false; - } - } - } - - public static IEnumerable read_after_atom4(object Ch, object Dict, object arg3, object Chars) - { - { - Variable Atom_1 = new Variable(); - Variable Pos = new Variable(); - Variable Tokens = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom_1, Pos), Tokens))) - { - foreach (bool l3 in YP.unify(Pos, 0)) - { - foreach (bool l4 in YP.atom_codes(Atom_1, Chars)) - { - foreach (bool l5 in read_after_atom(Ch, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - - public static IEnumerable read_after_atom(object arg1, object Dict, object arg3) - { - { - Variable Tokens = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, 40)) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"("), Tokens))) - { - foreach (bool l4 in YP.get_code(NextCh)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - yield break; - } - } - } - { - object Ch = arg1; - object Tokens = arg3; - foreach (bool l2 in read_tokens(Ch, Dict, Tokens)) - { - yield return false; - } - } - } - - public static IEnumerable read_string(object Chars, object Quote, object NextCh) - { - { - Variable Ch = new Variable(); - Variable Char = new Variable(); - Variable Next = new Variable(); - foreach (bool l2 in YP.get_code(Ch)) - { - foreach (bool l3 in read_char(Ch, Quote, Char, Next)) - { - foreach (bool l4 in rest_string5(Char, Next, Chars, Quote, NextCh)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable rest_string5(object arg1, object arg2, object arg3, object arg4, object arg5) - { - { - object _X = arg4; - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg1, -1)) - { - foreach (bool l3 in YP.unify(arg2, NextCh)) - { - foreach (bool l4 in YP.unify(arg3, Atom.NIL)) - { - foreach (bool l5 in YP.unify(arg5, NextCh)) - { - yield return true; - yield break; - } - } - } - } - } - { - object Char = arg1; - object Next = arg2; - object Quote = arg4; - object NextCh = arg5; - Variable Chars = new Variable(); - Variable Char2 = new Variable(); - Variable Next2 = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(Char, Chars))) - { - foreach (bool l3 in read_char(Next, Quote, Char2, Next2)) - { - foreach (bool l4 in rest_string5(Char2, Next2, Chars, Quote, NextCh)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable escape_char(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, 110)) - { - foreach (bool l3 in YP.unify(arg2, 10)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 78)) - { - foreach (bool l3 in YP.unify(arg2, 10)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 116)) - { - foreach (bool l3 in YP.unify(arg2, 9)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 84)) - { - foreach (bool l3 in YP.unify(arg2, 9)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 114)) - { - foreach (bool l3 in YP.unify(arg2, 13)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 82)) - { - foreach (bool l3 in YP.unify(arg2, 13)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 118)) - { - foreach (bool l3 in YP.unify(arg2, 11)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 86)) - { - foreach (bool l3 in YP.unify(arg2, 11)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 98)) - { - foreach (bool l3 in YP.unify(arg2, 8)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 66)) - { - foreach (bool l3 in YP.unify(arg2, 8)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 102)) - { - foreach (bool l3 in YP.unify(arg2, 12)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 70)) - { - foreach (bool l3 in YP.unify(arg2, 12)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 101)) - { - foreach (bool l3 in YP.unify(arg2, 27)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 69)) - { - foreach (bool l3 in YP.unify(arg2, 27)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 100)) - { - foreach (bool l3 in YP.unify(arg2, 127)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 68)) - { - foreach (bool l3 in YP.unify(arg2, 127)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 115)) - { - foreach (bool l3 in YP.unify(arg2, 32)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 83)) - { - foreach (bool l3 in YP.unify(arg2, 32)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 122)) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, 90)) - { - foreach (bool l3 in YP.unify(arg2, -1)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_variable(object C1, object Dict, object arg3) - { - { - Variable Var = new Variable(); - Variable Name = new Variable(); - Variable StartPos = new Variable(); - Variable Tokens = new Variable(); - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor3(@"var", Var, Name, StartPos), Tokens))) - { - foreach (bool l3 in get_current_position(StartPos)) - { - foreach (bool l4 in read_name(C1, Chars, NextCh)) - { - foreach (bool l5 in YP.atom_codes(Name, Chars)) - { - if (YP.termEqual(Name, Atom.a(@"_"))) - { - foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - goto cutIf1; - } - foreach (bool l6 in read_lookup(Dict, Name, Var)) - { - foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) - { - yield return false; - } - } - cutIf1: - { } - } - } - } - } - } - } - - public static IEnumerable read_lookup(object arg1, object Name, object Var) - { - { - Variable N = new Variable(); - Variable V = new Variable(); - Variable L = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", N, V), L))) - { - foreach (bool l3 in YP.unify(N, Name)) - { - foreach (bool l4 in YP.unify(V, Var)) - { - yield return false; - } - goto cutIf1; - } - foreach (bool l3 in read_lookup(L, Name, Var)) - { - yield return false; - } - cutIf1: - { } - } - } - } - - public static IEnumerable read_solidus(object Ch, object LastCh) - { - { - Variable NextCh = new Variable(); - if (YP.equal(Ch, 42)) - { - foreach (bool l3 in YP.get_code(NextCh)) - { - if (YP.equal(NextCh, 47)) - { - foreach (bool l5 in YP.get_code(LastCh)) - { - yield return false; - } - goto cutIf2; - } - foreach (bool l4 in read_solidus(NextCh, LastCh)) - { - yield return false; - } - cutIf2: - { } - } - goto cutIf1; - } - if (YP.notEqual(Ch, -1)) - { - foreach (bool l3 in YP.get_code(NextCh)) - { - foreach (bool l4 in read_solidus(NextCh, LastCh)) - { - yield return false; - } - } - goto cutIf3; - } - foreach (bool l2 in YP.unify(LastCh, Ch)) - { - foreach (bool l3 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in /*comment~n"), Atom.NIL)) - { - yield return false; - } - } - cutIf3: - cutIf1: - { } - } - } - - public static IEnumerable read_identifier(object C1, object Dict, object Tokens) - { - { - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in read_name(C1, Chars, NextCh)) - { - foreach (bool l3 in read_after_atom4(NextCh, Dict, Tokens, Chars)) - { - yield return false; - } - } - } - } - - public static IEnumerable read_name(object C1, object arg2, object LastCh) - { - { - Variable Chars = new Variable(); - Variable C2 = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) - { - foreach (bool l3 in YP.get_code(C2)) - { - if (YP.greaterThanOrEqual(C2, new ListPair(97, Atom.NIL))) - { - if (YP.lessThanOrEqual(C2, new ListPair(122, Atom.NIL))) - { - foreach (bool l6 in read_name(C2, Chars, LastCh)) - { - yield return false; - } - goto cutIf2; - } - if (YP.lessThan(C2, 192)) - { - if (YP.notEqual(YP.bitwiseOr(C2, 16), 186)) - { - foreach (bool l7 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l8 in YP.unify(LastCh, C2)) - { - yield return false; - } - } - goto cutIf3; - } - } - if (YP.equal(YP.bitwiseOr(C2, 32), 247)) - { - foreach (bool l6 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l7 in YP.unify(LastCh, C2)) - { - yield return false; - } - } - goto cutIf4; - } - foreach (bool l5 in read_name(C2, Chars, LastCh)) - { - yield return false; - } - cutIf4: - cutIf3: - cutIf2: - goto cutIf1; - } - if (YP.greaterThanOrEqual(C2, new ListPair(65, Atom.NIL))) - { - if (YP.greaterThan(C2, new ListPair(90, Atom.NIL))) - { - if (YP.notEqual(C2, new ListPair(95, Atom.NIL))) - { - foreach (bool l7 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l8 in YP.unify(LastCh, C2)) - { - yield return false; - } - } - goto cutIf6; - } - } - foreach (bool l5 in read_name(C2, Chars, LastCh)) - { - yield return false; - } - cutIf6: - goto cutIf5; - } - if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) - { - foreach (bool l6 in read_name(C2, Chars, LastCh)) - { - yield return false; - } - goto cutIf7; - } - } - foreach (bool l4 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l5 in YP.unify(LastCh, C2)) - { - yield return false; - } - } - cutIf7: - cutIf5: - cutIf1: - { } - } - } - } - } - - public static IEnumerable read_fullstop(object Ch, object Dict, object Tokens) - { - { - Variable Number = new Variable(); - Variable Tokens1 = new Variable(); - Variable Chars = new Variable(); - Variable NextCh = new Variable(); - if (YP.lessThanOrEqual(Ch, new ListPair(57, Atom.NIL))) - { - if (YP.greaterThanOrEqual(Ch, new ListPair(48, Atom.NIL))) - { - foreach (bool l4 in YP.unify(Tokens, new ListPair(new Functor1(@"number", Number), Tokens1))) - { - foreach (bool l5 in read_float(Number, Dict, Tokens1, new ListPair(48, Atom.NIL), Ch)) - { - yield return false; - } - } - goto cutIf1; - } - } - if (YP.greaterThan(Ch, new ListPair(32, Atom.NIL))) - { - foreach (bool l3 in rest_symbol(Ch, Chars, NextCh)) - { - foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(46, Chars))) - { - yield return false; - } - } - goto cutIf2; - } - if (YP.greaterThanOrEqual(Ch, 0)) - { - foreach (bool l3 in YP.unify(Tokens, Atom.NIL)) - { - yield return false; - } - goto cutIf3; - } - foreach (bool l2 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file just after full stop~n"), Atom.NIL)) - { - } - cutIf3: - cutIf2: - cutIf1: - { } - } - } - - public static IEnumerable read_float(object Number, object Dict, object Tokens, object Digits, object Digit) - { - { - Variable Chars = new Variable(); - Variable Rest = new Variable(); - Variable NextCh = new Variable(); - foreach (bool l2 in prepend(Digits, Chars, Rest)) - { - foreach (bool l3 in read_float(Digit, Rest, NextCh, Chars)) - { - foreach (bool l4 in YP.number_codes(Number, Chars)) - { - foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) - { - yield return false; - } - } - } - } - } - } - - public static IEnumerable prepend(object arg1, object arg2, object arg3) - { - { - object X = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(46, X))) - { - yield return false; - } - } - } - { - object Y = arg3; - Variable C = new Variable(); - Variable Cs = new Variable(); - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(C, Cs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(C, X))) - { - foreach (bool l4 in prepend(Cs, X, Y)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable read_float(object C1, object arg2, object NextCh, object Total) - { - { - Variable Chars = new Variable(); - Variable C2 = new Variable(); - Variable C3 = new Variable(); - Variable C4 = new Variable(); - Variable More = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) - { - foreach (bool l3 in YP.get_code(C2)) - { - if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) - { - foreach (bool l6 in read_float(C2, Chars, NextCh, Total)) - { - yield return false; - } - goto cutIf1; - } - } - if (YP.equal(YP.bitwiseOr(C2, 32), new ListPair(101, Atom.NIL))) - { - foreach (bool l5 in YP.get_code(C3)) - { - if (YP.equal(C3, new ListPair(45, Atom.NIL))) - { - foreach (bool l7 in YP.get_code(C4)) - { - foreach (bool l8 in YP.unify(Chars, new ListPair(C2, new ListPair(45, More)))) - { - if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) - { - foreach (bool l11 in read_exponent(C4, More, NextCh)) - { - yield return false; - } - goto cutIf4; - } - } - foreach (bool l9 in YP.unify(More, Atom.NIL)) - { - foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) - { - } - } - foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) - { - foreach (bool l10 in YP.unify(NextCh, C4)) - { - yield return false; - } - } - cutIf4: - { } - } - } - goto cutIf3; - } - if (YP.equal(C3, new ListPair(43, Atom.NIL))) - { - foreach (bool l7 in YP.get_code(C4)) - { - foreach (bool l8 in YP.unify(Chars, new ListPair(C2, More))) - { - if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) - { - foreach (bool l11 in read_exponent(C4, More, NextCh)) - { - yield return false; - } - goto cutIf6; - } - } - foreach (bool l9 in YP.unify(More, Atom.NIL)) - { - foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) - { - } - } - foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) - { - foreach (bool l10 in YP.unify(NextCh, C4)) - { - yield return false; - } - } - cutIf6: - { } - } - } - goto cutIf5; - } - foreach (bool l6 in YP.unify(C4, C3)) - { - foreach (bool l7 in YP.unify(Chars, new ListPair(C2, More))) - { - if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) - { - foreach (bool l10 in read_exponent(C4, More, NextCh)) - { - yield return false; - } - goto cutIf7; - } - } - foreach (bool l8 in YP.unify(More, Atom.NIL)) - { - foreach (bool l9 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) - { - } - } - foreach (bool l8 in YP.unify(More, new ListPair(48, Atom.NIL))) - { - foreach (bool l9 in YP.unify(NextCh, C4)) - { - yield return false; - } - } - cutIf7: - { } - } - } - cutIf5: - cutIf3: - { } - } - goto cutIf2; - } - foreach (bool l4 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l5 in YP.unify(NextCh, C2)) - { - yield return false; - } - } - cutIf2: - cutIf1: - { } - } - } - } - } - - public static IEnumerable read_exponent(object C1, object arg2, object NextCh) - { - { - Variable Chars = new Variable(); - Variable C2 = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) - { - foreach (bool l3 in YP.get_code(C2)) - { - if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) - { - foreach (bool l6 in read_exponent(C2, Chars, NextCh)) - { - yield return false; - } - goto cutIf1; - } - } - foreach (bool l4 in YP.unify(Chars, Atom.NIL)) - { - foreach (bool l5 in YP.unify(NextCh, C2)) - { - yield return false; - } - } - cutIf1: - { } - } - } - } - } - - public static IEnumerable read_number(object C1, object Dict, object arg3) - { - { - Variable Number = new Variable(); - Variable Tokens = new Variable(); - Variable C2 = new Variable(); - Variable N = new Variable(); - Variable C = new Variable(); - Variable C3 = new Variable(); - Variable Digits = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor1(@"number", Number), Tokens))) - { - foreach (bool l3 in read_number4(C1, C2, 0, N)) - { - if (YP.equal(C2, 39)) - { - if (YP.greaterThanOrEqual(N, 2)) - { - if (YP.lessThanOrEqual(N, 36)) - { - foreach (bool l7 in read_based(N, 0, Number, C)) - { - foreach (bool l8 in read_tokens(C, Dict, Tokens)) - { - yield return false; - } - } - goto cutIf2; - } - } - if (YP.equal(N, 0)) - { - foreach (bool l6 in YP.get_code(C3)) - { - foreach (bool l7 in read_char(C3, -1, Number, C)) - { - foreach (bool l8 in read_tokens(C, Dict, Tokens)) - { - yield return false; - } - } - } - goto cutIf3; - } - foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** ~d' read as ~d '~n"), new ListPair(N, new ListPair(N, Atom.NIL)))) - { - foreach (bool l6 in YP.unify(Number, N)) - { - foreach (bool l7 in YP.unify(C, C2)) - { - foreach (bool l8 in read_tokens(C, Dict, Tokens)) - { - yield return false; - } - } - } - } - cutIf3: - cutIf2: - goto cutIf1; - } - if (YP.equal(C2, 46)) - { - foreach (bool l5 in YP.get_code(C3)) - { - if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C3, new ListPair(57, Atom.NIL))) - { - foreach (bool l8 in YP.number_codes(N, Digits)) - { - foreach (bool l9 in read_float(Number, Dict, Tokens, Digits, C3)) - { - yield return false; - } - } - goto cutIf5; - } - } - foreach (bool l6 in YP.unify(Number, N)) - { - foreach (bool l7 in read_fullstop(C3, Dict, Tokens)) - { - yield return false; - } - } - cutIf5: - { } - } - goto cutIf4; - } - foreach (bool l4 in YP.unify(Number, N)) - { - foreach (bool l5 in read_tokens(C2, Dict, Tokens)) - { - yield return false; - } - } - cutIf4: - cutIf1: - { } - } - } - } - } - - public static IEnumerable read_number4(object C0, object C, object N0, object N) - { - { - Variable N1 = new Variable(); - Variable C1 = new Variable(); - if (YP.greaterThanOrEqual(C0, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C0, new ListPair(57, Atom.NIL))) - { - foreach (bool l4 in YP.unify(N1, YP.add(YP.subtract(YP.multiply(N0, 10), new ListPair(48, Atom.NIL)), C0))) - { - foreach (bool l5 in YP.get_code(C1)) - { - foreach (bool l6 in read_number4(C1, C, N1, N)) - { - yield return false; - } - } - } - goto cutIf1; - } - } - if (YP.equal(C0, 95)) - { - foreach (bool l3 in YP.get_code(C1)) - { - foreach (bool l4 in read_number4(C1, C, N0, N)) - { - yield return false; - } - } - goto cutIf2; - } - foreach (bool l2 in YP.unify(C, C0)) - { - foreach (bool l3 in YP.unify(N, N0)) - { - yield return false; - } - } - cutIf2: - cutIf1: - { } - } - } - - public static IEnumerable read_based(object Base, object N0, object N, object C) - { - { - Variable C1 = new Variable(); - Variable Digit = new Variable(); - Variable N1 = new Variable(); - foreach (bool l2 in YP.get_code(C1)) - { - if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) - { - foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, new ListPair(48, Atom.NIL)))) - { - if (YP.lessThan(Digit, Base)) - { - foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) - { - foreach (bool l8 in read_based(Base, N1, N, C)) - { - yield return false; - } - } - goto cutIf2; - } - if (YP.equal(C1, new ListPair(95, Atom.NIL))) - { - foreach (bool l7 in read_based(Base, N0, N, C)) - { - yield return false; - } - goto cutIf3; - } - foreach (bool l6 in YP.unify(N, N0)) - { - foreach (bool l7 in YP.unify(C, C1)) - { - yield return false; - } - } - cutIf3: - cutIf2: - { } - } - goto cutIf1; - } - } - if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) - { - foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(65, Atom.NIL), 10)))) - { - if (YP.lessThan(Digit, Base)) - { - foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) - { - foreach (bool l8 in read_based(Base, N1, N, C)) - { - yield return false; - } - } - goto cutIf5; - } - if (YP.equal(C1, new ListPair(95, Atom.NIL))) - { - foreach (bool l7 in read_based(Base, N0, N, C)) - { - yield return false; - } - goto cutIf6; - } - foreach (bool l6 in YP.unify(N, N0)) - { - foreach (bool l7 in YP.unify(C, C1)) - { - yield return false; - } - } - cutIf6: - cutIf5: - { } - } - goto cutIf4; - } - } - if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) - { - if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) - { - foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(97, Atom.NIL), 10)))) - { - if (YP.lessThan(Digit, Base)) - { - foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) - { - foreach (bool l8 in read_based(Base, N1, N, C)) - { - yield return false; - } - } - goto cutIf8; - } - if (YP.equal(C1, new ListPair(95, Atom.NIL))) - { - foreach (bool l7 in read_based(Base, N0, N, C)) - { - yield return false; - } - goto cutIf9; - } - foreach (bool l6 in YP.unify(N, N0)) - { - foreach (bool l7 in YP.unify(C, C1)) - { - yield return false; - } - } - cutIf9: - cutIf8: - { } - } - goto cutIf7; - } - } - foreach (bool l3 in YP.unify(Digit, 99)) - { - if (YP.lessThan(Digit, Base)) - { - foreach (bool l5 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) - { - foreach (bool l6 in read_based(Base, N1, N, C)) - { - yield return false; - } - } - goto cutIf10; - } - if (YP.equal(C1, new ListPair(95, Atom.NIL))) - { - foreach (bool l5 in read_based(Base, N0, N, C)) - { - yield return false; - } - goto cutIf11; - } - foreach (bool l4 in YP.unify(N, N0)) - { - foreach (bool l5 in YP.unify(C, C1)) - { - yield return false; - } - } - cutIf11: - cutIf10: - { } - } - cutIf7: - cutIf4: - cutIf1: - { } - } - } - } - - public static IEnumerable read_char(object Char, object Quote, object Result, object Next) - { - { - Variable C1 = new Variable(); - Variable C2 = new Variable(); - Variable C3 = new Variable(); - Variable Ch = new Variable(); - if (YP.equal(Char, 92)) - { - foreach (bool l3 in YP.get_code(C1)) - { - if (YP.lessThan(C1, 0)) - { - foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~cquoted~c~n"), new ListPair(Quote, new ListPair(Quote, Atom.NIL)))) - { - foreach (bool l6 in YP.unify(Result, -1)) - { - foreach (bool l7 in YP.unify(Next, C1)) - { - yield return false; - } - } - } - goto cutIf2; - } - if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) - { - foreach (bool l5 in YP.get_code(C2)) - { - foreach (bool l6 in read_char(C2, Quote, Result, Next)) - { - yield return false; - } - } - goto cutIf3; - } - if (YP.equal(YP.bitwiseOr(C1, 32), new ListPair(99, Atom.NIL))) - { - foreach (bool l5 in YP.get_code(C2)) - { - foreach (bool l6 in read_char(C2, Quote, Result, Next)) - { - yield return false; - } - } - goto cutIf4; - } - if (YP.lessThanOrEqual(C1, new ListPair(55, Atom.NIL))) - { - if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) - { - foreach (bool l6 in YP.get_code(C2)) - { - if (YP.lessThanOrEqual(C2, new ListPair(55, Atom.NIL))) - { - if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) - { - foreach (bool l9 in YP.get_code(C3)) - { - if (YP.lessThanOrEqual(C3, new ListPair(55, Atom.NIL))) - { - if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) - { - foreach (bool l12 in YP.get_code(Next)) - { - foreach (bool l13 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(YP.add(YP.multiply(C1, 8), C2), 8), C3), YP.multiply(73, new ListPair(48, Atom.NIL))))) - { - yield return false; - } - } - goto cutIf7; - } - } - foreach (bool l10 in YP.unify(Next, C3)) - { - foreach (bool l11 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(C1, 8), C2), YP.multiply(9, new ListPair(48, Atom.NIL))))) - { - yield return false; - } - } - cutIf7: - { } - } - goto cutIf6; - } - } - foreach (bool l7 in YP.unify(Next, C2)) - { - foreach (bool l8 in YP.unify(Result, YP.subtract(C1, new ListPair(48, Atom.NIL)))) - { - yield return false; - } - } - cutIf6: - { } - } - goto cutIf5; - } - } - if (YP.equal(C1, new ListPair(94, Atom.NIL))) - { - foreach (bool l5 in YP.get_code(C2)) - { - if (YP.lessThan(C2, 0)) - { - foreach (bool l7 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~c..~c^..~c~n"), new ListPair(Quote, new ListPair(92, new ListPair(Quote, Atom.NIL))))) - { - foreach (bool l8 in YP.unify(Result, -1)) - { - foreach (bool l9 in YP.unify(Next, C2)) - { - yield return false; - } - } - } - goto cutIf9; - } - if (YP.equal(C2, new ListPair(63, Atom.NIL))) - { - foreach (bool l7 in YP.unify(Result, 127)) - { - foreach (bool l8 in YP.get_code(Next)) - { - yield return false; - } - } - goto cutIf10; - } - foreach (bool l6 in YP.unify(Result, YP.bitwiseAnd(C2, 31))) - { - foreach (bool l7 in YP.get_code(Next)) - { - yield return false; - } - } - cutIf10: - cutIf9: - { } - } - goto cutIf8; - } - foreach (bool l4 in escape_char(C1, Result)) - { - foreach (bool l5 in YP.get_code(Next)) - { - yield return false; - } - goto cutIf11; - } - foreach (bool l4 in YP.unify(Result, C1)) - { - foreach (bool l5 in YP.get_code(Next)) - { - yield return false; - } - } - cutIf11: - cutIf8: - cutIf5: - cutIf4: - cutIf3: - cutIf2: - { } - } - goto cutIf1; - } - if (YP.equal(Char, Quote)) - { - foreach (bool l3 in YP.get_code(Ch)) - { - if (YP.equal(Ch, Quote)) - { - foreach (bool l5 in YP.unify(Result, Quote)) - { - foreach (bool l6 in YP.get_code(Next)) - { - yield return false; - } - } - goto cutIf13; - } - foreach (bool l4 in YP.unify(Result, -1)) - { - foreach (bool l5 in YP.unify(Next, Ch)) - { - yield return false; - } - } - cutIf13: - { } - } - goto cutIf12; - } - if (YP.lessThan(Char, new ListPair(32, Atom.NIL))) - { - if (YP.notEqual(Char, 9)) - { - if (YP.notEqual(Char, 10)) - { - if (YP.notEqual(Char, 13)) - { - foreach (bool l6 in YP.unify(Result, -1)) - { - foreach (bool l7 in YP.unify(Next, Char)) - { - foreach (bool l8 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Strange character ~d ends ~ctoken~c~n"), new ListPair(Char, new ListPair(Quote, new ListPair(Quote, Atom.NIL))))) - { - yield return false; - } - } - } - goto cutIf14; - } - } - } - } - foreach (bool l2 in YP.unify(Result, Char)) - { - foreach (bool l3 in YP.get_code(Next)) - { - yield return false; - } - } - cutIf14: - cutIf12: - cutIf1: - { } - } - } - - } -} +/* + * 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.Generic; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class Parser + { + public static IEnumerable formatError(object Output, object Format, object Arguments) + { + // Debug: Simple implementation for now. + YP.write(Format); + YP.write(Arguments); + YP.nl(); + yield return false; + } + + // Debug: Hand-modify this central predicate to do tail recursion. + public static IEnumerable read_tokens(object arg1, object arg2, object arg3) + { + bool repeat = true; + while (repeat) + { + repeat = false; + { + object C1 = arg1; + object Dict = arg2; + object Tokens = arg3; + Variable C2 = new Variable(); + if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C1, 0)) + { + foreach (bool l4 in YP.get_code(C2)) + { +#if false + foreach (bool l5 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } +#endif + arg1 = YP.getValue(C2); + arg2 = YP.getValue(Dict); + arg3 = YP.getValue(Tokens); + repeat = true; + } + } + goto cutIf1; + } + if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) + { + foreach (bool l4 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf2; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) + { + foreach (bool l4 in read_variable(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf3; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) + { + foreach (bool l4 in read_number(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf4; + } + } + if (YP.lessThan(C1, 127)) + { + foreach (bool l3 in read_special(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf5; + } + if (YP.lessThanOrEqual(C1, 160)) + { + foreach (bool l3 in YP.get_code(C2)) + { +#if false + foreach (bool l4 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } +#endif + arg1 = YP.getValue(C2); + arg2 = YP.getValue(Dict); + arg3 = YP.getValue(Tokens); + repeat = true; + } + goto cutIf6; + } + if (YP.greaterThanOrEqual(C1, 223)) + { + if (YP.notEqual(C1, 247)) + { + foreach (bool l4 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf7; + } + } + if (YP.greaterThanOrEqual(C1, 192)) + { + if (YP.notEqual(C1, 215)) + { + foreach (bool l4 in read_variable(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf8; + } + } + if (YP.notEqual(C1, 170)) + { + if (YP.notEqual(C1, 186)) + { + foreach (bool l4 in read_symbol(C1, Dict, Tokens)) + { + yield return false; + } + goto cutIf9; + } + } + foreach (bool l2 in read_identifier(C1, Dict, Tokens)) + { + yield return false; + } + cutIf9: + cutIf8: + cutIf7: + cutIf6: + cutIf5: + cutIf4: + cutIf3: + cutIf2: + cutIf1: + { } + } + } + } + + // Compiler output follows. + + class YPInnerClass { } + static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } + + public static IEnumerable parseInput(object TermList) + { + { + Variable TermAndVariables = new Variable(); + FindallAnswers findallAnswers1 = new FindallAnswers(TermAndVariables); + foreach (bool l2 in parseInputHelper(TermAndVariables)) + { + findallAnswers1.add(); + } + foreach (bool l2 in findallAnswers1.result(TermList)) + { + yield return false; + } + } + } + + public static IEnumerable parseInputHelper(object arg1) + { + { + Variable Term = new Variable(); + Variable Variables = new Variable(); + Variable Answer = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"f", Term, Variables))) + { + foreach (bool l3 in YP.repeat()) + { + foreach (bool l4 in portable_read3(Answer, Variables, x4)) + { + foreach (bool l5 in remove_pos(Answer, Term)) + { + if (YP.termEqual(Term, Atom.a(@"end_of_file"))) + { + yield break; + goto cutIf1; + } + yield return false; + cutIf1: + { } + } + } + } + } + } + } + + public static IEnumerable clear_errors() + { + { + yield return false; + } + } + + public static IEnumerable remove_pos(object arg1, object arg2) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, X)) + { + foreach (bool l3 in YP.unify(arg2, X)) + { + if (YP.var(X)) + { + yield return true; + yield break; + } + } + } + } + { + object X = arg2; + Variable _Pos = new Variable(); + Variable _Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"$VAR", _Pos, _Name, X))) + { + if (YP.var(X)) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + Variable H = new Variable(); + Variable T = new Variable(); + Variable NH = new Variable(); + Variable NT = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(NH, NT))) + { + foreach (bool l4 in remove_pos(H, NH)) + { + foreach (bool l5 in remove_pos(T, NT)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable A = new Variable(); + Variable B = new Variable(); + Variable NA = new Variable(); + Variable NB = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg2, new Functor2(@",", NA, NB))) + { + foreach (bool l4 in remove_pos(A, NA)) + { + foreach (bool l5 in remove_pos(B, NB)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable Atom_1 = new Variable(); + Variable _F = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom_1)) + { + foreach (bool l3 in YP.unify(arg2, Atom_1)) + { + foreach (bool l4 in YP.functor(Atom_1, _F, 0)) + { + yield return false; + } + } + } + } + { + object Term = arg1; + object NewTerm = arg2; + Variable Func = new Variable(); + Variable _Pos = new Variable(); + Variable Args = new Variable(); + Variable NArgs = new Variable(); + if (YP.nonvar(Term)) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Func, new ListPair(_Pos, Args)))) + { + foreach (bool l4 in remove_pos(Args, NArgs)) + { + foreach (bool l5 in YP.univ(NewTerm, new ListPair(Func, NArgs))) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable portable_read_position(object Term, object PosTerm, object Syntax) + { + { + foreach (bool l2 in portable_read(PosTerm, Syntax)) + { + foreach (bool l3 in remove_pos(PosTerm, Term)) + { + yield return false; + } + } + } + } + + public static IEnumerable portable_read(object Answer, object Syntax) + { + { + Variable Tokens = new Variable(); + Variable ParseTokens = new Variable(); + foreach (bool l2 in read_tokens1(Tokens)) + { + foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) + { + foreach (bool l4 in parse2(ParseTokens, Answer)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable portable_read3(object Answer, object Variables, object Syntax) + { + { + Variable Tokens = new Variable(); + Variable ParseTokens = new Variable(); + foreach (bool l2 in read_tokens2(Tokens, Variables)) + { + foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) + { + foreach (bool l4 in parse2(ParseTokens, Answer)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable remove_comments(object arg1, object arg2, object arg3) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return false; + } + } + } + } + { + object Ys = arg2; + Variable S = new Variable(); + Variable E = new Variable(); + Variable Xs = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"comment", S, E), Xs))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", S, E), Zs))) + { + foreach (bool l4 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + yield break; + } + } + } + { + Variable Pos = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + Variable Pos2 = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"["), Ys))) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) + { + foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) + { + foreach (bool l6 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + Variable Pos = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + Variable Pos2 = new Variable(); + Variable Zs = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), Ys))) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2(@"list", Pos, Pos2), Zs))) + { + foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) + { + foreach (bool l6 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object Zs = arg3; + Variable Token = new Variable(); + Variable Xs = new Variable(); + Variable Ys = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Xs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Token, Ys))) + { + foreach (bool l4 in remove_comments(Xs, Ys, Zs)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable expect(object Token, object arg2, object arg3) + { + { + object Rest = arg3; + foreach (bool l2 in YP.unify(arg2, new ListPair(Token, Rest))) + { + yield return true; + yield break; + } + } + { + object S0 = arg2; + object x3 = arg3; + foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"or"), new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), Atom.NIL)))), S0)) + { + yield return false; + } + } + } + + public static IEnumerable parse2(object Tokens, object Answer) + { + { + Variable Term = new Variable(); + Variable LeftOver = new Variable(); + foreach (bool l2 in clear_errors()) + { + foreach (bool l3 in parse(Tokens, 1200, Term, LeftOver)) + { + foreach (bool l4 in all_read(LeftOver)) + { + foreach (bool l5 in YP.unify(Answer, Term)) + { + yield return false; + } + yield break; + } + } + foreach (bool l3 in syntax_error(Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable all_read(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + { + Variable Token = new Variable(); + Variable S = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S))) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"operator"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"after"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(Token, S))) + { + yield return false; + } + } + } + } + + public static IEnumerable parse(object arg1, object arg2, object arg3, object arg4) + { + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@"expression"), new ListPair(Atom.a(@"expected"), Atom.NIL)), Atom.NIL)) + { + yield return false; + } + } + } + { + object Precedence = arg2; + object Term = arg3; + object LeftOver = arg4; + Variable Token = new Variable(); + Variable RestTokens = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, RestTokens))) + { + foreach (bool l3 in parse5(Token, RestTokens, Precedence, Term, LeftOver)) + { + yield return false; + } + } + } + } + + public static IEnumerable parse5(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"}"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"]"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in cannot_start(Atom.a(@")"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in cannot_start(Atom.a(@","), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in cannot_start(Atom.a(@"|"), S0)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Chars = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", Chars))) + { + foreach (bool l3 in exprtl0(S0, Chars, Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Number = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", Number))) + { + foreach (bool l3 in exprtl0(S0, Number, Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"]"), S1))) + { + foreach (bool l4 in read_atom(new Functor2(@"/", Atom.NIL, 0), S1, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l4 in read_list(S2, RestArgs, S3)) + { + foreach (bool l5 in exprtl0(S3, new ListPair(Arg1, RestArgs), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@")"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable _Pos = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), _Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"}"), S1))) + { + foreach (bool l4 in read_atom(Atom.a(@"{}"), S1, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object S1 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Pos = new Variable(); + Variable Term = new Variable(); + Variable S2 = new Variable(); + Variable S3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"{"), Pos))) + { + foreach (bool l3 in parse(S1, 1200, Term, S2)) + { + foreach (bool l4 in expect(Atom.a(@"}"), S2, S3)) + { + foreach (bool l5 in exprtl0(S3, new Functor2(@"{}", Pos, Term), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + } + { + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Variable_1 = new Variable(); + Variable Name = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) + { + foreach (bool l4 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l5 in read_args(S2, RestArgs, S3)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Atom.a(@"call"), new ListPair(new Functor3(@"$VAR", Pos, Name, Variable_1), new ListPair(Arg1, RestArgs))))) + { + foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + yield break; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Variable_1 = new Variable(); + Variable Name = new Variable(); + Variable Pos = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", Variable_1, Name, Pos))) + { + foreach (bool l3 in exprtl0(S0, new Functor3(@"$VAR", Pos, Name, Variable_1), Precedence, Answer, S)) + { + yield return false; + } + } + } + { + object S0 = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Atom_1 = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", Atom_1, P))) + { + foreach (bool l3 in read_atom(new Functor2(@"/", Atom_1, P), S0, Precedence, Answer, S)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_atom(object arg1, object arg2, object Precedence, object Answer, object S) + { + { + Variable _Pos = new Variable(); + Variable Number = new Variable(); + Variable S1 = new Variable(); + Variable Negative = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom.a(@"-"), _Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"number", Number), S1))) + { + foreach (bool l4 in YP.unify(Negative, YP.negate(Number))) + { + foreach (bool l5 in exprtl0(S1, Negative, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + { + Variable Functor_1 = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable Arg1 = new Variable(); + Variable S2 = new Variable(); + Variable RestArgs = new Variable(); + Variable S3 = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Functor_1, Pos))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a(@"("), S1))) + { + foreach (bool l4 in parse(S1, 999, Arg1, S2)) + { + foreach (bool l5 in read_args(S2, RestArgs, S3)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Functor_1, new ListPair(Pos, new ListPair(Arg1, RestArgs))))) + { + foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + yield break; + } + } + } + { + object S0 = arg2; + Variable Op = new Variable(); + Variable Pos = new Variable(); + Variable Oprec = new Variable(); + Variable Aprec = new Variable(); + Variable Flag = new Variable(); + Variable Term = new Variable(); + Variable Arg = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Op, Pos))) + { + foreach (bool l3 in prefixop(Op, Oprec, Aprec)) + { + foreach (bool l4 in possible_right_operand(S0, Flag)) + { + if (YP.lessThan(Flag, 0)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, Atom.NIL)))) + { + foreach (bool l7 in exprtl0(S0, Term, Precedence, Answer, S)) + { + yield return false; + } + } + goto cutIf1; + } + if (YP.greaterThan(Oprec, Precedence)) + { + foreach (bool l6 in syntax_error(new ListPair(Atom.a(@"prefix"), new ListPair(Atom.a(@"operator"), new ListPair(Op, new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"context"), new ListPair(Atom.a(@"with"), new ListPair(Atom.a(@"precedence"), new ListPair(Precedence, Atom.NIL)))))))), S0)) + { + yield return false; + } + goto cutIf2; + } + if (YP.greaterThan(Flag, 0)) + { + foreach (bool l6 in parse(S0, Aprec, Arg, S1)) + { + foreach (bool l7 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) + { + foreach (bool l8 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + goto cutIf3; + } + foreach (bool l5 in peepop(S0, S1)) + { + foreach (bool l6 in prefix_is_atom(S1, Oprec)) + { + foreach (bool l7 in exprtl(S1, Oprec, new Functor2(@"/", Op, Pos), Precedence, Answer, S)) + { + yield return false; + } + } + } + foreach (bool l5 in parse(S0, Aprec, Arg, S1)) + { + foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, new ListPair(Arg, Atom.NIL))))) + { + foreach (bool l7 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + cutIf3: + cutIf2: + cutIf1: + { } + } + yield break; + } + } + } + { + object S0 = arg2; + Variable Atom_1 = new Variable(); + Variable Pos = new Variable(); + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", Atom_1, Pos))) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Atom_1, new ListPair(Pos, Atom.NIL)))) + { + foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable cannot_start(object Token, object S0) + { + { + foreach (bool l2 in syntax_error(new ListPair(Token, new ListPair(Atom.a(@"cannot"), new ListPair(Atom.a(@"start"), new ListPair(Atom.a(@"an"), new ListPair(Atom.a(@"expression"), Atom.NIL))))), S0)) + { + yield return false; + } + } + } + + public static IEnumerable read_args(object arg1, object arg2, object arg3) + { + { + object S = arg3; + Variable S1 = new Variable(); + Variable Term = new Variable(); + Variable Rest = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@","), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(Term, Rest))) + { + foreach (bool l4 in parse(S1, 999, Term, S2)) + { + foreach (bool l5 in read_args(S2, Rest, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + } + { + object S = arg3; + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@")"), S))) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object S = arg1; + object x2 = arg2; + object x3 = arg3; + foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", or )"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"arguments"), Atom.NIL)))), S)) + { + yield return false; + } + } + } + + public static IEnumerable read_list(object arg1, object arg2, object arg3) + { + { + object x1 = arg2; + object x2 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), Atom.NIL)) + { + yield return false; + } + } + } + { + object Rest = arg2; + object S = arg3; + Variable Token = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) + { + foreach (bool l3 in read_list4(Token, S1, Rest, S)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_list4(object arg1, object arg2, object arg3, object arg4) + { + { + object S1 = arg2; + object S = arg4; + Variable Term = new Variable(); + Variable Rest = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Term, Rest))) + { + foreach (bool l4 in parse(S1, 999, Term, S2)) + { + foreach (bool l5 in read_list(S2, Rest, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + } + { + object S1 = arg2; + object Rest = arg3; + object S = arg4; + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in parse(S1, 999, Rest, S2)) + { + foreach (bool l4 in expect(Atom.a(@"]"), S2, S)) + { + yield return false; + } + yield break; + } + yield break; + } + } + { + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, S1)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + foreach (bool l5 in YP.unify(arg4, S1)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Token = arg1; + object S1 = arg2; + object x3 = arg3; + object x4 = arg4; + foreach (bool l2 in syntax_error(new ListPair(Atom.a(@", | or ]"), new ListPair(Atom.a(@"expected"), new ListPair(Atom.a(@"in"), new ListPair(Atom.a(@"list"), Atom.NIL)))), new ListPair(Token, S1))) + { + yield return false; + } + } + } + + public static IEnumerable possible_right_operand(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object Flag = arg2; + Variable H = new Variable(); + Variable T = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) + { + foreach (bool l3 in possible_right_operand3(H, Flag, T)) + { + yield return false; + } + } + } + } + + public static IEnumerable possible_right_operand3(object arg1, object arg2, object arg3) + { + { + object x4 = arg3; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + Variable x3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", x1, x2, x3))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x2 = arg3; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", x1))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x2 = arg3; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", x1))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"]"), x1))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a(@"}"), x1))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg2, 1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x1 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + object x3 = arg3; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", x1, x2))) + { + foreach (bool l3 in YP.unify(arg2, 0)) + { + yield return false; + } + } + } + } + + public static IEnumerable peepop(object arg1, object arg2) + { + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor2(@"atom", F, Pos), new ListPair(Atom.a(@"("), S1)))) + { + yield return true; + yield break; + } + } + } + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable L = new Variable(); + Variable P = new Variable(); + Variable R = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, P, R }), S1))) + { + foreach (bool l4 in infixop(F, L, P, R)) + { + yield return false; + } + } + } + } + { + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable S1 = new Variable(); + Variable L = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", F, Pos), S1))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, P), S1))) + { + foreach (bool l4 in postfixop(F, L, P)) + { + yield return false; + } + } + } + } + { + Variable S0 = new Variable(); + foreach (bool l2 in YP.unify(arg1, S0)) + { + foreach (bool l3 in YP.unify(arg2, S0)) + { + yield return false; + } + } + } + } + + public static IEnumerable prefix_is_atom(object arg1, object arg2) + { + { + object Precedence = arg2; + Variable Token = new Variable(); + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, x2))) + { + foreach (bool l3 in prefix_is_atom(Token, Precedence)) + { + yield return false; + } + } + } + { + object P = arg2; + Variable x1 = new Variable(); + Variable L = new Variable(); + Variable x3 = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { x1, L, x3, x4 }))) + { + if (YP.greaterThanOrEqual(L, P)) + { + yield return false; + } + } + } + { + object P = arg2; + Variable x1 = new Variable(); + Variable L = new Variable(); + Variable x3 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), x1, L, x3))) + { + if (YP.greaterThanOrEqual(L, P)) + { + yield return false; + } + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + yield return false; + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + yield return false; + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + yield return false; + } + } + { + object P = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(1100, P)) + { + yield return false; + } + } + } + { + object P = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(1000, P)) + { + yield return false; + } + } + } + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + } + + public static IEnumerable exprtl0(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object x2 = arg3; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, Atom.NIL)) + { + yield return false; + } + } + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable Token = new Variable(); + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) + { + foreach (bool l3 in exprtl0_6(Token, Term, Precedence, Answer, S, S1)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl0_6(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"}"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"}"), S1))) + { + yield return false; + } + } + } + } + } + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"]"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@"]"), S1))) + { + yield return false; + } + } + } + } + } + { + object x2 = arg3; + object S1 = arg6; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@")"))) + { + foreach (bool l3 in YP.unify(arg2, Term)) + { + foreach (bool l4 in YP.unify(arg4, Term)) + { + foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(@")"), S1))) + { + yield return false; + } + } + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(Precedence, 1000)) + { + foreach (bool l4 in parse(S1, 1000, Next, S2)) + { + foreach (bool l5 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(Answer, Term)) + { + foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@","), S1))) + { + yield return false; + } + } + cutIf1: + { } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(Precedence, 1100)) + { + foreach (bool l4 in parse(S1, 1100, Next, S2)) + { + foreach (bool l5 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + goto cutIf2; + } + foreach (bool l3 in YP.unify(Answer, Term)) + { + foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(@"|"), S1))) + { + yield return false; + } + } + cutIf2: + { } + } + } + { + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + object S1 = arg6; + Variable S = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"string", S))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"chars"), new Functor1(@"string", S), S1)) + { + yield return false; + } + } + } + { + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + object S1 = arg6; + Variable N = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"number", N))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"number"), new Functor1(@"number", N), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"}"), S1))) + { + foreach (bool l4 in exprtl0_atom(Atom.a(@"{}"), Term, Precedence, Answer, S, S1)) + { + yield return false; + } + yield break; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"{"))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"brace"), Atom.a(@"{"), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable S1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a(@"]"), S1))) + { + foreach (bool l4 in exprtl0_atom(Atom.NIL, Term, Precedence, Answer, S, S1)) + { + yield return false; + } + yield break; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"["))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"bracket"), Atom.a(@"["), S1)) + { + yield return false; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"("))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) + { + yield return false; + } + } + } + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + object x4 = arg5; + object S1 = arg6; + foreach (bool l2 in YP.unify(arg1, Atom.a(@" ("))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"parenthesis"), Atom.a(@"("), S1)) + { + yield return false; + } + } + } + { + object x4 = arg2; + object x5 = arg3; + object x6 = arg4; + object x7 = arg5; + object S1 = arg6; + Variable A = new Variable(); + Variable B = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"var", A, B, P))) + { + foreach (bool l3 in cannot_follow(Atom.a(@"variable"), new Functor3(@"var", A, B, P), S1)) + { + yield return false; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + object S1 = arg6; + Variable F = new Variable(); + Variable P = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"atom", F, P))) + { + foreach (bool l3 in exprtl0_atom(new Functor2(@"/", F, P), Term, Precedence, Answer, S, S1)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl0_atom(object arg1, object arg2, object arg3, object arg4, object arg5, object S1) + { + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L1 = new Variable(); + Variable O1 = new Variable(); + Variable R1 = new Variable(); + Variable L2 = new Variable(); + Variable O2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in ambigop(F, Precedence, L1, O1, R1, L2, O2)) + { + foreach (bool l4 in prefix_is_atom(S1, Precedence)) + { + foreach (bool l5 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L1 = new Variable(); + Variable O1 = new Variable(); + Variable R1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in infixop(F, L1, O1, R1)) + { + foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object Term = arg2; + object Precedence = arg3; + object Answer = arg4; + object S = arg5; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L2 = new Variable(); + Variable O2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"/", F, Pos))) + { + foreach (bool l3 in postfixop(F, L2, O2)) + { + foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) + { + yield return false; + } + yield break; + } + } + } + { + object X = arg1; + object x2 = arg2; + object x3 = arg3; + object x4 = arg4; + object x5 = arg5; + Variable x7 = new Variable(); + foreach (bool l2 in syntax_error(new ListPair(new Functor2(@"-", Atom.a(@"non"), Atom.a(@"operator")), new ListPair(X, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL)))), new ListPair(new Functor2(@"atom", X, x7), S1))) + { + yield return false; + } + yield break; + } + } + + public static IEnumerable cannot_follow(object Type, object Token, object Tokens) + { + { + foreach (bool l2 in syntax_error(new ListPair(Type, new ListPair(Atom.a(@"follows"), new ListPair(Atom.a(@"expression"), Atom.NIL))), new ListPair(Token, Tokens))) + { + yield return false; + } + } + } + + public static IEnumerable exprtl(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x1 = arg2; + object x3 = arg4; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Term)) + { + foreach (bool l4 in YP.unify(arg5, Term)) + { + foreach (bool l5 in YP.unify(arg6, Atom.NIL)) + { + yield return false; + } + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + Variable Token = new Variable(); + Variable Tokens = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Tokens))) + { + foreach (bool l3 in exprtl_7(Token, C, Term, Precedence, Answer, S, Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable exprtl_7(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7) + { + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L = new Variable(); + Variable O = new Variable(); + Variable R = new Variable(); + Variable Other = new Variable(); + Variable S2 = new Variable(); + Variable Expr = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a(@"infixop", Atom.a(@"")), new object[] { new Functor2(@"/", F, Pos), L, O, R }))) + { + if (YP.greaterThanOrEqual(Precedence, O)) + { + if (YP.lessThanOrEqual(C, L)) + { + foreach (bool l5 in parse(S1, R, Other, S2)) + { + foreach (bool l6 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, new ListPair(Other, Atom.NIL)))))) + { + foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) + { + yield return false; + } + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable F = new Variable(); + Variable Pos = new Variable(); + Variable L = new Variable(); + Variable O = new Variable(); + Variable Expr = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a(@"postfixop", Atom.a(@"")), new Functor2(@"/", F, Pos), L, O))) + { + if (YP.greaterThanOrEqual(Precedence, O)) + { + if (YP.lessThanOrEqual(C, L)) + { + foreach (bool l5 in YP.univ(Expr, new ListPair(F, new ListPair(Pos, new ListPair(Term, Atom.NIL))))) + { + foreach (bool l6 in peepop(S1, S2)) + { + foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) + { + yield return false; + } + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@","))) + { + if (YP.greaterThanOrEqual(Precedence, 1000)) + { + if (YP.lessThan(C, 1000)) + { + foreach (bool l5 in parse(S1, 1000, Next, S2)) + { + foreach (bool l6 in exprtl(S2, 1000, new Functor2(@",", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object C = arg2; + object Term = arg3; + object Precedence = arg4; + object Answer = arg5; + object S = arg6; + object S1 = arg7; + Variable Next = new Variable(); + Variable S2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.a(@"|"))) + { + if (YP.greaterThanOrEqual(Precedence, 1100)) + { + if (YP.lessThan(C, 1100)) + { + foreach (bool l5 in parse(S1, 1100, Next, S2)) + { + foreach (bool l6 in exprtl(S2, 1100, new Functor2(@";", Term, Next), Precedence, Answer, S)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + object Token = arg1; + object x2 = arg2; + object x4 = arg4; + object Tokens = arg7; + Variable Term = new Variable(); + foreach (bool l2 in YP.unify(arg3, Term)) + { + foreach (bool l3 in YP.unify(arg5, Term)) + { + foreach (bool l4 in YP.unify(arg6, new ListPair(Token, Tokens))) + { + yield return false; + } + } + } + } + } + + public static IEnumerable syntax_error(object _Message, object _List) + { + { + yield break; + } + } + + public static IEnumerable syntax_error(object _List) + { + { + yield break; + } + } + + public static IEnumerable prefixop(object F, object O, object Q) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"fx"), F)) + { + foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"fy"), F)) + { + foreach (bool l3 in YP.unify(Q, O)) + { + yield return false; + } + goto cutIf2; + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable postfixop(object F, object P, object O) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"xf"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"yf"), F)) + { + foreach (bool l3 in YP.unify(P, O)) + { + yield return false; + } + goto cutIf2; + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable infixop(object F, object P, object O, object Q) + { + { + foreach (bool l2 in YP.current_op(O, Atom.a(@"xfy"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(Q, O)) + { + yield return false; + } + } + goto cutIf1; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"xfx"), F)) + { + foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(Q, P)) + { + yield return false; + } + } + goto cutIf2; + } + foreach (bool l2 in YP.current_op(O, Atom.a(@"yfx"), F)) + { + foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) + { + foreach (bool l4 in YP.unify(P, O)) + { + yield return false; + } + } + goto cutIf3; + } + cutIf3: + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable ambigop(object F, object Precedence, object L1, object O1, object R1, object L2, object O2) + { + { + foreach (bool l2 in postfixop(F, L2, O2)) + { + if (YP.lessThanOrEqual(O2, Precedence)) + { + foreach (bool l4 in infixop(F, L1, O1, R1)) + { + if (YP.lessThanOrEqual(O1, Precedence)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable read_tokens1(object arg1) + { + { + object TokenList = arg1; + Variable C1 = new Variable(); + Variable _X = new Variable(); + Variable ListOfTokens = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + foreach (bool l3 in read_tokens(C1, _X, ListOfTokens)) + { + foreach (bool l4 in YP.unify(TokenList, ListOfTokens)) + { + yield return false; + } + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) + { + yield return false; + } + } + } + + public static IEnumerable read_tokens2(object arg1, object arg2) + { + { + object TokenList = arg1; + object Dictionary = arg2; + Variable C1 = new Variable(); + Variable Dict = new Variable(); + Variable ListOfTokens = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + foreach (bool l3 in read_tokens(C1, Dict, ListOfTokens)) + { + foreach (bool l4 in terminate_list(Dict)) + { + foreach (bool l5 in YP.unify(Dictionary, Dict)) + { + foreach (bool l6 in YP.unify(TokenList, ListOfTokens)) + { + yield return false; + } + } + yield break; + } + } + } + } + { + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"atom", Atom.a(@"end_of_file"), 0), Atom.NIL))) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return false; + } + } + } + } + + public static IEnumerable terminate_list(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return false; + } + } + { + Variable x1 = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Tail))) + { + foreach (bool l3 in terminate_list(Tail)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_special(object arg1, object Dict, object arg3) + { + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 95)) + { + foreach (bool l3 in read_variable(95, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 247)) + { + foreach (bool l3 in read_symbol(247, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 215)) + { + foreach (bool l3 in read_symbol(215, Dict, Tokens)) + { + yield return false; + } + } + } + { + Variable StartPos = new Variable(); + Variable EndPos = new Variable(); + Variable Tokens = new Variable(); + Variable Ch = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 37)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) + { + foreach (bool l4 in get_current_position(StartPos)) + { + foreach (bool l5 in YP.repeat()) + { + foreach (bool l6 in YP.get_code(Ch)) + { + if (YP.lessThan(Ch, new ListPair(32, Atom.NIL))) + { + if (YP.notEqual(Ch, 9)) + { + if (YP.termNotEqual(Ch, -1)) + { + foreach (bool l10 in get_current_position(EndPos)) + { + foreach (bool l11 in YP.get_code(NextCh)) + { + foreach (bool l12 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + yield break; + } + } + } + } + } + } + } + } + { + object T = arg3; + Variable C2 = new Variable(); + Variable StartPos = new Variable(); + Variable EndPos = new Variable(); + Variable Tokens = new Variable(); + Variable StartPos1 = new Variable(); + Variable NextCh = new Variable(); + Variable Chars = new Variable(); + foreach (bool l2 in YP.unify(arg1, 47)) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.equal(C2, new ListPair(42, Atom.NIL))) + { + foreach (bool l5 in YP.unify(T, new ListPair(new Functor2(@"comment", StartPos, EndPos), Tokens))) + { + foreach (bool l6 in get_current_position(StartPos1)) + { + foreach (bool l7 in YP.unify(StartPos, YP.subtract(StartPos1, 1))) + { + foreach (bool l8 in read_solidus(32, NextCh)) + { + foreach (bool l9 in get_current_position(EndPos)) + { + foreach (bool l10 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + goto cutIf1; + } + foreach (bool l4 in YP.unify(T, Tokens)) + { + foreach (bool l5 in rest_symbol(C2, Chars, NextCh)) + { + foreach (bool l6 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(47, Chars))) + { + yield return false; + } + } + } + cutIf1: + { } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 33)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@"!"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 40)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@" ("), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 41)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@")"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 44)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@","), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 59)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom.a(@";"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 91)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"["), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 93)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"]"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 123)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"/", Atom.a(@"{"), Pos), Tokens))) + { + foreach (bool l4 in get_current_position(Pos)) + { + foreach (bool l5 in YP.get_code(NextCh)) + { + foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 124)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"|"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 125)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"}"), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + object Tokens = arg3; + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 46)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + foreach (bool l4 in read_fullstop(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + { + Variable Chars = new Variable(); + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 34)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"string", Chars), Tokens))) + { + foreach (bool l4 in read_string(Chars, 34, NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + { + object Tokens = arg3; + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 39)) + { + foreach (bool l3 in read_string(Chars, 39, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, Chars)) + { + yield return false; + } + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 35)) + { + foreach (bool l3 in read_symbol(35, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 36)) + { + foreach (bool l3 in read_symbol(36, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 38)) + { + foreach (bool l3 in read_symbol(38, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 42)) + { + foreach (bool l3 in read_symbol(42, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 43)) + { + foreach (bool l3 in read_symbol(43, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 45)) + { + foreach (bool l3 in read_symbol(45, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 58)) + { + foreach (bool l3 in read_symbol(58, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 60)) + { + foreach (bool l3 in read_symbol(60, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 61)) + { + foreach (bool l3 in read_symbol(61, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 62)) + { + foreach (bool l3 in read_symbol(62, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 63)) + { + foreach (bool l3 in read_symbol(63, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 64)) + { + foreach (bool l3 in read_symbol(64, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 92)) + { + foreach (bool l3 in read_symbol(92, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 94)) + { + foreach (bool l3 in read_symbol(94, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 96)) + { + foreach (bool l3 in read_symbol(96, Dict, Tokens)) + { + yield return false; + } + } + } + { + object Tokens = arg3; + foreach (bool l2 in YP.unify(arg1, 126)) + { + foreach (bool l3 in read_symbol(126, Dict, Tokens)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_symbol(object C1, object Dict, object Tokens) + { + { + Variable C2 = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.get_code(C2)) + { + foreach (bool l3 in rest_symbol(C2, Chars, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(C1, Chars))) + { + yield return false; + } + } + } + } + } + + public static IEnumerable rest_symbol(object arg1, object arg2, object arg3) + { + { + object C2 = arg1; + object LastCh = arg3; + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C2, Chars))) + { + if (YP.greaterThan(C2, 160)) + { + if (YP.lessThan(C2, 192)) + { + if (YP.notEqual(C2, 186)) + { + if (YP.notEqual(C2, 170)) + { + foreach (bool l7 in YP.get_code(NextCh)) + { + foreach (bool l8 in rest_symbol(NextCh, Chars, LastCh)) + { + yield return false; + } + } + yield break; + } + } + } + goto cutIf1; + } + foreach (bool l3 in symbol_char(C2)) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in rest_symbol(NextCh, Chars, LastCh)) + { + yield return false; + } + } + yield break; + } + cutIf1: + { } + } + } + { + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, C2)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, C2)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable symbol_char(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, 35)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 36)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 38)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 42)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 43)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 45)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 46)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 47)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 58)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 60)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 61)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 62)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 63)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 64)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 92)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 94)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 96)) + { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, 126)) + { + yield return false; + } + } + } + + public static IEnumerable get_current_position(object Pos) + { + { + foreach (bool l2 in YP.unify(Pos, 0)) + { + yield return false; + } + } + } + + public static IEnumerable read_after_atom4(object Ch, object Dict, object arg3, object Chars) + { + { + Variable Atom_1 = new Variable(); + Variable Pos = new Variable(); + Variable Tokens = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"atom", Atom_1, Pos), Tokens))) + { + foreach (bool l3 in YP.unify(Pos, 0)) + { + foreach (bool l4 in YP.atom_codes(Atom_1, Chars)) + { + foreach (bool l5 in read_after_atom(Ch, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable read_after_atom(object arg1, object Dict, object arg3) + { + { + Variable Tokens = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, 40)) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"("), Tokens))) + { + foreach (bool l4 in YP.get_code(NextCh)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + yield break; + } + } + } + { + object Ch = arg1; + object Tokens = arg3; + foreach (bool l2 in read_tokens(Ch, Dict, Tokens)) + { + yield return false; + } + } + } + + public static IEnumerable read_string(object Chars, object Quote, object NextCh) + { + { + Variable Ch = new Variable(); + Variable Char = new Variable(); + Variable Next = new Variable(); + foreach (bool l2 in YP.get_code(Ch)) + { + foreach (bool l3 in read_char(Ch, Quote, Char, Next)) + { + foreach (bool l4 in rest_string5(Char, Next, Chars, Quote, NextCh)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable rest_string5(object arg1, object arg2, object arg3, object arg4, object arg5) + { + { + object _X = arg4; + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg1, -1)) + { + foreach (bool l3 in YP.unify(arg2, NextCh)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + foreach (bool l5 in YP.unify(arg5, NextCh)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Char = arg1; + object Next = arg2; + object Quote = arg4; + object NextCh = arg5; + Variable Chars = new Variable(); + Variable Char2 = new Variable(); + Variable Next2 = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(Char, Chars))) + { + foreach (bool l3 in read_char(Next, Quote, Char2, Next2)) + { + foreach (bool l4 in rest_string5(Char2, Next2, Chars, Quote, NextCh)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable escape_char(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, 110)) + { + foreach (bool l3 in YP.unify(arg2, 10)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 78)) + { + foreach (bool l3 in YP.unify(arg2, 10)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 116)) + { + foreach (bool l3 in YP.unify(arg2, 9)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 84)) + { + foreach (bool l3 in YP.unify(arg2, 9)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 114)) + { + foreach (bool l3 in YP.unify(arg2, 13)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 82)) + { + foreach (bool l3 in YP.unify(arg2, 13)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 118)) + { + foreach (bool l3 in YP.unify(arg2, 11)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 86)) + { + foreach (bool l3 in YP.unify(arg2, 11)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 98)) + { + foreach (bool l3 in YP.unify(arg2, 8)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 66)) + { + foreach (bool l3 in YP.unify(arg2, 8)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 102)) + { + foreach (bool l3 in YP.unify(arg2, 12)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 70)) + { + foreach (bool l3 in YP.unify(arg2, 12)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 101)) + { + foreach (bool l3 in YP.unify(arg2, 27)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 69)) + { + foreach (bool l3 in YP.unify(arg2, 27)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 100)) + { + foreach (bool l3 in YP.unify(arg2, 127)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 68)) + { + foreach (bool l3 in YP.unify(arg2, 127)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 115)) + { + foreach (bool l3 in YP.unify(arg2, 32)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 83)) + { + foreach (bool l3 in YP.unify(arg2, 32)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 122)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, 90)) + { + foreach (bool l3 in YP.unify(arg2, -1)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_variable(object C1, object Dict, object arg3) + { + { + Variable Var = new Variable(); + Variable Name = new Variable(); + Variable StartPos = new Variable(); + Variable Tokens = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor3(@"var", Var, Name, StartPos), Tokens))) + { + foreach (bool l3 in get_current_position(StartPos)) + { + foreach (bool l4 in read_name(C1, Chars, NextCh)) + { + foreach (bool l5 in YP.atom_codes(Name, Chars)) + { + if (YP.termEqual(Name, Atom.a(@"_"))) + { + foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l6 in read_lookup(Dict, Name, Var)) + { + foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) + { + yield return false; + } + } + cutIf1: + { } + } + } + } + } + } + } + + public static IEnumerable read_lookup(object arg1, object Name, object Var) + { + { + Variable N = new Variable(); + Variable V = new Variable(); + Variable L = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", N, V), L))) + { + foreach (bool l3 in YP.unify(N, Name)) + { + foreach (bool l4 in YP.unify(V, Var)) + { + yield return false; + } + goto cutIf1; + } + foreach (bool l3 in read_lookup(L, Name, Var)) + { + yield return false; + } + cutIf1: + { } + } + } + } + + public static IEnumerable read_solidus(object Ch, object LastCh) + { + { + Variable NextCh = new Variable(); + if (YP.equal(Ch, 42)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + if (YP.equal(NextCh, 47)) + { + foreach (bool l5 in YP.get_code(LastCh)) + { + yield return false; + } + goto cutIf2; + } + foreach (bool l4 in read_solidus(NextCh, LastCh)) + { + yield return false; + } + cutIf2: + { } + } + goto cutIf1; + } + if (YP.notEqual(Ch, -1)) + { + foreach (bool l3 in YP.get_code(NextCh)) + { + foreach (bool l4 in read_solidus(NextCh, LastCh)) + { + yield return false; + } + } + goto cutIf3; + } + foreach (bool l2 in YP.unify(LastCh, Ch)) + { + foreach (bool l3 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in /*comment~n"), Atom.NIL)) + { + yield return false; + } + } + cutIf3: + cutIf1: + { } + } + } + + public static IEnumerable read_identifier(object C1, object Dict, object Tokens) + { + { + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in read_name(C1, Chars, NextCh)) + { + foreach (bool l3 in read_after_atom4(NextCh, Dict, Tokens, Chars)) + { + yield return false; + } + } + } + } + + public static IEnumerable read_name(object C1, object arg2, object LastCh) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(122, Atom.NIL))) + { + foreach (bool l6 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + goto cutIf2; + } + if (YP.lessThan(C2, 192)) + { + if (YP.notEqual(YP.bitwiseOr(C2, 16), 186)) + { + foreach (bool l7 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l8 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf3; + } + } + if (YP.equal(YP.bitwiseOr(C2, 32), 247)) + { + foreach (bool l6 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l7 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf4; + } + foreach (bool l5 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + cutIf4: + cutIf3: + cutIf2: + goto cutIf1; + } + if (YP.greaterThanOrEqual(C2, new ListPair(65, Atom.NIL))) + { + if (YP.greaterThan(C2, new ListPair(90, Atom.NIL))) + { + if (YP.notEqual(C2, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l8 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + goto cutIf6; + } + } + foreach (bool l5 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + cutIf6: + goto cutIf5; + } + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_name(C2, Chars, LastCh)) + { + yield return false; + } + goto cutIf7; + } + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(LastCh, C2)) + { + yield return false; + } + } + cutIf7: + cutIf5: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_fullstop(object Ch, object Dict, object Tokens) + { + { + Variable Number = new Variable(); + Variable Tokens1 = new Variable(); + Variable Chars = new Variable(); + Variable NextCh = new Variable(); + if (YP.lessThanOrEqual(Ch, new ListPair(57, Atom.NIL))) + { + if (YP.greaterThanOrEqual(Ch, new ListPair(48, Atom.NIL))) + { + foreach (bool l4 in YP.unify(Tokens, new ListPair(new Functor1(@"number", Number), Tokens1))) + { + foreach (bool l5 in read_float(Number, Dict, Tokens1, new ListPair(48, Atom.NIL), Ch)) + { + yield return false; + } + } + goto cutIf1; + } + } + if (YP.greaterThan(Ch, new ListPair(32, Atom.NIL))) + { + foreach (bool l3 in rest_symbol(Ch, Chars, NextCh)) + { + foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(46, Chars))) + { + yield return false; + } + } + goto cutIf2; + } + if (YP.greaterThanOrEqual(Ch, 0)) + { + foreach (bool l3 in YP.unify(Tokens, Atom.NIL)) + { + yield return false; + } + goto cutIf3; + } + foreach (bool l2 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file just after full stop~n"), Atom.NIL)) + { + } + cutIf3: + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable read_float(object Number, object Dict, object Tokens, object Digits, object Digit) + { + { + Variable Chars = new Variable(); + Variable Rest = new Variable(); + Variable NextCh = new Variable(); + foreach (bool l2 in prepend(Digits, Chars, Rest)) + { + foreach (bool l3 in read_float(Digit, Rest, NextCh, Chars)) + { + foreach (bool l4 in YP.number_codes(Number, Chars)) + { + foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) + { + yield return false; + } + } + } + } + } + } + + public static IEnumerable prepend(object arg1, object arg2, object arg3) + { + { + object X = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(46, X))) + { + yield return false; + } + } + } + { + object Y = arg3; + Variable C = new Variable(); + Variable Cs = new Variable(); + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(C, Cs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(C, X))) + { + foreach (bool l4 in prepend(Cs, X, Y)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable read_float(object C1, object arg2, object NextCh, object Total) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + Variable C3 = new Variable(); + Variable C4 = new Variable(); + Variable More = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_float(C2, Chars, NextCh, Total)) + { + yield return false; + } + goto cutIf1; + } + } + if (YP.equal(YP.bitwiseOr(C2, 32), new ListPair(101, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C3)) + { + if (YP.equal(C3, new ListPair(45, Atom.NIL))) + { + foreach (bool l7 in YP.get_code(C4)) + { + foreach (bool l8 in YP.unify(Chars, new ListPair(C2, new ListPair(45, More)))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l11 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf4; + } + } + foreach (bool l9 in YP.unify(More, Atom.NIL)) + { + foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l10 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf4: + { } + } + } + goto cutIf3; + } + if (YP.equal(C3, new ListPair(43, Atom.NIL))) + { + foreach (bool l7 in YP.get_code(C4)) + { + foreach (bool l8 in YP.unify(Chars, new ListPair(C2, More))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l11 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf6; + } + } + foreach (bool l9 in YP.unify(More, Atom.NIL)) + { + foreach (bool l10 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l10 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf6: + { } + } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(C4, C3)) + { + foreach (bool l7 in YP.unify(Chars, new ListPair(C2, More))) + { + if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) + { + foreach (bool l10 in read_exponent(C4, More, NextCh)) + { + yield return false; + } + goto cutIf7; + } + } + foreach (bool l8 in YP.unify(More, Atom.NIL)) + { + foreach (bool l9 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) + { + } + } + foreach (bool l8 in YP.unify(More, new ListPair(48, Atom.NIL))) + { + foreach (bool l9 in YP.unify(NextCh, C4)) + { + yield return false; + } + } + cutIf7: + { } + } + } + cutIf5: + cutIf3: + { } + } + goto cutIf2; + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(NextCh, C2)) + { + yield return false; + } + } + cutIf2: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_exponent(object C1, object arg2, object NextCh) + { + { + Variable Chars = new Variable(); + Variable C2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) + { + foreach (bool l3 in YP.get_code(C2)) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) + { + foreach (bool l6 in read_exponent(C2, Chars, NextCh)) + { + yield return false; + } + goto cutIf1; + } + } + foreach (bool l4 in YP.unify(Chars, Atom.NIL)) + { + foreach (bool l5 in YP.unify(NextCh, C2)) + { + yield return false; + } + } + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_number(object C1, object Dict, object arg3) + { + { + Variable Number = new Variable(); + Variable Tokens = new Variable(); + Variable C2 = new Variable(); + Variable N = new Variable(); + Variable C = new Variable(); + Variable C3 = new Variable(); + Variable Digits = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor1(@"number", Number), Tokens))) + { + foreach (bool l3 in read_number4(C1, C2, 0, N)) + { + if (YP.equal(C2, 39)) + { + if (YP.greaterThanOrEqual(N, 2)) + { + if (YP.lessThanOrEqual(N, 36)) + { + foreach (bool l7 in read_based(N, 0, Number, C)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + goto cutIf2; + } + } + if (YP.equal(N, 0)) + { + foreach (bool l6 in YP.get_code(C3)) + { + foreach (bool l7 in read_char(C3, -1, Number, C)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + } + goto cutIf3; + } + foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** ~d' read as ~d '~n"), new ListPair(N, new ListPair(N, Atom.NIL)))) + { + foreach (bool l6 in YP.unify(Number, N)) + { + foreach (bool l7 in YP.unify(C, C2)) + { + foreach (bool l8 in read_tokens(C, Dict, Tokens)) + { + yield return false; + } + } + } + } + cutIf3: + cutIf2: + goto cutIf1; + } + if (YP.equal(C2, 46)) + { + foreach (bool l5 in YP.get_code(C3)) + { + if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C3, new ListPair(57, Atom.NIL))) + { + foreach (bool l8 in YP.number_codes(N, Digits)) + { + foreach (bool l9 in read_float(Number, Dict, Tokens, Digits, C3)) + { + yield return false; + } + } + goto cutIf5; + } + } + foreach (bool l6 in YP.unify(Number, N)) + { + foreach (bool l7 in read_fullstop(C3, Dict, Tokens)) + { + yield return false; + } + } + cutIf5: + { } + } + goto cutIf4; + } + foreach (bool l4 in YP.unify(Number, N)) + { + foreach (bool l5 in read_tokens(C2, Dict, Tokens)) + { + yield return false; + } + } + cutIf4: + cutIf1: + { } + } + } + } + } + + public static IEnumerable read_number4(object C0, object C, object N0, object N) + { + { + Variable N1 = new Variable(); + Variable C1 = new Variable(); + if (YP.greaterThanOrEqual(C0, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C0, new ListPair(57, Atom.NIL))) + { + foreach (bool l4 in YP.unify(N1, YP.add(YP.subtract(YP.multiply(N0, 10), new ListPair(48, Atom.NIL)), C0))) + { + foreach (bool l5 in YP.get_code(C1)) + { + foreach (bool l6 in read_number4(C1, C, N1, N)) + { + yield return false; + } + } + } + goto cutIf1; + } + } + if (YP.equal(C0, 95)) + { + foreach (bool l3 in YP.get_code(C1)) + { + foreach (bool l4 in read_number4(C1, C, N0, N)) + { + yield return false; + } + } + goto cutIf2; + } + foreach (bool l2 in YP.unify(C, C0)) + { + foreach (bool l3 in YP.unify(N, N0)) + { + yield return false; + } + } + cutIf2: + cutIf1: + { } + } + } + + public static IEnumerable read_based(object Base, object N0, object N, object C) + { + { + Variable C1 = new Variable(); + Variable Digit = new Variable(); + Variable N1 = new Variable(); + foreach (bool l2 in YP.get_code(C1)) + { + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, new ListPair(48, Atom.NIL)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf2; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf3; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf3: + cutIf2: + { } + } + goto cutIf1; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(65, Atom.NIL), 10)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf5; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf6; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf6: + cutIf5: + { } + } + goto cutIf4; + } + } + if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) + { + if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) + { + foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(97, Atom.NIL), 10)))) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l8 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf8; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l7 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf9; + } + foreach (bool l6 in YP.unify(N, N0)) + { + foreach (bool l7 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf9: + cutIf8: + { } + } + goto cutIf7; + } + } + foreach (bool l3 in YP.unify(Digit, 99)) + { + if (YP.lessThan(Digit, Base)) + { + foreach (bool l5 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) + { + foreach (bool l6 in read_based(Base, N1, N, C)) + { + yield return false; + } + } + goto cutIf10; + } + if (YP.equal(C1, new ListPair(95, Atom.NIL))) + { + foreach (bool l5 in read_based(Base, N0, N, C)) + { + yield return false; + } + goto cutIf11; + } + foreach (bool l4 in YP.unify(N, N0)) + { + foreach (bool l5 in YP.unify(C, C1)) + { + yield return false; + } + } + cutIf11: + cutIf10: + { } + } + cutIf7: + cutIf4: + cutIf1: + { } + } + } + } + + public static IEnumerable read_char(object Char, object Quote, object Result, object Next) + { + { + Variable C1 = new Variable(); + Variable C2 = new Variable(); + Variable C3 = new Variable(); + Variable Ch = new Variable(); + if (YP.equal(Char, 92)) + { + foreach (bool l3 in YP.get_code(C1)) + { + if (YP.lessThan(C1, 0)) + { + foreach (bool l5 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~cquoted~c~n"), new ListPair(Quote, new ListPair(Quote, Atom.NIL)))) + { + foreach (bool l6 in YP.unify(Result, -1)) + { + foreach (bool l7 in YP.unify(Next, C1)) + { + yield return false; + } + } + } + goto cutIf2; + } + if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + foreach (bool l6 in read_char(C2, Quote, Result, Next)) + { + yield return false; + } + } + goto cutIf3; + } + if (YP.equal(YP.bitwiseOr(C1, 32), new ListPair(99, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + foreach (bool l6 in read_char(C2, Quote, Result, Next)) + { + yield return false; + } + } + goto cutIf4; + } + if (YP.lessThanOrEqual(C1, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) + { + foreach (bool l6 in YP.get_code(C2)) + { + if (YP.lessThanOrEqual(C2, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) + { + foreach (bool l9 in YP.get_code(C3)) + { + if (YP.lessThanOrEqual(C3, new ListPair(55, Atom.NIL))) + { + if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) + { + foreach (bool l12 in YP.get_code(Next)) + { + foreach (bool l13 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(YP.add(YP.multiply(C1, 8), C2), 8), C3), YP.multiply(73, new ListPair(48, Atom.NIL))))) + { + yield return false; + } + } + goto cutIf7; + } + } + foreach (bool l10 in YP.unify(Next, C3)) + { + foreach (bool l11 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(C1, 8), C2), YP.multiply(9, new ListPair(48, Atom.NIL))))) + { + yield return false; + } + } + cutIf7: + { } + } + goto cutIf6; + } + } + foreach (bool l7 in YP.unify(Next, C2)) + { + foreach (bool l8 in YP.unify(Result, YP.subtract(C1, new ListPair(48, Atom.NIL)))) + { + yield return false; + } + } + cutIf6: + { } + } + goto cutIf5; + } + } + if (YP.equal(C1, new ListPair(94, Atom.NIL))) + { + foreach (bool l5 in YP.get_code(C2)) + { + if (YP.lessThan(C2, 0)) + { + foreach (bool l7 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** end of file in ~c..~c^..~c~n"), new ListPair(Quote, new ListPair(92, new ListPair(Quote, Atom.NIL))))) + { + foreach (bool l8 in YP.unify(Result, -1)) + { + foreach (bool l9 in YP.unify(Next, C2)) + { + yield return false; + } + } + } + goto cutIf9; + } + if (YP.equal(C2, new ListPair(63, Atom.NIL))) + { + foreach (bool l7 in YP.unify(Result, 127)) + { + foreach (bool l8 in YP.get_code(Next)) + { + yield return false; + } + } + goto cutIf10; + } + foreach (bool l6 in YP.unify(Result, YP.bitwiseAnd(C2, 31))) + { + foreach (bool l7 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf10: + cutIf9: + { } + } + goto cutIf8; + } + foreach (bool l4 in escape_char(C1, Result)) + { + foreach (bool l5 in YP.get_code(Next)) + { + yield return false; + } + goto cutIf11; + } + foreach (bool l4 in YP.unify(Result, C1)) + { + foreach (bool l5 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf11: + cutIf8: + cutIf5: + cutIf4: + cutIf3: + cutIf2: + { } + } + goto cutIf1; + } + if (YP.equal(Char, Quote)) + { + foreach (bool l3 in YP.get_code(Ch)) + { + if (YP.equal(Ch, Quote)) + { + foreach (bool l5 in YP.unify(Result, Quote)) + { + foreach (bool l6 in YP.get_code(Next)) + { + yield return false; + } + } + goto cutIf13; + } + foreach (bool l4 in YP.unify(Result, -1)) + { + foreach (bool l5 in YP.unify(Next, Ch)) + { + yield return false; + } + } + cutIf13: + { } + } + goto cutIf12; + } + if (YP.lessThan(Char, new ListPair(32, Atom.NIL))) + { + if (YP.notEqual(Char, 9)) + { + if (YP.notEqual(Char, 10)) + { + if (YP.notEqual(Char, 13)) + { + foreach (bool l6 in YP.unify(Result, -1)) + { + foreach (bool l7 in YP.unify(Next, Char)) + { + foreach (bool l8 in formatError(Atom.a(@"user_error"), Atom.a(@"~N** Strange character ~d ends ~ctoken~c~n"), new ListPair(Char, new ListPair(Quote, new ListPair(Quote, Atom.NIL))))) + { + yield return false; + } + } + } + goto cutIf14; + } + } + } + } + foreach (bool l2 in YP.unify(Result, Char)) + { + foreach (bool l3 in YP.get_code(Next)) + { + yield return false; + } + } + cutIf14: + cutIf12: + cutIf1: + { } + } + } + + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/PrologException.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/PrologException.cs index ffb8ddc..63b304a 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/PrologException.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/PrologException.cs @@ -1,71 +1,71 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// A PrologException is used as the exception thrown by YP.throw(Term). - /// - public class PrologException : Exception - { - public readonly object _term; - - /// - /// Create a PrologException with the given Term. The printable exception message is the full Term. - /// - /// the term of the exception - /// - public PrologException(object Term) - : base(YP.getValue(Term).ToString()) - { - _term = YP.makeCopy(Term, new Variable.CopyStore()); - } - - /// - /// Create a PrologException where the Term is error(ErrorTerm, Message). - /// This uses YP.makeCopy to copy the ErrorTerm and Message so that they are valid after unbinding. - /// - /// the term of the exception - /// the message, converted to a string, to use as the printable exception message - /// - public PrologException(object ErrorTerm, object Message) - : base(YP.getValue(Message).ToString()) - { - _term = YP.makeCopy(new Functor2(Atom.a("error"), ErrorTerm, Message), new Variable.CopyStore()); - } - - public object Term - { - get { return _term; } - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// A PrologException is used as the exception thrown by YP.throw(Term). + /// + public class PrologException : Exception + { + public readonly object _term; + + /// + /// Create a PrologException with the given Term. The printable exception message is the full Term. + /// + /// the term of the exception + /// + public PrologException(object Term) + : base(YP.getValue(Term).ToString()) + { + _term = YP.makeCopy(Term, new Variable.CopyStore()); + } + + /// + /// Create a PrologException where the Term is error(ErrorTerm, Message). + /// This uses YP.makeCopy to copy the ErrorTerm and Message so that they are valid after unbinding. + /// + /// the term of the exception + /// the message, converted to a string, to use as the printable exception message + /// + public PrologException(object ErrorTerm, object Message) + : base(YP.getValue(Message).ToString()) + { + _term = YP.makeCopy(new Functor2(Atom.a("error"), ErrorTerm, Message), new Variable.CopyStore()); + } + + public object Term + { + get { return _term; } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/README.TXT b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/README.TXT index 05186f1..a1beeb6 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/README.TXT +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/README.TXT @@ -1,405 +1,405 @@ -YPOS: YieldProlog for OpenSim - - a compiler from Prolog to OpenSim compatible C# scripts - -Ported by Kino Coursey and Douglas Miles at Daxtron Labs. -Based on Jeff Thompson Yield Prolog, http://yieldprolog.sourceforge.net/ -For Prolog see http://en.wikipedia.org/wiki/Prolog - - -INTRODUCTION - -This folder contains code to implement a Prolog compiler using the "Yield Statement" found in C#, Javascript, and Python. -The original Yield Prolog system can transform Prolog programs into C# code. -In this system we detect and extract YieldProlog code (with "//YP" as the first four characters in the script) and seperate it from any c# code ("marked by "//CS"). -The YP code is transformed to C# and prepended to the "//CS" section, and passed as a bundel to the existing C# compiler. -The end result is Prolog can interface to OpenSim using the existing "//CS" functionality, and C# can call the compiled Prolog. -As such YP allows both declaritive and procedural programming in a 3D script enabled environment. - -FEATURES -* Allows implementation of logic programming for objects and agents. -* C#/Javascript/Python as intermediate language -* Yield Prolog has relatively high speed of execution which is important in OpenSim. http://yieldprolog.sourceforge.net/benchmarks.html -* It is compatable with the existing C#/Mono based system. -* Yield Prolog is BSD license -* Calling Prolog from C# scripts -* Calling C# functions (with LSL and OS functions) from Prolog -* Prolog dynamic database -* Edinburgh, Cocksin & Mellish style syntax. -* Compiler is generated by compiling the Prolog descrition of itself into C# -* Same script entry interface as LSL - - -TODO -* Utilize ability to generate Javascript and Python code -* Integrate Prolog database with Sim -* Translation error reporting back to the editor -* Communications via message passing -* Interface to external inference engines - -POSSIBILITIES -* Inworld expert systems -* Parallel logic programming and expert systems -* Ontology based processing -* Knowledge based alerting, accessing and business rules - For instance, listen on channel x, filter the events and broadcast alerts on channel y - or send IM, emails etc. - - -USAGE: - -Add "yp" as an allowed compiler - -OpenSim.ini -[ScriptEngine.DotNetEngine] -AllowedCompilers=lsl,cs,js,vb,yp - -Enter scripts using the inworld editing process. Scripts have the following format. -The first line of a file must have "//yp". - -//yp - -//CS - - - - - - - -C# code calling a Prolog Predicate: ------------------------------------ -The Prolog predicate is transformed into a C# boolean function. So the general calling format is: - foreach( bool var in prolog_predicate(ARGS)) {}; - -I/O is via using a string reader and writer in conjunction with YP.See() and YP.Tell() - - StringWriter PrologOutuput= new StringWriter(); - StringReader PrologInput= new StringReader(myInputString); - YP.see(PrologInput); - YP.tell(PrologOutuput); - - YP.seen(); - YP.told(); - StringBuilder builder = PrologOutput.GetStringBuilder(); - string finaloutput = builder.ToString(); - -Any prolog reads and writes will be to the passed StringReader and StringWriter. In fact any TextReader/TextWriter class can be used. - -Strings in Prolog are stored as Atom's and you need to use an Atom object to match. - -\\yp -wanted('bob'). -\\cs -string Who="bob"; -foreach( bool ans in wanted(Atom.a(Who) )){}; - - -Prolog code calling a C# function: ------------------------------------ -The prolog code uses the script_event('name_of_function',ARGS) builtin, which is transformed into the function call. -The C# function called uses "PrologCallback" and returns a boolean. - - - -Dynamic database assertions: ------------------------------------ - -void assertdb2(string predicate, string arg1, string arg2) -{ - name = Atom.a(predicate); - YP.assertFact(name, new object[] { arg1, arg2 }); -} - -void retractdb2(string predicate, string arg1, string arg2) -{ - name = Atom.a(predicate); - YP.retractFact(name, new object[] { arg1, arg2 }); -} - - -========================= APPENDIX A: touch test ================================ - - - =================================== -Input YP Code - =================================== -//yp - mydb('field2','field1'). - mydb('andy','jane'). - mydb('carl','dan'). - mydb('andy','bill'). - mydb('andy','betty'). - - call_me(X):-mydb(X,Y) , respond(Y). - respond(X):- script_event('sayit',X). - -//cs - public void default_event_touch_start(int N ) - { - llSay(0,"pstart1"); - foreach( bool ans in call_me(Atom.a(@"andy") )){}; - llSay(0,"pstop2"); - } - - public void default_event_state_entry() - { - llSay(0,"prolog tester active."); - } - -PrologCallback sayit(object ans) - { - llSay(0,"sayit1"); - string msg = "one answer is :"+((Variable)ans).getValue(); - llSay(0,msg); - yield return false; - } - - - =================================== -Generated CS Code - =================================== -using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog;using OpenSim.Region.ScriptEngine.Common; using System.Collections.Generic; -namespace SecondLife { public class Script : OpenSim.Region.ScriptEngine.Common.BuiltIn_Commands_BaseClass { -static OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP YP=null;public Script() { YP= new OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP(); } -//cs - public void default_event_touch_start(int N ) - { - llSay(0,"pstart1"); - foreach( bool ans in call_me(Atom.a(@"carl") )){}; - llSay(0,"pstop2"); - } - - public void default_event_state_entry() - { - llSay(0,"prolog tester active."); - } - -public IEnumerable sayit(object ans) - { - llSay(0,"sayit1"); - string msg = "one answer is :"+((Variable)ans).getValue(); - llSay(0,msg); - yield return false; - } - - -//YPEncoded -public IEnumerable mydb(object arg1, object arg2) { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"carl"))) { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"dan"))) { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"andy"))) { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"bill"))) { - yield return false; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"andy"))) { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"betty"))) { - yield return false; - } - } - } -} - -public IEnumerable call_me(object X) { - { - Variable Y = new Variable(); - foreach (bool l2 in mydb(X, Y)) { - foreach (bool l3 in respond(Y)) { - yield return false; - } - } - } -} - -public IEnumerable respond(object X) { - { - foreach (bool l2 in this.sayit( X)) { - yield return false; - } - } -} - -} } - - - -========================= APPENDIX B:SENSOR INFORMED SCRIPT ===================== - - - =================================== -Input YP Code - =================================== -//yp - -nop. - -good('Daxxon Kinoc'). -good('Fluffy Kitty'). - -bad('Eric Evil'). -bad('Spikey Plant'). - -prolog_notify(X) :- good(X) , script_event('accept',X). -prolog_notify(X) :- bad(X) , script_event('reject',X). - - -//cs - -public void default_event_state_entry() - { - llSay(0,"prolog sensor tester active."); - - // Start a sensor looking for Agents - llSensorRepeat("","",AGENT, 10, PI,20); - - } - -public void default_event_sensor(int number_detected ) -{ - int i; - for(i=0;i< number_detected ;i++) - { - string dName = llDetectedName(i); - string dOwner = llDetectedName(i); - foreach(bool response in prolog_notify(Atom.a(dName)) ){}; - foreach(bool response in prolog_notify(dOwner) ){}; - llSay(0,"Saw "+dName); - } -} - -string decodeToString(object obj) -{ - if (obj is Variable) { return (string) ((Variable)obj).getValue();} - if (obj is Atom) { return (string) ((Atom)obj)._name;} - return "unknown type"; -} - -PrologCallback accept(object ans) - { - string msg = "Welcoming :"+decodeToString(ans); - llSay(0,msg); - yield return false; - } - -PrologCallback reject(object ans) - { - string msg = "Watching :"+decodeToString(ans); - llSay(0,msg); - yield return false; - } - - - =================================== -Generated CS Code - =================================== - -using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog; using OpenSim.Region.ScriptEngine.Common; using System.Collections.Generic; -namespace SecondLife { public class Script : OpenSim.Region.ScriptEngine.Common.BuiltIn_Commands_BaseClass { -static OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP YP=null; public Script() { YP= new OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP(); } -//cs - -public void default_event_state_entry() - { - llSay(0,"prolog sensor tester active."); - - // Start a sensor looking for Agents - llSensorRepeat("","",AGENT, 10, PI,20); - - } - -public void default_event_sensor(int number_detected ) -{ - int i; - for(i=0;i< number_detected ;i++) - { - string dName = llDetectedName(i); - string dOwner = llDetectedName(i); - foreach(bool response in prolog_notify(Atom.a(dName)) ){}; - foreach(bool response in prolog_notify(dOwner) ){}; - llSay(0,"Saw "+dName); - } -} - -string decodeToString(object obj) -{ - if (obj is Variable) { return (string) ((Variable)obj).getValue();} - if (obj is Atom) { return (string) ((Atom)obj)._name;} - return "unknown type"; -} - -public IEnumerable accept(object ans) - { - string msg = "Welcoming :"+decodeToString(ans); - llSay(0,msg); - yield return false; - } - -public IEnumerable reject(object ans) - { - string msg = "Watching :"+decodeToString(ans); - llSay(0,msg); - yield return false; - } - - -//YPEncoded -public IEnumerable yp_nop_header_nop() { - { - yield return false; - } -} - -public IEnumerable good(object arg1) { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"Daxxon Kinoc"))) { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"Fluffy Kitty"))) { - yield return false; - } - } -} - -public IEnumerable bad(object arg1) { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"Eric Evil"))) { - yield return false; - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"Spikey Plant"))) { - yield return false; - } - } -} - -public IEnumerable prolog_notify(object X) { - { - foreach (bool l2 in good(X)) { - foreach (bool l3 in this.accept( X)) { - yield return false; - } - } - } - { - foreach (bool l2 in bad(X)) { - foreach (bool l3 in this.reject( X)) { - yield return false; - } - } - } -} - -} } - +YPOS: YieldProlog for OpenSim + + a compiler from Prolog to OpenSim compatible C# scripts + +Ported by Kino Coursey and Douglas Miles at Daxtron Labs. +Based on Jeff Thompson Yield Prolog, http://yieldprolog.sourceforge.net/ +For Prolog see http://en.wikipedia.org/wiki/Prolog + + +INTRODUCTION + +This folder contains code to implement a Prolog compiler using the "Yield Statement" found in C#, Javascript, and Python. +The original Yield Prolog system can transform Prolog programs into C# code. +In this system we detect and extract YieldProlog code (with "//YP" as the first four characters in the script) and seperate it from any c# code ("marked by "//CS"). +The YP code is transformed to C# and prepended to the "//CS" section, and passed as a bundel to the existing C# compiler. +The end result is Prolog can interface to OpenSim using the existing "//CS" functionality, and C# can call the compiled Prolog. +As such YP allows both declaritive and procedural programming in a 3D script enabled environment. + +FEATURES +* Allows implementation of logic programming for objects and agents. +* C#/Javascript/Python as intermediate language +* Yield Prolog has relatively high speed of execution which is important in OpenSim. http://yieldprolog.sourceforge.net/benchmarks.html +* It is compatable with the existing C#/Mono based system. +* Yield Prolog is BSD license +* Calling Prolog from C# scripts +* Calling C# functions (with LSL and OS functions) from Prolog +* Prolog dynamic database +* Edinburgh, Cocksin & Mellish style syntax. +* Compiler is generated by compiling the Prolog descrition of itself into C# +* Same script entry interface as LSL + + +TODO +* Utilize ability to generate Javascript and Python code +* Integrate Prolog database with Sim +* Translation error reporting back to the editor +* Communications via message passing +* Interface to external inference engines + +POSSIBILITIES +* Inworld expert systems +* Parallel logic programming and expert systems +* Ontology based processing +* Knowledge based alerting, accessing and business rules + For instance, listen on channel x, filter the events and broadcast alerts on channel y + or send IM, emails etc. + + +USAGE: + +Add "yp" as an allowed compiler + +OpenSim.ini +[ScriptEngine.DotNetEngine] +AllowedCompilers=lsl,cs,js,vb,yp + +Enter scripts using the inworld editing process. Scripts have the following format. +The first line of a file must have "//yp". + +//yp + +//CS + + + + + + + +C# code calling a Prolog Predicate: +----------------------------------- +The Prolog predicate is transformed into a C# boolean function. So the general calling format is: + foreach( bool var in prolog_predicate(ARGS)) {}; + +I/O is via using a string reader and writer in conjunction with YP.See() and YP.Tell() + + StringWriter PrologOutuput= new StringWriter(); + StringReader PrologInput= new StringReader(myInputString); + YP.see(PrologInput); + YP.tell(PrologOutuput); + + YP.seen(); + YP.told(); + StringBuilder builder = PrologOutput.GetStringBuilder(); + string finaloutput = builder.ToString(); + +Any prolog reads and writes will be to the passed StringReader and StringWriter. In fact any TextReader/TextWriter class can be used. + +Strings in Prolog are stored as Atom's and you need to use an Atom object to match. + +\\yp +wanted('bob'). +\\cs +string Who="bob"; +foreach( bool ans in wanted(Atom.a(Who) )){}; + + +Prolog code calling a C# function: +----------------------------------- +The prolog code uses the script_event('name_of_function',ARGS) builtin, which is transformed into the function call. +The C# function called uses "PrologCallback" and returns a boolean. + + + +Dynamic database assertions: +----------------------------------- + +void assertdb2(string predicate, string arg1, string arg2) +{ + name = Atom.a(predicate); + YP.assertFact(name, new object[] { arg1, arg2 }); +} + +void retractdb2(string predicate, string arg1, string arg2) +{ + name = Atom.a(predicate); + YP.retractFact(name, new object[] { arg1, arg2 }); +} + + +========================= APPENDIX A: touch test ================================ + + + =================================== +Input YP Code + =================================== +//yp + mydb('field2','field1'). + mydb('andy','jane'). + mydb('carl','dan'). + mydb('andy','bill'). + mydb('andy','betty'). + + call_me(X):-mydb(X,Y) , respond(Y). + respond(X):- script_event('sayit',X). + +//cs + public void default_event_touch_start(int N ) + { + llSay(0,"pstart1"); + foreach( bool ans in call_me(Atom.a(@"andy") )){}; + llSay(0,"pstop2"); + } + + public void default_event_state_entry() + { + llSay(0,"prolog tester active."); + } + +PrologCallback sayit(object ans) + { + llSay(0,"sayit1"); + string msg = "one answer is :"+((Variable)ans).getValue(); + llSay(0,msg); + yield return false; + } + + + =================================== +Generated CS Code + =================================== +using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog;using OpenSim.Region.ScriptEngine.Common; using System.Collections.Generic; +namespace SecondLife { public class Script : OpenSim.Region.ScriptEngine.Common.BuiltIn_Commands_BaseClass { +static OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP YP=null;public Script() { YP= new OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP(); } +//cs + public void default_event_touch_start(int N ) + { + llSay(0,"pstart1"); + foreach( bool ans in call_me(Atom.a(@"carl") )){}; + llSay(0,"pstop2"); + } + + public void default_event_state_entry() + { + llSay(0,"prolog tester active."); + } + +public IEnumerable sayit(object ans) + { + llSay(0,"sayit1"); + string msg = "one answer is :"+((Variable)ans).getValue(); + llSay(0,msg); + yield return false; + } + + +//YPEncoded +public IEnumerable mydb(object arg1, object arg2) { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"carl"))) { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"dan"))) { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"andy"))) { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"bill"))) { + yield return false; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"andy"))) { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"betty"))) { + yield return false; + } + } + } +} + +public IEnumerable call_me(object X) { + { + Variable Y = new Variable(); + foreach (bool l2 in mydb(X, Y)) { + foreach (bool l3 in respond(Y)) { + yield return false; + } + } + } +} + +public IEnumerable respond(object X) { + { + foreach (bool l2 in this.sayit( X)) { + yield return false; + } + } +} + +} } + + + +========================= APPENDIX B:SENSOR INFORMED SCRIPT ===================== + + + =================================== +Input YP Code + =================================== +//yp + +nop. + +good('Daxxon Kinoc'). +good('Fluffy Kitty'). + +bad('Eric Evil'). +bad('Spikey Plant'). + +prolog_notify(X) :- good(X) , script_event('accept',X). +prolog_notify(X) :- bad(X) , script_event('reject',X). + + +//cs + +public void default_event_state_entry() + { + llSay(0,"prolog sensor tester active."); + + // Start a sensor looking for Agents + llSensorRepeat("","",AGENT, 10, PI,20); + + } + +public void default_event_sensor(int number_detected ) +{ + int i; + for(i=0;i< number_detected ;i++) + { + string dName = llDetectedName(i); + string dOwner = llDetectedName(i); + foreach(bool response in prolog_notify(Atom.a(dName)) ){}; + foreach(bool response in prolog_notify(dOwner) ){}; + llSay(0,"Saw "+dName); + } +} + +string decodeToString(object obj) +{ + if (obj is Variable) { return (string) ((Variable)obj).getValue();} + if (obj is Atom) { return (string) ((Atom)obj)._name;} + return "unknown type"; +} + +PrologCallback accept(object ans) + { + string msg = "Welcoming :"+decodeToString(ans); + llSay(0,msg); + yield return false; + } + +PrologCallback reject(object ans) + { + string msg = "Watching :"+decodeToString(ans); + llSay(0,msg); + yield return false; + } + + + =================================== +Generated CS Code + =================================== + +using OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog; using OpenSim.Region.ScriptEngine.Common; using System.Collections.Generic; +namespace SecondLife { public class Script : OpenSim.Region.ScriptEngine.Common.BuiltIn_Commands_BaseClass { +static OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP YP=null; public Script() { YP= new OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog.YP(); } +//cs + +public void default_event_state_entry() + { + llSay(0,"prolog sensor tester active."); + + // Start a sensor looking for Agents + llSensorRepeat("","",AGENT, 10, PI,20); + + } + +public void default_event_sensor(int number_detected ) +{ + int i; + for(i=0;i< number_detected ;i++) + { + string dName = llDetectedName(i); + string dOwner = llDetectedName(i); + foreach(bool response in prolog_notify(Atom.a(dName)) ){}; + foreach(bool response in prolog_notify(dOwner) ){}; + llSay(0,"Saw "+dName); + } +} + +string decodeToString(object obj) +{ + if (obj is Variable) { return (string) ((Variable)obj).getValue();} + if (obj is Atom) { return (string) ((Atom)obj)._name;} + return "unknown type"; +} + +public IEnumerable accept(object ans) + { + string msg = "Welcoming :"+decodeToString(ans); + llSay(0,msg); + yield return false; + } + +public IEnumerable reject(object ans) + { + string msg = "Watching :"+decodeToString(ans); + llSay(0,msg); + yield return false; + } + + +//YPEncoded +public IEnumerable yp_nop_header_nop() { + { + yield return false; + } +} + +public IEnumerable good(object arg1) { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"Daxxon Kinoc"))) { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"Fluffy Kitty"))) { + yield return false; + } + } +} + +public IEnumerable bad(object arg1) { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"Eric Evil"))) { + yield return false; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"Spikey Plant"))) { + yield return false; + } + } +} + +public IEnumerable prolog_notify(object X) { + { + foreach (bool l2 in good(X)) { + foreach (bool l3 in this.accept( X)) { + yield return false; + } + } + } + { + foreach (bool l2 in bad(X)) { + foreach (bool l3 in this.reject( X)) { + yield return false; + } + } + } +} + +} } + diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/UndefinedPredicateException.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/UndefinedPredicateException.cs index 035b79c..f746a07 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/UndefinedPredicateException.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/UndefinedPredicateException.cs @@ -1,62 +1,62 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// An UndefinedPredicateException extends PrologException to create an existence_error exception. - /// - public class UndefinedPredicateException : PrologException - { - private Atom _predicateName; - private int _arity; - - public UndefinedPredicateException(object message, Atom predicateName, int arity) - : base(new Functor2 - (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.a("/"), predicateName, arity)), - message) - { - _predicateName = predicateName; - _arity = arity; - } - - public Atom PredicateName - { - get { return _predicateName; } - } - - public int Arity - { - get { return _arity; } - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// An UndefinedPredicateException extends PrologException to create an existence_error exception. + /// + public class UndefinedPredicateException : PrologException + { + private Atom _predicateName; + private int _arity; + + public UndefinedPredicateException(object message, Atom predicateName, int arity) + : base(new Functor2 + (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.a("/"), predicateName, arity)), + message) + { + _predicateName = predicateName; + _arity = arity; + } + + public Atom PredicateName + { + get { return _predicateName; } + } + + public int Arity + { + get { return _arity; } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Variable.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Variable.cs index d5ee21c..47b5278 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Variable.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/Variable.cs @@ -1,196 +1,196 @@ -/* - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public interface IUnifiable - { - IEnumerable unify(object arg); - void addUniqueVariables(List variableSet); - object makeCopy(Variable.CopyStore copyStore); - bool termEqual(object term); - bool ground(); - } - - public class Variable : IUnifiable - { - // Use _isBound separate from _value so that it can be bound to any value, - // including null. - private bool _isBound = false; - private object _value; - - public object getValue() - { - if (!_isBound) - return this; - - object result = _value; - while (result is Variable) - { - if (!((Variable)result)._isBound) - return result; - - // Keep following the Variable chain. - result = ((Variable)result)._value; - } - - return result; - } - - public IEnumerable unify(object arg) - { - if (!_isBound) - { - _value = YP.getValue(arg); - if (_value == this) - // We are unifying this unbound variable with itself, so leave it unbound. - yield return false; - else - { - _isBound = true; - try - { - yield return false; - } - finally - { - // Remove the binding. - _isBound = false; - } - } - } - else - { - foreach (bool l1 in YP.unify(this, arg)) - yield return false; - } - } - - public override string ToString() - { - object value = getValue(); - if (value == this) - return "Variable"; - else - return getValue().ToString(); - } - - /// - /// If bound, call YP.addUniqueVariables on the value. Otherwise, if this unbound - /// variable is not already in variableSet, add it. - /// - /// - public void addUniqueVariables(List variableSet) - { - if (_isBound) - YP.addUniqueVariables(getValue(), variableSet); - else - { - if (variableSet.IndexOf(this) < 0) - variableSet.Add(this); - } - } - - /// - /// If bound, return YP.makeCopy for the value, else return copyStore.getCopy(this). - /// However, if copyStore is null, just return this. - /// - /// - /// - public object makeCopy(Variable.CopyStore copyStore) - { - if (_isBound) - return YP.makeCopy(getValue(), copyStore); - else - return copyStore == null ? this : copyStore.getCopy(this); - } - - public bool termEqual(object term) - { - if (_isBound) - return YP.termEqual(getValue(), term); - else - return this == YP.getValue(term); - } - - public bool ground() - { - if (_isBound) - // This is usually called by YP.ground which already did getValue, so this - // should never be reached, but check anyway. - return YP.ground(getValue()); - else - return false; - } - - /// - /// A CopyStore is used by makeCopy to track which Variable objects have - /// been copied. - /// - public class CopyStore - { - private List _inVariableSet = new List(); - private List _outVariableSet = new List(); - - /// - /// If inVariable has already been copied, return its copy. Otherwise, - /// return a fresh Variable associated with inVariable. - /// - /// - /// - public Variable getCopy(Variable inVariable) - { - int index = _inVariableSet.IndexOf(inVariable); - if (index >= 0) - return _outVariableSet[index]; - else - { - Variable outVariable = new Variable(); - _inVariableSet.Add(inVariable); - _outVariableSet.Add(outVariable); - return outVariable; - } - } - - /// - /// Return the number of unique variables that have been copied. - /// - /// - public int getNUniqueVariables() - { - return _inVariableSet.Count; - } - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public interface IUnifiable + { + IEnumerable unify(object arg); + void addUniqueVariables(List variableSet); + object makeCopy(Variable.CopyStore copyStore); + bool termEqual(object term); + bool ground(); + } + + public class Variable : IUnifiable + { + // Use _isBound separate from _value so that it can be bound to any value, + // including null. + private bool _isBound = false; + private object _value; + + public object getValue() + { + if (!_isBound) + return this; + + object result = _value; + while (result is Variable) + { + if (!((Variable)result)._isBound) + return result; + + // Keep following the Variable chain. + result = ((Variable)result)._value; + } + + return result; + } + + public IEnumerable unify(object arg) + { + if (!_isBound) + { + _value = YP.getValue(arg); + if (_value == this) + // We are unifying this unbound variable with itself, so leave it unbound. + yield return false; + else + { + _isBound = true; + try + { + yield return false; + } + finally + { + // Remove the binding. + _isBound = false; + } + } + } + else + { + foreach (bool l1 in YP.unify(this, arg)) + yield return false; + } + } + + public override string ToString() + { + object value = getValue(); + if (value == this) + return "Variable"; + else + return getValue().ToString(); + } + + /// + /// If bound, call YP.addUniqueVariables on the value. Otherwise, if this unbound + /// variable is not already in variableSet, add it. + /// + /// + public void addUniqueVariables(List variableSet) + { + if (_isBound) + YP.addUniqueVariables(getValue(), variableSet); + else + { + if (variableSet.IndexOf(this) < 0) + variableSet.Add(this); + } + } + + /// + /// If bound, return YP.makeCopy for the value, else return copyStore.getCopy(this). + /// However, if copyStore is null, just return this. + /// + /// + /// + public object makeCopy(Variable.CopyStore copyStore) + { + if (_isBound) + return YP.makeCopy(getValue(), copyStore); + else + return copyStore == null ? this : copyStore.getCopy(this); + } + + public bool termEqual(object term) + { + if (_isBound) + return YP.termEqual(getValue(), term); + else + return this == YP.getValue(term); + } + + public bool ground() + { + if (_isBound) + // This is usually called by YP.ground which already did getValue, so this + // should never be reached, but check anyway. + return YP.ground(getValue()); + else + return false; + } + + /// + /// A CopyStore is used by makeCopy to track which Variable objects have + /// been copied. + /// + public class CopyStore + { + private List _inVariableSet = new List(); + private List _outVariableSet = new List(); + + /// + /// If inVariable has already been copied, return its copy. Otherwise, + /// return a fresh Variable associated with inVariable. + /// + /// + /// + public Variable getCopy(Variable inVariable) + { + int index = _inVariableSet.IndexOf(inVariable); + if (index >= 0) + return _outVariableSet[index]; + else + { + Variable outVariable = new Variable(); + _inVariableSet.Add(inVariable); + _outVariableSet.Add(outVariable); + return outVariable; + } + } + + /// + /// Return the number of unique variables that have been copied. + /// + /// + public int getNUniqueVariables() + { + return _inVariableSet.Count; + } + } + } +} 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 - * - * 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; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - /// - /// YP has static methods for general functions in Yield Prolog such as - /// and . - /// - public class YP - { - private static Fail _fail = new Fail(); - private static Repeat _repeat = new Repeat(); - private static Dictionary> _predicatesStore = - new Dictionary>(); - private static TextWriter _outputStream = System.Console.Out; - private static TextReader _inputStream = System.Console.In; - private static List _operatorTable = null; - - /// - /// An IClause is used so that dynamic predicates can call match. - /// - public interface IClause - { - IEnumerable match(object[] args); - } - - public static object getValue(object value) - { - if (value is Variable) - return ((Variable)value).getValue(); - else - return value; - } - - public static IEnumerable 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; - } - } - - /// - /// This is used for the lookup key in _factStore. - /// - 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(); - } - } - - /// - /// 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 an exception. - /// - /// - /// - 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); - - return (int)term; - } - - /// - /// 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 an exception. - /// - /// - /// - 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); - - return Convert.ToDouble(term); - } - - /// - /// 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. - /// - /// - /// - 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)); - } - - /// - /// The ISO standard returns an int. - /// - /// - /// - public static object floor(object x) - { - return (int)Math.Floor(convertDouble(x)); - } - - /// - /// The ISO standard returns an int. - /// - /// - /// - public static object truncate(object x) - { - return (int)Math.Truncate(convertDouble(x)); - } - - /// - /// The ISO standard returns an int. - /// - /// - /// - public static object round(object x) - { - return (int)Math.Round(convertDouble(x)); - } - - /// - /// The ISO standard returns an int. - /// - /// - /// - 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); - } - - /// - /// Return floating point, even if both arguments are integer. - /// - /// - /// - /// - 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 copy_term(object inTerm, object outTerm) - { - return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore())); - } - - public static void addUniqueVariables(object term, List 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; - } - - /// - /// Sort the array in place according to termLessThan. This does not remove duplicates - /// - /// - public static void sortArray(object[] array) - { - Array.Sort(array, YP.compareTerms); - } - - /// - /// Sort the array in place according to termLessThan. This does not remove duplicates - /// - /// - public static void sortArray(List array) - { - array.Sort(YP.compareTerms); - } - - /// - /// Sort List according to termLessThan, remove duplicates and unify with Sorted. - /// - /// - /// - /// - public static IEnumerable 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)); - } - - - - /// - /// Use YP.unify to unify each of the elements of the two arrays, and yield - /// once if they all unify. - /// - /// - /// - /// - public static IEnumerable unifyArrays(object[] array1, object[] array2) - { - if (array1.Length != array2.Length) - yield break; - - IEnumerator[] iterators = new IEnumerator[array1.Length]; - bool gotMatch = true; - int nIterators = 0; - // Try to bind all the arguments. - for (int i = 0; i < array1.Length; ++i) - { - IEnumerator 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(); - } - } - - /// - /// 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. - /// - /// - public static IEnumerable fail() - { - return _fail; - } - - /// - /// 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. - /// - /// - public static IEnumerable succeed() - { - return new Succeed(); - } - - /// - /// 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. - /// - /// - public static IEnumerable repeat() - { - return _repeat; - } - - public static IEnumerable 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 Exception("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 (!atom(Name)) - throw new Exception("Expected an atom. Got: " + Name.getValue()); - - return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args)); - } - - return YP.fail(); - } - - public static IEnumerable functor(object Term, object FunctorName, object Arity) - { - Term = YP.getValue(Term); - FunctorName = YP.getValue(FunctorName); - Arity = YP.getValue(Arity); - - if (!(Term is Variable)) - { - foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term))) - { - foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length)) - yield return false; - } - } - else - throw new NotImplementedException("Debug: must finish functor/3"); - } - - public static IEnumerable arg(object ArgNumber, object Term, object Value) - { - if (YP.var(ArgNumber)) - throw new NotImplementedException("Debug: must finish arg/3"); - else - { - int argNumberInt = convertInt(ArgNumber); - if (argNumberInt < 0) - throw new Exception("ArgNumber must be non-negative"); - 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; - } - - /// - /// 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). - /// - /// - /// - 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 current_op - (object Priority, object Specifier, object Operator) - { - if (_operatorTable == null) - { - // Initialize. - _operatorTable = new List(); - _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[] { 1100, 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[] { 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("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[] { 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[] { 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("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[] { 200, Atom.a("xfx"), 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("\\") }); - // 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("<--") }); - } - - object[] args = new object[] { Priority, Specifier, Operator }; - foreach (object[] answer in _operatorTable) - { - foreach (bool l1 in YP.unifyArrays(args, answer)) - yield return false; - } - } - - public static IEnumerable atom_length(object atom, object Length) - { - return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length); - } - - public static IEnumerable atom_concat(object Start, object End, object Whole) - { - // Debug: Should implement for var(Start) which is a kind of search. - // Debug: Should we try to preserve the _declaringClass? - return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name + - ((Atom)YP.getValue(End))._name)); - } - - public static IEnumerable 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 we try to preserve the _declaringClass? - Atom atomAtom = (Atom)YP.getValue(atom); - int beforeInt = YP.convertInt(Before); - int lengthInt = YP.convertInt(Length); - if (beforeInt < 0) - throw new Exception("Before must be non-negative"); - if (lengthInt < 0) - throw new Exception("Length must be non-negative"); - int afterInt = atomAtom._name.Length - (beforeInt + lengthInt); - if (afterInt >= 0) - { - foreach (bool l1 in YP.unify(After, afterInt)) - { - foreach (bool l2 in YP.unify - (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt)))) - yield return false; - } - } - } - - public static IEnumerable atom_codes(object atom, object List) - { - atom = YP.getValue(atom); - List = YP.getValue(List); - - if (nonvar(atom)) - { - string name = ((Atom)atom)._name; - object codeList = Atom.NIL; - // Start from the back to make the list. - for (int i = name.Length - 1; i >= 0; --i) - codeList = new ListPair((int)name[i], codeList); - return YP.unify(List, codeList); - } - { - object[] codeArray = ListPair.toArray(List); - char[] charArray = new char[codeArray.Length]; - for (int i = 0; i < codeArray.Length; ++i) - charArray[i] = (char)YP.convertInt(codeArray[i]); - return YP.unify(atom, Atom.a(new String(charArray))); - } - } - - public static IEnumerable number_codes(object number, object List) - { - number = YP.getValue(number); - List = YP.getValue(List); - - if (nonvar(number)) - { - string numberString = null; - // Try converting to an int first. - int intNumber; - if (YP.getInt(number, out intNumber)) - numberString = intNumber.ToString(); - else - 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); - } - { - object[] codeArray = ListPair.toArray(List); - char[] charArray = new char[codeArray.Length]; - for (int i = 0; i < codeArray.Length; ++i) - charArray[i] = (char)YP.convertInt(codeArray[i]); - String numberString = new String(charArray); - // 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 YP.unify(number, Convert.ToInt32(numberString)); - } - catch (FormatException) { } - return YP.unify(number, Convert.ToDouble(numberString)); - } - } - - /// - /// If term is an Atom or functor type, return its name. - /// Otherwise, return term. - /// - /// - /// - 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; - } - - /// - /// If term is an Atom or functor type, return an array of its args. - /// Otherwise, return an empty array. - /// - /// - /// - 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 number(object Term) - { - Term = getValue(Term); - // Debug: Should exhaustively check for all number types. - return Term is int || Term is double; - } - - 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; - } - - public static void see(object input) - { - input = YP.getValue(input); - 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 - throw new InvalidOperationException("Can't open stream for " + input); - } - - public static void seen() - { - if (_inputStream == Console.In) - return; - _inputStream.Close(); - _inputStream = Console.In; - } - - public static void tell(object output) - { - output = YP.getValue(output); - 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 InvalidOperationException("Can't open stream for " + output); - } - - public static void told() - { - if (_outputStream == Console.Out) - return; - _outputStream.Close(); - _outputStream = Console.Out; - } - - public static void write(object x) - { - x = YP.getValue(x); - if (x is double) - _outputStream.Write(doubleToString((double)x)); - else - _outputStream.Write(x.ToString()); - } - - /// - /// 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. - /// - /// - /// - 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) - { - _outputStream.Write((char)YP.convertInt(x)); - } - - public static void nl() - { - _outputStream.WriteLine(); - } - - public static IEnumerable get_code(object code) - { - return YP.unify(code, _inputStream.Read()); - } - - public static void assertFact(Atom name, object[] values) - { - NameArity nameArity = new NameArity(name, values.Length); - List clauses; - IndexedAnswers indexedAnswers; - if (!_predicatesStore.TryGetValue(nameArity, out clauses)) - { - // Create an IndexedAnswers as the first clause of the predicate. - _predicatesStore[nameArity] = (clauses = new List()); - clauses.Add(indexedAnswers = new IndexedAnswers()); - } - else - { - 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()); - } - - indexedAnswers.addAnswer(values); - } - - public static IEnumerable matchFact(Atom name, object[] arguments) - { - List clauses; - if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses)) - throw new UndefinedPredicateException - ("Undefined fact: " + name + "/" + arguments.Length, 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); - } - - /// - /// 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. - /// - /// - /// - /// - private static IEnumerable matchAllClauses(List clauses, object[] arguments) - { - foreach (IClause clause in clauses) - { - foreach (bool lastCall in clause.match(arguments)) - yield return false; - } - } - - public static void retractFact(Atom name, object[] arguments) - { - NameArity nameArity = new NameArity(name, arguments.Length); - List 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("All arguments must be unbound"); - } - // Set to a fresh empty IndexedAnswers. - _predicatesStore[nameArity] = (clauses = new List()); - clauses.Add(new IndexedAnswers()); - } - - public static IEnumerable current_predicate(object NameSlashArity) - { - NameSlashArity = YP.getValue(NameSlashArity); - // First check if Name and Arity are nonvar so we can do a direct lookup. - if (YP.ground(NameSlashArity)) - { - if (NameSlashArity is Functor2) - { - Functor2 NameArityFunctor = (Functor2)NameSlashArity; - if (NameArityFunctor._name == Atom.SLASH) - { - if (_predicatesStore.ContainsKey(new NameArity - ((Atom)YP.getValue(NameArityFunctor._arg1), - (int)YP.getValue(NameArityFunctor._arg2)))) - // The predicate is defined. - yield return false; - } - } - yield break; - } - - foreach (NameArity key in _predicatesStore.Keys) - { - foreach (bool l1 in YP.unify - (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity)) - yield return false; - } - } - - /// - /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the - /// declaringClass, using arguments from YP.getFunctorArgs(Goal). - /// Note that Goal must be a simple functor, not a complex expression. - /// If not found, this throws UndefinedPredicateException. - /// - /// - /// the class for looking up default function references - /// - public static IEnumerable getIterator(object Goal, Type declaringClass) - { -#if true - List variableSetList = new List(); - addUniqueVariables(Goal, variableSetList); - Variable[] variableSet = variableSetList.ToArray(); - object Head = Functor.make("function", variableSet); - - object Rule = new Functor2(Atom.RULE, Head, Goal); - object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL)); - StringWriter functionCode = new StringWriter(); - TextWriter saveOutputStream = _outputStream; - try - { - tell(functionCode); - Variable FunctionCode = new Variable(); - foreach (bool l1 in YPCompiler.makeFunctionPseudoCode(RuleList, FunctionCode)) - { - if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass"))) - // Ignore getDeclaringClass since we have access to the one passed in. - continue; - - // Debug: should check if FunctionCode is a single call. - YPCompiler.convertFunctionCSharp(FunctionCode); - } - told(); - } - finally - { - // Restore after calling tell. - _outputStream = saveOutputStream; - } - return YPCompiler.compileAnonymousFunction - (functionCode.ToString(), variableSet.Length, declaringClass).match(variableSet); -#else - Goal = YP.getValue(Goal); - Atom name; - object[] args; - while (true) - { - name = (Atom)YP.getFunctorName(Goal); - 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; - } - try - { - return (IEnumerable)declaringClass.InvokeMember - (name._name, BindingFlags.InvokeMethod, null, null, args); - } - catch (TargetInvocationException exception) - { - throw exception.InnerException; - } - catch (MissingMethodException) - { - throw new UndefinedPredicateException - ("Cannot find predicate function: " + name + "/" + args.Length + " in " + - declaringClass.FullName, name, args.Length); - } -#endif - } - - public static void throwException(object Term) - { - throw new PrologException(Term); - } - - /// - /// script_event calls hosting script with events as a callback method. - /// - /// - /// - /// - public static void 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) - 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)); - } - - /// - /// An enumerator that does zero loops. - /// - private class Fail : IEnumerator, IEnumerable - { - public bool MoveNext() - { - return false; - } - - public IEnumerator GetEnumerator() - { - return (IEnumerator)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(); - } - } - - /// - /// An enumerator that does one iteration. - /// - private class Succeed : IEnumerator, IEnumerable - { - private bool _didIteration = false; - - public bool MoveNext() - { - if (!_didIteration) - { - _didIteration = true; - return true; - } - else - return false; - } - - public IEnumerator GetEnumerator() - { - return (IEnumerator)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(); - } - } - - /// - /// An enumerator that repeats forever. - /// - private class Repeat : IEnumerator, IEnumerable - { - public bool MoveNext() - { - return true; - } - - public IEnumerator GetEnumerator() - { - return (IEnumerator)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(); - } - } - } -} +/* + * 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; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + /// + /// YP has static methods for general functions in Yield Prolog such as + /// and . + /// + public class YP + { + private static Fail _fail = new Fail(); + private static Repeat _repeat = new Repeat(); + private static Dictionary> _predicatesStore = + new Dictionary>(); + private static TextWriter _outputStream = System.Console.Out; + private static TextReader _inputStream = System.Console.In; + private static List _operatorTable = null; + + /// + /// An IClause is used so that dynamic predicates can call match. + /// + public interface IClause + { + IEnumerable match(object[] args); + } + + public static object getValue(object value) + { + if (value is Variable) + return ((Variable)value).getValue(); + else + return value; + } + + public static IEnumerable 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; + } + } + + /// + /// This is used for the lookup key in _factStore. + /// + 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(); + } + } + + /// + /// 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 an exception. + /// + /// + /// + 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); + + return (int)term; + } + + /// + /// 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 an exception. + /// + /// + /// + 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); + + return Convert.ToDouble(term); + } + + /// + /// 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. + /// + /// + /// + 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)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object floor(object x) + { + return (int)Math.Floor(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object truncate(object x) + { + return (int)Math.Truncate(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + public static object round(object x) + { + return (int)Math.Round(convertDouble(x)); + } + + /// + /// The ISO standard returns an int. + /// + /// + /// + 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); + } + + /// + /// Return floating point, even if both arguments are integer. + /// + /// + /// + /// + 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 copy_term(object inTerm, object outTerm) + { + return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore())); + } + + public static void addUniqueVariables(object term, List 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; + } + + /// + /// Sort the array in place according to termLessThan. This does not remove duplicates + /// + /// + public static void sortArray(object[] array) + { + Array.Sort(array, YP.compareTerms); + } + + /// + /// Sort the array in place according to termLessThan. This does not remove duplicates + /// + /// + public static void sortArray(List array) + { + array.Sort(YP.compareTerms); + } + + /// + /// Sort List according to termLessThan, remove duplicates and unify with Sorted. + /// + /// + /// + /// + public static IEnumerable 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)); + } + + + + /// + /// Use YP.unify to unify each of the elements of the two arrays, and yield + /// once if they all unify. + /// + /// + /// + /// + public static IEnumerable unifyArrays(object[] array1, object[] array2) + { + if (array1.Length != array2.Length) + yield break; + + IEnumerator[] iterators = new IEnumerator[array1.Length]; + bool gotMatch = true; + int nIterators = 0; + // Try to bind all the arguments. + for (int i = 0; i < array1.Length; ++i) + { + IEnumerator 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(); + } + } + + /// + /// 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. + /// + /// + public static IEnumerable fail() + { + return _fail; + } + + /// + /// 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. + /// + /// + public static IEnumerable succeed() + { + return new Succeed(); + } + + /// + /// 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. + /// + /// + public static IEnumerable repeat() + { + return _repeat; + } + + public static IEnumerable 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 Exception("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 (!atom(Name)) + throw new Exception("Expected an atom. Got: " + Name.getValue()); + + return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args)); + } + + return YP.fail(); + } + + public static IEnumerable functor(object Term, object FunctorName, object Arity) + { + Term = YP.getValue(Term); + FunctorName = YP.getValue(FunctorName); + Arity = YP.getValue(Arity); + + if (!(Term is Variable)) + { + foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term))) + { + foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length)) + yield return false; + } + } + else + throw new NotImplementedException("Debug: must finish functor/3"); + } + + public static IEnumerable arg(object ArgNumber, object Term, object Value) + { + if (YP.var(ArgNumber)) + throw new NotImplementedException("Debug: must finish arg/3"); + else + { + int argNumberInt = convertInt(ArgNumber); + if (argNumberInt < 0) + throw new Exception("ArgNumber must be non-negative"); + 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; + } + + /// + /// 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). + /// + /// + /// + 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 current_op + (object Priority, object Specifier, object Operator) + { + if (_operatorTable == null) + { + // Initialize. + _operatorTable = new List(); + _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[] { 1100, 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[] { 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("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[] { 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[] { 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("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[] { 200, Atom.a("xfx"), 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("\\") }); + // 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("<--") }); + } + + object[] args = new object[] { Priority, Specifier, Operator }; + foreach (object[] answer in _operatorTable) + { + foreach (bool l1 in YP.unifyArrays(args, answer)) + yield return false; + } + } + + public static IEnumerable atom_length(object atom, object Length) + { + return YP.unify(Length, ((Atom)YP.getValue(atom))._name.Length); + } + + public static IEnumerable atom_concat(object Start, object End, object Whole) + { + // Debug: Should implement for var(Start) which is a kind of search. + // Debug: Should we try to preserve the _declaringClass? + return YP.unify(Whole, Atom.a(((Atom)YP.getValue(Start))._name + + ((Atom)YP.getValue(End))._name)); + } + + public static IEnumerable 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 we try to preserve the _declaringClass? + Atom atomAtom = (Atom)YP.getValue(atom); + int beforeInt = YP.convertInt(Before); + int lengthInt = YP.convertInt(Length); + if (beforeInt < 0) + throw new Exception("Before must be non-negative"); + if (lengthInt < 0) + throw new Exception("Length must be non-negative"); + int afterInt = atomAtom._name.Length - (beforeInt + lengthInt); + if (afterInt >= 0) + { + foreach (bool l1 in YP.unify(After, afterInt)) + { + foreach (bool l2 in YP.unify + (Sub_atom, Atom.a(atomAtom._name.Substring(beforeInt, lengthInt)))) + yield return false; + } + } + } + + public static IEnumerable atom_codes(object atom, object List) + { + atom = YP.getValue(atom); + List = YP.getValue(List); + + if (nonvar(atom)) + { + string name = ((Atom)atom)._name; + object codeList = Atom.NIL; + // Start from the back to make the list. + for (int i = name.Length - 1; i >= 0; --i) + codeList = new ListPair((int)name[i], codeList); + return YP.unify(List, codeList); + } + { + object[] codeArray = ListPair.toArray(List); + char[] charArray = new char[codeArray.Length]; + for (int i = 0; i < codeArray.Length; ++i) + charArray[i] = (char)YP.convertInt(codeArray[i]); + return YP.unify(atom, Atom.a(new String(charArray))); + } + } + + public static IEnumerable number_codes(object number, object List) + { + number = YP.getValue(number); + List = YP.getValue(List); + + if (nonvar(number)) + { + string numberString = null; + // Try converting to an int first. + int intNumber; + if (YP.getInt(number, out intNumber)) + numberString = intNumber.ToString(); + else + 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); + } + { + object[] codeArray = ListPair.toArray(List); + char[] charArray = new char[codeArray.Length]; + for (int i = 0; i < codeArray.Length; ++i) + charArray[i] = (char)YP.convertInt(codeArray[i]); + String numberString = new String(charArray); + // 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 YP.unify(number, Convert.ToInt32(numberString)); + } + catch (FormatException) { } + return YP.unify(number, Convert.ToDouble(numberString)); + } + } + + /// + /// If term is an Atom or functor type, return its name. + /// Otherwise, return term. + /// + /// + /// + 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; + } + + /// + /// If term is an Atom or functor type, return an array of its args. + /// Otherwise, return an empty array. + /// + /// + /// + 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 number(object Term) + { + Term = getValue(Term); + // Debug: Should exhaustively check for all number types. + return Term is int || Term is double; + } + + 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; + } + + public static void see(object input) + { + input = YP.getValue(input); + 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 + throw new InvalidOperationException("Can't open stream for " + input); + } + + public static void seen() + { + if (_inputStream == Console.In) + return; + _inputStream.Close(); + _inputStream = Console.In; + } + + public static void tell(object output) + { + output = YP.getValue(output); + 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 InvalidOperationException("Can't open stream for " + output); + } + + public static void told() + { + if (_outputStream == Console.Out) + return; + _outputStream.Close(); + _outputStream = Console.Out; + } + + public static void write(object x) + { + x = YP.getValue(x); + if (x is double) + _outputStream.Write(doubleToString((double)x)); + else + _outputStream.Write(x.ToString()); + } + + /// + /// 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. + /// + /// + /// + 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) + { + _outputStream.Write((char)YP.convertInt(x)); + } + + public static void nl() + { + _outputStream.WriteLine(); + } + + public static IEnumerable get_code(object code) + { + return YP.unify(code, _inputStream.Read()); + } + + public static void assertFact(Atom name, object[] values) + { + NameArity nameArity = new NameArity(name, values.Length); + List clauses; + IndexedAnswers indexedAnswers; + if (!_predicatesStore.TryGetValue(nameArity, out clauses)) + { + // Create an IndexedAnswers as the first clause of the predicate. + _predicatesStore[nameArity] = (clauses = new List()); + clauses.Add(indexedAnswers = new IndexedAnswers()); + } + else + { + 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()); + } + + indexedAnswers.addAnswer(values); + } + + public static IEnumerable matchFact(Atom name, object[] arguments) + { + List clauses; + if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses)) + throw new UndefinedPredicateException + ("Undefined fact: " + name + "/" + arguments.Length, 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); + } + + /// + /// 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. + /// + /// + /// + /// + private static IEnumerable matchAllClauses(List clauses, object[] arguments) + { + foreach (IClause clause in clauses) + { + foreach (bool lastCall in clause.match(arguments)) + yield return false; + } + } + + public static void retractFact(Atom name, object[] arguments) + { + NameArity nameArity = new NameArity(name, arguments.Length); + List 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("All arguments must be unbound"); + } + // Set to a fresh empty IndexedAnswers. + _predicatesStore[nameArity] = (clauses = new List()); + clauses.Add(new IndexedAnswers()); + } + + public static IEnumerable current_predicate(object NameSlashArity) + { + NameSlashArity = YP.getValue(NameSlashArity); + // First check if Name and Arity are nonvar so we can do a direct lookup. + if (YP.ground(NameSlashArity)) + { + if (NameSlashArity is Functor2) + { + Functor2 NameArityFunctor = (Functor2)NameSlashArity; + if (NameArityFunctor._name == Atom.SLASH) + { + if (_predicatesStore.ContainsKey(new NameArity + ((Atom)YP.getValue(NameArityFunctor._arg1), + (int)YP.getValue(NameArityFunctor._arg2)))) + // The predicate is defined. + yield return false; + } + } + yield break; + } + + foreach (NameArity key in _predicatesStore.Keys) + { + foreach (bool l1 in YP.unify + (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity)) + yield return false; + } + } + + /// + /// Use YP.getFunctorName(Goal) and invoke the static method of this name in the + /// declaringClass, using arguments from YP.getFunctorArgs(Goal). + /// Note that Goal must be a simple functor, not a complex expression. + /// If not found, this throws UndefinedPredicateException. + /// + /// + /// the class for looking up default function references + /// + public static IEnumerable getIterator(object Goal, Type declaringClass) + { +#if true + List variableSetList = new List(); + addUniqueVariables(Goal, variableSetList); + Variable[] variableSet = variableSetList.ToArray(); + object Head = Functor.make("function", variableSet); + + object Rule = new Functor2(Atom.RULE, Head, Goal); + object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL)); + StringWriter functionCode = new StringWriter(); + TextWriter saveOutputStream = _outputStream; + try + { + tell(functionCode); + Variable FunctionCode = new Variable(); + foreach (bool l1 in YPCompiler.makeFunctionPseudoCode(RuleList, FunctionCode)) + { + if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass"))) + // Ignore getDeclaringClass since we have access to the one passed in. + continue; + + // Debug: should check if FunctionCode is a single call. + YPCompiler.convertFunctionCSharp(FunctionCode); + } + told(); + } + finally + { + // Restore after calling tell. + _outputStream = saveOutputStream; + } + return YPCompiler.compileAnonymousFunction + (functionCode.ToString(), variableSet.Length, declaringClass).match(variableSet); +#else + Goal = YP.getValue(Goal); + Atom name; + object[] args; + while (true) + { + name = (Atom)YP.getFunctorName(Goal); + 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; + } + try + { + return (IEnumerable)declaringClass.InvokeMember + (name._name, BindingFlags.InvokeMethod, null, null, args); + } + catch (TargetInvocationException exception) + { + throw exception.InnerException; + } + catch (MissingMethodException) + { + throw new UndefinedPredicateException + ("Cannot find predicate function: " + name + "/" + args.Length + " in " + + declaringClass.FullName, name, args.Length); + } +#endif + } + + public static void throwException(object Term) + { + throw new PrologException(Term); + } + + /// + /// script_event calls hosting script with events as a callback method. + /// + /// + /// + /// + public static void 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) + 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)); + } + + /// + /// An enumerator that does zero loops. + /// + private class Fail : IEnumerator, IEnumerable + { + public bool MoveNext() + { + return false; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)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(); + } + } + + /// + /// An enumerator that does one iteration. + /// + private class Succeed : IEnumerator, IEnumerable + { + private bool _didIteration = false; + + public bool MoveNext() + { + if (!_didIteration) + { + _didIteration = true; + return true; + } + else + return false; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)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(); + } + } + + /// + /// An enumerator that repeats forever. + /// + private class Repeat : IEnumerator, IEnumerable + { + public bool MoveNext() + { + return true; + } + + public IEnumerator GetEnumerator() + { + return (IEnumerator)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(); + } + } + } +} diff --git a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YPCompiler.cs b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YPCompiler.cs index 923906b..a0a92b6 100644 --- a/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YPCompiler.cs +++ b/OpenSim/Region/ScriptEngine/DotNetEngine/Compiler/YieldProlog/YPCompiler.cs @@ -1,5247 +1,5247 @@ -/* - * 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.IO; -using System.Collections; -using System.Collections.Generic; -using System.Text; -using System.CodeDom.Compiler; - -namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog -{ - public class YPCompiler - { - private class CompilerState - { - public IndexedAnswers _pred = new IndexedAnswers(); - public Dictionary _moduleForNameArity = new Dictionary(); - public int _gensymCounter; - public bool _useFinalCutCode; - public Variable _finalCutCode; - public bool _codeUsesYield; - public Atom _determinism; - // a list of '='(Name, Variable) - public List _variableNames; - - // Make these static functions that explicitly take the State so Prolog can call it. - - /// - /// Make a new CompilerState and bind it to State. - /// - /// - /// - public static IEnumerable make(object State) - { - return YP.unify(State, new CompilerState()); - } - - public static void assertPred(object State, object Pred, object Determinism) - { - State = YP.getValue(State); - object functorName = YP.getFunctorName(Pred); - object[] functorArgs = YP.getFunctorArgs(Pred); - // Debug: Should check if it's already asserted and is the same. - ((CompilerState)State)._pred.addAnswer - (new object[] { functorName, functorArgs.Length, Pred, YP.getValue(Determinism) }); - } - - public static void assertModuleForNameArity(object State, object Name, object Arity, object Module) - { - State = YP.getValue(State); - Name = YP.getValue(Name); - Arity = YP.getValue(Arity); - Module = YP.getValue(Module); - // If the Module Atom comes from the parser, it always has null _declaringClass. - if (Module is Atom && ((Atom)Module)._module == null && Name is Atom && Arity is int) - { - // Replace a previous entry if it exists. - ((CompilerState)State)._moduleForNameArity[new YP.NameArity((Atom)Name, (int)Arity)] = - (Atom)Module; - } - } - - public static void startFunction(object State, object Head) - { - State = YP.getValue(State); - ((CompilerState)State)._gensymCounter = 0; - ((CompilerState)State)._useFinalCutCode = false; - ((CompilerState)State)._finalCutCode = new Variable(); - ((CompilerState)State)._codeUsesYield = false; - if (CompilerState.isDetNoneOut(State, Head)) - ((CompilerState)State)._determinism = Atom.a("detNoneOut"); - else if (CompilerState.isSemidetNoneOut(State, Head)) - ((CompilerState)State)._determinism = Atom.a("semidetNoneOut"); - else - ((CompilerState)State)._determinism = Atom.a("nondet"); - } - - public static void setCodeUsesYield(object State) - { - State = YP.getValue(State); - ((CompilerState)State)._codeUsesYield = true; - } - - public static bool codeUsesYield(object State) - { - State = YP.getValue(State); - return ((CompilerState)State)._codeUsesYield; - } - - public static bool determinismEquals(object State, object Term) - { - State = YP.getValue(State); - return YP.termEqual(((CompilerState)State)._determinism, Term); - } - - /// - /// Set _variableNames to a new list of (Name = Variable) for each unique variable in rule. - /// If the variable is in variableNameSuggestions, use it, otherwise use x1, x2, etc. - /// - /// - /// - /// - public static void newVariableNames(object State, object Rule, object VariableNameSuggestions) - { - State = YP.getValue(State); - List variablesSet = new List(); - YP.addUniqueVariables(Rule, variablesSet); - - ((CompilerState)State)._variableNames = new List(); - int xCounter = 0; - foreach (Variable variable in variablesSet) - ((CompilerState)State)._variableNames.Add - (new Functor2(Atom.a("="), makeVariableName(variable, VariableNameSuggestions, ++xCounter), - variable)); - } - - private static object makeVariableName(object variable, object variableNameSuggestions, int xCounter) - { - // Debug: should require named variables to start with _ or capital. Should - // check for duplicates and clashes with keywords. - for (object element = YP.getValue(variableNameSuggestions); - element is Functor2 && ((Functor2)element)._name == Atom.DOT; - element = YP.getValue(((Functor2)element)._arg2)) - { - object suggestionPair = YP.getValue(((Functor2)element)._arg1); - if (sameVariable(variable, ((Functor2)suggestionPair)._arg2)) - { - Atom suggestion = (Atom)YP.getValue(((Functor2)suggestionPair)._arg1); - if (suggestion.Equals(Atom.a("Atom"))) - suggestion = Atom.a("Atom_1"); - if (suggestion.Equals(Atom.a("Variable"))) - suggestion = Atom.a("Variable_1"); - if (suggestion.Equals(Atom.a("Functor"))) - suggestion = Atom.a("Functor_1"); - return suggestion; - } - } - - return Atom.a("x" + xCounter); - } - - /// - /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames - /// for variable. - /// - /// a Variable - /// - /// the assigned Name - public static IEnumerable getVariableName(object State, object variable, object Result) - { - State = YP.getValue(State); - foreach (object variableInfo in ((CompilerState)State)._variableNames) - { - if (variableInfo is Functor2 && ((Functor2)variableInfo)._name.Equals(Atom.a("="))) - { - if (sameVariable(variable, ((Functor2)variableInfo)._arg2)) - return YP.unify(Result, ((Functor2)variableInfo)._arg1); - } - } - - // We set up names for all unique variables, so this should never happen. - throw new PrologException(Atom.a("Can't find entry in _variableNames")); - } - - public static IEnumerable variableNamesList(object State, object VariableNamesList) - { - State = YP.getValue(State); - return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames)); - } - - public static IEnumerable gensym(object State, object Base, object Symbol) - { - State = YP.getValue(State); - return YP.unify(Symbol, Atom.a(Base.ToString() + ++((CompilerState)State)._gensymCounter)); - } - - public static bool isDetNoneOut(object State, object Term) - { - State = YP.getValue(State); - object functorName = YP.getFunctorName(Term); - object[] functorArgs = YP.getFunctorArgs(Term); - - Variable pred = new Variable(); - foreach (bool l1 in ((CompilerState)State)._pred.match - (new object[] { functorName, functorArgs.Length, pred, Atom.a("det") })) - { - if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) - { - return true; - } - } - - return false; - } - - public static bool isSemidetNoneOut(object State, object Term) - { - State = YP.getValue(State); - object functorName = YP.getFunctorName(Term); - object[] functorArgs = YP.getFunctorArgs(Term); - - Variable pred = new Variable(); - foreach (bool l1 in ((CompilerState)State)._pred.match - (new object[] { functorName, functorArgs.Length, pred, Atom.a("semidet") })) - { - if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) - { - return true; - } - } - - return false; - } - - /// - /// Return false if any of args is out, otherwise true. - /// args is an array of ::(Type,Mode) where Mode is in or out. - /// - /// - /// - private static bool isNoneOut(object[] args) - { - foreach (object arg in args) - { - if (arg is Functor2 && ((Functor2)arg)._name == Atom.a("::") && - ((Functor2)arg)._arg2 == Atom.a("out")) - return false; - } - return true; - } - - public static bool nameArityHasModule(object State, object Name, object Arity, object Module) - { - State = YP.getValue(State); - Name = YP.getValue(Name); - Arity = YP.getValue(Arity); - Module = YP.getValue(Module); - if (Name is Atom && Arity is int) - { - Atom FoundModule; - if (!((CompilerState)State)._moduleForNameArity.TryGetValue - (new YP.NameArity((Atom)Name, (int)Arity), out FoundModule)) - return false; - return FoundModule == Module; - } - return false; - } - } - - /// - /// Use CodeDomProvider to compile the functionCode and return a YP.IClause. - /// The function name must be "function" and have nArgs arguments. - /// - /// the code for the iterator, such as - /// "public static IEnumerable function() { yield return false; }" - /// - /// the number of args in the function - /// if not null, then use the functionCode inside a class which - /// inherits from contextClass, so that references in functionCode to methods in declaringClass don't - /// have to be qualified - /// a new YP.IClause object on which you can call match(object[] args) where - /// args length is nArgs - public static YP.IClause compileAnonymousFunction(string functionCode, int nArgs, Type declaringClass) - { - CompilerParameters parameters = new CompilerParameters(); - // This gets the location of the System assembly. - parameters.ReferencedAssemblies.Add(typeof(System.Int32).Assembly.Location); - // This gets the location of this assembly which also has YieldProlog.YP, etc. - parameters.ReferencedAssemblies.Add(typeof(YPCompiler).Assembly.Location); - if (declaringClass != null) - parameters.ReferencedAssemblies.Add(declaringClass.Assembly.Location); - parameters.GenerateInMemory = true; - - StringBuilder sourceCode = new StringBuilder(); - sourceCode.Append(@" -using System; -using System.Collections.Generic; -using YieldProlog; - -namespace Temporary { - public class Temporary : YP.IClause { - public class Inner" + (declaringClass == null ? "" : " : " + declaringClass.FullName) + @" { -"); - sourceCode.Append(functionCode); - // Basically, match applies the args to function. - sourceCode.Append(@" - } - public IEnumerable match(object[] args) { - return Inner.function("); - if (nArgs >= 1) - sourceCode.Append("args[0]"); - for (int i = 1; i < nArgs; ++i) - sourceCode.Append(", args[" + i + "]"); - sourceCode.Append(@"); - } - } -} -"); - - CompilerResults results = CodeDomProvider.CreateProvider - ("CSharp").CompileAssemblyFromSource(parameters, sourceCode.ToString()); - if (results.Errors.Count > 0) - throw new Exception("Error evaluating code: " + results.Errors[0]); - - // Return a new Temporary.Temporary object. - return (YP.IClause)results.CompiledAssembly.GetType - ("Temporary.Temporary").GetConstructor(Type.EmptyTypes).Invoke(null); - } - - // Compiler output follows. - - class YPInnerClass { } - static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } - - public static void repeatWrite(object arg1, object N) - { - { - object _Value = arg1; - if (YP.termEqual(N, 0)) - { - return; - } - } - { - object Value = arg1; - Variable NextN = new Variable(); - YP.write(Value); - foreach (bool l2 in YP.unify(NextN, YP.subtract(N, 1))) - { - repeatWrite(Value, NextN); - return; - } - } - } - - public static bool sameVariable(object Variable1, object Variable2) - { - { - if (YP.var(Variable1)) - { - if (YP.var(Variable2)) - { - if (YP.termEqual(Variable1, Variable2)) - { - return true; - } - } - } - } - return false; - } - - public static IEnumerable makeFunctionPseudoCode(object RuleList, object FunctionCode) - { - { - Variable State = new Variable(); - foreach (bool l2 in CompilerState.make(State)) - { - CompilerState.assertPred(State, Atom.a(@"nl"), Atom.a(@"det")); - CompilerState.assertPred(State, new Functor1(@"write", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); - CompilerState.assertPred(State, new Functor1(@"put_code", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); - CompilerState.assertPred(State, new Functor1(@"throw", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); - CompilerState.assertPred(State, new Functor1(@"var", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor1(@"nonvar", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor1(@"atom", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor1(@"number", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"\==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"@<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"@=<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"@>", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - CompilerState.assertPred(State, new Functor2(@"@>=", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); - processCompilerDirectives(RuleList, State); - foreach (bool l3 in YP.unify(FunctionCode, Atom.a(@"getDeclaringClass"))) - { - yield return false; - } - foreach (bool l3 in makeFunctionPseudoCode3(RuleList, State, FunctionCode)) - { - yield return false; - } - } - } - } - - public static void processCompilerDirectives(object arg1, object arg2) - { - { - object _State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - object State = arg2; - Variable Pred = new Variable(); - Variable Determinism = new Variable(); - Variable x3 = new Variable(); - Variable RestRules = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor1(@"pred", new Functor2(@"is", Pred, Determinism))), x3), RestRules))) - { - CompilerState.assertPred(State, Pred, Determinism); - processCompilerDirectives(RestRules, State); - return; - } - } - { - object State = arg2; - Variable Module = new Variable(); - Variable PredicateList = new Variable(); - Variable x3 = new Variable(); - Variable RestRules = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor2(@"import", Module, PredicateList)), x3), RestRules))) - { - foreach (bool l3 in importPredicateList(State, Module, PredicateList)) - { - processCompilerDirectives(RestRules, State); - return; - } - } - } - { - object State = arg2; - Variable x1 = new Variable(); - Variable x2 = new Variable(); - Variable RestRules = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", x1), x2), RestRules))) - { - processCompilerDirectives(RestRules, State); - return; - } - } - { - object State = arg2; - Variable Head = new Variable(); - Variable _Body = new Variable(); - Variable x3 = new Variable(); - Variable RestRules = new Variable(); - Variable Name = new Variable(); - Variable Arity = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor2(@":-", Head, _Body), x3), RestRules))) - { - foreach (bool l3 in YP.functor(Head, Name, Arity)) - { - CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); - processCompilerDirectives(RestRules, State); - return; - } - } - } - { - object State = arg2; - Variable Fact = new Variable(); - Variable x2 = new Variable(); - Variable RestRules = new Variable(); - Variable Name = new Variable(); - Variable Arity = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", Fact, x2), RestRules))) - { - foreach (bool l3 in YP.functor(Fact, Name, Arity)) - { - CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); - processCompilerDirectives(RestRules, State); - return; - } - } - } - { - object State = arg2; - Variable x1 = new Variable(); - Variable RestRules = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestRules))) - { - processCompilerDirectives(RestRules, State); - return; - } - } - } - - public static IEnumerable importPredicateList(object arg1, object arg2, object arg3) - { - { - object _State = arg1; - object _Module = arg2; - foreach (bool l2 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - { - object State = arg1; - object Module = arg2; - Variable Name = new Variable(); - Variable Arity = new Variable(); - Variable Rest = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"/", Name, Arity), Rest))) - { - CompilerState.assertModuleForNameArity(State, Name, Arity, Module); - foreach (bool l3 in importPredicateList(State, Module, Rest)) - { - yield return true; - yield break; - } - } - } - { - object State = arg1; - object Module = arg2; - Variable x3 = new Variable(); - Variable Rest = new Variable(); - foreach (bool l2 in YP.unify(arg3, new ListPair(x3, Rest))) - { - foreach (bool l3 in importPredicateList(State, Module, Rest)) - { - yield return true; - yield break; - } - } - } - } - - public static IEnumerable makeFunctionPseudoCode3(object RuleList, object State, object FunctionCode) - { - { - Variable SamePredicateRuleList = new Variable(); - Variable RestRules = new Variable(); - foreach (bool l2 in samePredicateRuleList(RuleList, SamePredicateRuleList, RestRules)) - { - if (YP.termNotEqual(SamePredicateRuleList, Atom.NIL)) - { - foreach (bool l4 in compileSamePredicateFunction(SamePredicateRuleList, State, FunctionCode)) - { - yield return false; - } - foreach (bool l4 in makeFunctionPseudoCode3(RestRules, State, FunctionCode)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable compileSamePredicateFunction(object SamePredicateRuleList, object State, object FunctionCode) - { - { - Variable FirstRule = new Variable(); - Variable x5 = new Variable(); - Variable x6 = new Variable(); - Variable x7 = new Variable(); - Variable Head = new Variable(); - Variable x9 = new Variable(); - Variable ArgAssignments = new Variable(); - Variable Calls = new Variable(); - Variable Rule = new Variable(); - Variable VariableNameSuggestions = new Variable(); - Variable ClauseBag = new Variable(); - Variable Name = new Variable(); - Variable ArgsList = new Variable(); - Variable FunctionArgNames = new Variable(); - Variable MergedArgName = new Variable(); - Variable ArgName = new Variable(); - Variable MergedArgNames = new Variable(); - Variable FunctionArgs = new Variable(); - Variable BodyCode = new Variable(); - Variable ReturnType = new Variable(); - Variable BodyWithReturn = new Variable(); - foreach (bool l2 in YP.unify(new ListPair(new Functor2(@"f", FirstRule, x5), x6), SamePredicateRuleList)) - { - foreach (bool l3 in YP.unify(FirstRule, new Functor1(@":-", x7))) - { - goto cutIf1; - } - foreach (bool l3 in YP.unify(new Functor2(@":-", Head, x9), FirstRule)) - { - CompilerState.startFunction(State, Head); - FindallAnswers findallAnswers3 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); - foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) - { - foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) - { - findallAnswers3.add(); - } - } - foreach (bool l4 in findallAnswers3.result(ClauseBag)) - { - foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) - { - foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) - { - FindallAnswers findallAnswers4 = new FindallAnswers(MergedArgName); - foreach (bool l7 in member(ArgName, FunctionArgNames)) - { - foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) - { - findallAnswers4.add(); - goto cutIf5; - } - foreach (bool l8 in YP.unify(MergedArgName, ArgName)) - { - findallAnswers4.add(); - } - cutIf5: - { } - } - foreach (bool l7 in findallAnswers4.result(MergedArgNames)) - { - foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) - { - foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) - { - if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) - { - foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf7; - } - foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf7: - { } - } - goto cutIf6; - } - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf9; - } - foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf9: - { } - } - goto cutIf8; - } - foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf10; - } - foreach (bool l11 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf10: - { } - } - cutIf8: - cutIf6: - { } - } - } - } - } - } - } - goto cutIf2; - } - foreach (bool l3 in YP.unify(Head, FirstRule)) - { - CompilerState.startFunction(State, Head); - FindallAnswers findallAnswers11 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); - foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) - { - foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) - { - findallAnswers11.add(); - } - } - foreach (bool l4 in findallAnswers11.result(ClauseBag)) - { - foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) - { - foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) - { - FindallAnswers findallAnswers12 = new FindallAnswers(MergedArgName); - foreach (bool l7 in member(ArgName, FunctionArgNames)) - { - foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) - { - findallAnswers12.add(); - goto cutIf13; - } - foreach (bool l8 in YP.unify(MergedArgName, ArgName)) - { - findallAnswers12.add(); - } - cutIf13: - { } - } - foreach (bool l7 in findallAnswers12.result(MergedArgNames)) - { - foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) - { - foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) - { - if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) - { - foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf15; - } - foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf15: - { } - } - goto cutIf14; - } - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf17; - } - foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf17: - { } - } - goto cutIf16; - } - foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) - { - foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - goto cutIf18; - } - foreach (bool l11 in YP.unify(BodyWithReturn, BodyCode)) - { - foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) - { - yield return false; - } - } - cutIf18: - { } - } - cutIf16: - cutIf14: - { } - } - } - } - } - } - } - } - cutIf2: - cutIf1: - { } - } - } - } - - public static IEnumerable samePredicateRuleList(object arg1, object arg2, object arg3) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - foreach (bool l4 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - } - { - Variable First = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(First, Atom.NIL))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(First, Atom.NIL))) - { - foreach (bool l4 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - } - { - object SamePredicateRuleList = arg2; - object RestRules = arg3; - Variable First = new Variable(); - Variable Rest = new Variable(); - Variable FirstRule = new Variable(); - Variable x6 = new Variable(); - Variable SecondRule = new Variable(); - Variable x8 = new Variable(); - Variable x9 = new Variable(); - Variable FirstHead = new Variable(); - Variable x11 = new Variable(); - Variable SecondHead = new Variable(); - Variable x13 = new Variable(); - Variable Name = new Variable(); - Variable Arity = new Variable(); - Variable RestSamePredicates = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) - { - foreach (bool l3 in YP.unify(new Functor2(@"f", FirstRule, x6), First)) - { - foreach (bool l4 in YP.unify(new ListPair(new Functor2(@"f", SecondRule, x8), x9), Rest)) - { - foreach (bool l5 in YP.unify(new Functor2(@":-", FirstHead, x11), FirstRule)) - { - foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) - { - foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) - { - foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) - { - foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) - { - foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) - { - yield return true; - yield break; - } - } - goto cutIf3; - } - foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) - { - foreach (bool l9 in YP.unify(RestRules, Rest)) - { - yield return true; - yield break; - } - } - cutIf3: - { } - } - goto cutIf2; - } - foreach (bool l6 in YP.unify(SecondHead, SecondRule)) - { - foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) - { - foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) - { - foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) - { - foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) - { - yield return true; - yield break; - } - } - goto cutIf4; - } - foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) - { - foreach (bool l9 in YP.unify(RestRules, Rest)) - { - yield return true; - yield break; - } - } - cutIf4: - { } - } - } - cutIf2: - goto cutIf1; - } - foreach (bool l5 in YP.unify(FirstHead, FirstRule)) - { - foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) - { - foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) - { - foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) - { - foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) - { - foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) - { - yield return true; - yield break; - } - } - goto cutIf6; - } - foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) - { - foreach (bool l9 in YP.unify(RestRules, Rest)) - { - yield return true; - yield break; - } - } - cutIf6: - { } - } - goto cutIf5; - } - foreach (bool l6 in YP.unify(SecondHead, SecondRule)) - { - foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) - { - foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) - { - foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) - { - foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) - { - yield return true; - yield break; - } - } - goto cutIf7; - } - foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) - { - foreach (bool l9 in YP.unify(RestRules, Rest)) - { - yield return true; - yield break; - } - } - cutIf7: - { } - } - } - cutIf5: - { } - } - cutIf1: - { } - } - } - } - } - } - - public static IEnumerable maplist_compileClause(object arg1, object arg2, object arg3) - { - { - object _MergedArgNames = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - object MergedArgNames = arg2; - Variable ArgAssignments = new Variable(); - Variable Calls = new Variable(); - Variable Rest = new Variable(); - Variable ClauseCode = new Variable(); - Variable RestResults = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", ArgAssignments, Calls), Rest))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"blockScope", ClauseCode), RestResults))) - { - foreach (bool l4 in prependArgAssignments(ArgAssignments, Calls, MergedArgNames, ClauseCode)) - { - foreach (bool l5 in maplist_compileClause(Rest, MergedArgNames, RestResults)) - { - yield return true; - yield break; - } - } - } - } - } - } - - public static IEnumerable prependArgAssignments(object arg1, object arg2, object arg3, object arg4) - { - { - object _MergedArgNames = arg3; - Variable In = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, In)) - { - foreach (bool l4 in YP.unify(arg4, In)) - { - yield return true; - yield break; - } - } - } - } - { - object In = arg2; - object MergedArgNames = arg3; - object ClauseCode = arg4; - Variable VariableName = new Variable(); - Variable ArgName = new Variable(); - Variable RestArgAssignments = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", VariableName, ArgName), RestArgAssignments))) - { - foreach (bool l3 in member(VariableName, MergedArgNames)) - { - foreach (bool l4 in prependArgAssignments(RestArgAssignments, In, MergedArgNames, ClauseCode)) - { - yield return true; - yield break; - } - goto cutIf1; - } - foreach (bool l3 in prependArgAssignments(RestArgAssignments, new ListPair(new Functor3(@"declare", Atom.a(@"object"), VariableName, new Functor1(@"var", ArgName)), In), MergedArgNames, ClauseCode)) - { - yield return true; - yield break; - } - cutIf1: - { } - } - } - } - - public static IEnumerable argAssignedAll(object arg1, object arg2, object VariableName) - { - { - object _ArgName = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.NIL)) - { - if (YP.nonvar(VariableName)) - { - yield return true; - yield break; - } - } - } - { - object ArgName = arg1; - Variable ArgAssignments = new Variable(); - Variable _Calls = new Variable(); - Variable RestClauseBag = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(new Functor2(@"f", ArgAssignments, _Calls), RestClauseBag))) - { - foreach (bool l3 in member(new Functor2(@"f", VariableName, ArgName), ArgAssignments)) - { - foreach (bool l4 in argAssignedAll(ArgName, RestClauseBag, VariableName)) - { - yield return false; - } - } - } - } - } - - public static IEnumerable maplist_arg(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - Variable First = new Variable(); - Variable Rest = new Variable(); - Variable RestResults = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"arg", First), RestResults))) - { - foreach (bool l4 in maplist_arg(Rest, RestResults)) - { - yield return true; - yield break; - } - } - } - } - } - - public static IEnumerable getFunctionArgNames(object arg1, object arg2, object arg3) - { - { - object _StartArgNumber = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - object StartArgNumber = arg2; - Variable x1 = new Variable(); - Variable Rest = new Variable(); - Variable ArgName = new Variable(); - Variable RestFunctionArgs = new Variable(); - Variable NumberCodes = new Variable(); - Variable NumberAtom = new Variable(); - Variable NextArgNumber = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Rest))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(ArgName, RestFunctionArgs))) - { - foreach (bool l4 in YP.number_codes(StartArgNumber, NumberCodes)) - { - foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) - { - foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) - { - foreach (bool l7 in YP.unify(NextArgNumber, YP.add(StartArgNumber, 1))) - { - foreach (bool l8 in getFunctionArgNames(Rest, NextArgNumber, RestFunctionArgs)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - } - - public static IEnumerable compileBodyWithHeadBindings(object Rule, object VariableNameSuggestions, object State, object ArgAssignments, object Calls) - { - { - Variable Head = new Variable(); - Variable Body = new Variable(); - Variable x8 = new Variable(); - Variable HeadArgs = new Variable(); - Variable CompiledHeadArgs = new Variable(); - Variable BodyCode = new Variable(); - Variable VariableNamesList = new Variable(); - Variable ArgUnifications = new Variable(); - foreach (bool l2 in YP.unify(new Functor2(@":-", Head, Body), Rule)) - { - CompilerState.newVariableNames(State, Rule, VariableNameSuggestions); - foreach (bool l3 in YP.univ(Head, new ListPair(x8, HeadArgs))) - { - foreach (bool l4 in maplist_compileTerm(HeadArgs, State, CompiledHeadArgs)) - { - foreach (bool l5 in compileRuleBody(Body, State, BodyCode)) - { - foreach (bool l6 in CompilerState.variableNamesList(State, VariableNamesList)) - { - foreach (bool l7 in compileArgUnifications(HeadArgs, CompiledHeadArgs, 1, HeadArgs, BodyCode, ArgUnifications)) - { - foreach (bool l8 in compileDeclarations(VariableNamesList, HeadArgs, Atom.NIL, ArgAssignments, ArgUnifications, Calls)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - { - foreach (bool l2 in compileBodyWithHeadBindings(new Functor2(@":-", Rule, Atom.a(@"true")), VariableNameSuggestions, State, ArgAssignments, Calls)) - { - yield return true; - yield break; - } - } - } - - public static IEnumerable compileArgUnifications(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) - { - { - object x1 = arg2; - object x2 = arg3; - object x3 = arg4; - Variable BodyCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg5, BodyCode)) - { - foreach (bool l4 in YP.unify(arg6, BodyCode)) - { - yield return true; - yield break; - } - } - } - } - { - object Index = arg3; - object AllHeadArgs = arg4; - object BodyCode = arg5; - object ArgUnifications = arg6; - Variable HeadArg = new Variable(); - Variable RestHeadArgs = new Variable(); - Variable x3 = new Variable(); - Variable RestCompiledHeadArgs = new Variable(); - Variable _ArgIndex1 = new Variable(); - Variable NextIndex = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(HeadArg, RestHeadArgs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(x3, RestCompiledHeadArgs))) - { - foreach (bool l4 in getVariableArgIndex1(HeadArg, AllHeadArgs, _ArgIndex1)) - { - foreach (bool l5 in YP.unify(NextIndex, YP.add(Index, 1))) - { - foreach (bool l6 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, ArgUnifications)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object Index = arg3; - object AllHeadArgs = arg4; - object BodyCode = arg5; - Variable _HeadArg = new Variable(); - Variable RestHeadArgs = new Variable(); - Variable CompiledHeadArg = new Variable(); - Variable RestCompiledHeadArgs = new Variable(); - Variable ArgName = new Variable(); - Variable RestArgUnifications = new Variable(); - Variable NumberCodes = new Variable(); - Variable NumberAtom = new Variable(); - Variable NextIndex = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(_HeadArg, RestHeadArgs))) - { - foreach (bool l3 in YP.unify(arg2, new ListPair(CompiledHeadArg, RestCompiledHeadArgs))) - { - foreach (bool l4 in YP.unify(arg6, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(new Functor1(@"var", ArgName), new ListPair(CompiledHeadArg, Atom.NIL))), RestArgUnifications), Atom.NIL))) - { - foreach (bool l5 in YP.number_codes(Index, NumberCodes)) - { - foreach (bool l6 in YP.atom_codes(NumberAtom, NumberCodes)) - { - foreach (bool l7 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) - { - foreach (bool l8 in YP.unify(NextIndex, YP.add(Index, 1))) - { - foreach (bool l9 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, RestArgUnifications)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - } - } - - public static IEnumerable compileDeclarations(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) - { - { - object _HeadArgs = arg2; - Variable ArgAssignmentsIn = new Variable(); - Variable DeclarationsIn = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, ArgAssignmentsIn)) - { - foreach (bool l4 in YP.unify(arg4, ArgAssignmentsIn)) - { - foreach (bool l5 in YP.unify(arg5, DeclarationsIn)) - { - foreach (bool l6 in YP.unify(arg6, DeclarationsIn)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object HeadArgs = arg2; - object ArgAssignmentsIn = arg3; - object ArgAssignmentsOut = arg4; - object DeclarationsIn = arg5; - object DeclarationsOut = arg6; - Variable VariableName = new Variable(); - Variable Var = new Variable(); - Variable RestVariableNames = new Variable(); - Variable ArgIndex1 = new Variable(); - Variable NumberCodes = new Variable(); - Variable NumberAtom = new Variable(); - Variable ArgName = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, Var), RestVariableNames))) - { - foreach (bool l3 in getVariableArgIndex1(Var, HeadArgs, ArgIndex1)) - { - foreach (bool l4 in YP.number_codes(ArgIndex1, NumberCodes)) - { - foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) - { - foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) - { - foreach (bool l7 in compileDeclarations(RestVariableNames, HeadArgs, new ListPair(new Functor2(@"f", VariableName, ArgName), ArgAssignmentsIn), ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - { - object HeadArgs = arg2; - object ArgAssignmentsIn = arg3; - object ArgAssignmentsOut = arg4; - object DeclarationsIn = arg5; - Variable VariableName = new Variable(); - Variable _Var = new Variable(); - Variable RestVariableNames = new Variable(); - Variable DeclarationsOut = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, _Var), RestVariableNames))) - { - foreach (bool l3 in YP.unify(arg6, new ListPair(new Functor3(@"declare", Atom.a(@"Variable"), VariableName, new Functor2(@"new", Atom.a(@"Variable"), Atom.NIL)), DeclarationsOut))) - { - foreach (bool l4 in compileDeclarations(RestVariableNames, HeadArgs, ArgAssignmentsIn, ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) - { - yield return true; - yield break; - } - } - } - } - } - - public static IEnumerable getVariableArgIndex1(object Var, object arg2, object arg3) - { - { - Variable FirstHeadArgs = new Variable(); - Variable RestHeadArgs = new Variable(); - Variable x4 = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(FirstHeadArgs, RestHeadArgs))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - if (sameVariable(Var, FirstHeadArgs)) - { - foreach (bool l5 in getVariableArgIndex1(Var, RestHeadArgs, x4)) - { - goto cutIf1; - } - yield return false; - cutIf1: - yield break; - } - } - } - } - { - object Index = arg3; - Variable x2 = new Variable(); - Variable RestHeadArgs = new Variable(); - Variable RestIndex = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(x2, RestHeadArgs))) - { - foreach (bool l3 in getVariableArgIndex1(Var, RestHeadArgs, RestIndex)) - { - foreach (bool l4 in YP.unify(Index, YP.add(1, RestIndex))) - { - yield return true; - yield break; - } - } - } - } - } - - public static IEnumerable compileRuleBody(object arg1, object arg2, object arg3) - { - { - object A = arg1; - object State = arg2; - object PseudoCode = arg3; - if (YP.var(A)) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), Atom.a(@"true")), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldtrue"), new ListPair(Atom.a(@"yieldbreak"), Atom.NIL)))) - { - yield return true; - yield break; - } - } - } - { - object _State = arg2; - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"$CUTIF", Name))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL))) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) - { - if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldfalse"), Atom.NIL))) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - if (YP.var(A)) - { - foreach (bool l4 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), B), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable T = new Variable(); - Variable B = new Variable(); - Variable C = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), B), C))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@"->", A, new Functor2(@",", T, C)), new Functor2(@",", B, C)), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - Variable C = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", A, B), C))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, C), new Functor2(@",", B, C)), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor1(@"not", ACode), BCode), Atom.NIL))) - { - if (CompilerState.isSemidetNoneOut(State, A)) - { - foreach (bool l5 in compileFunctorCall(A, State, ACode)) - { - foreach (bool l6 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"fail")), Atom.a(@"true")), B), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"once", A), B))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"true")), Atom.a(@"fail")), B), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable T = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"->", A, T), B))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), Atom.a(@"fail")), B), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - Variable C = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"\=", A, B), C))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"\+", new Functor2(@"=", A, B)), C), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable ACode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"!"), A))) - { - foreach (bool l3 in compileRuleBody(A, State, ACode)) - { - foreach (bool l4 in append(ACode, new ListPair(Atom.a(@"yieldbreak"), Atom.NIL), PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable Name = new Variable(); - Variable A = new Variable(); - Variable ACode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$CUTIF", Name), A))) - { - foreach (bool l3 in compileRuleBody(A, State, ACode)) - { - foreach (bool l4 in append(ACode, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL), PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg2; - Variable x1 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"fail"), x1))) - { - foreach (bool l3 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"true"), A))) - { - foreach (bool l3 in compileRuleBody(A, State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable Term = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable TermCode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"is", A, Term), B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(ACode, new ListPair(TermCode, Atom.NIL))), BCode), Atom.NIL))) - { - foreach (bool l4 in compileTerm(A, State, ACode)) - { - foreach (bool l5 in compileExpression(Term, State, TermCode)) - { - foreach (bool l6 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) - { - if (CompilerState.isDetNoneOut(State, A)) - { - foreach (bool l5 in compileFunctorCall(A, State, ACode)) - { - foreach (bool l6 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", ACode, BCode), Atom.NIL))) - { - if (CompilerState.isSemidetNoneOut(State, A)) - { - foreach (bool l5 in compileFunctorCall(A, State, ACode)) - { - foreach (bool l6 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - { - object State = arg2; - Variable ACode = new Variable(); - Variable B = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", ACode), B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) - { - foreach (bool l4 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable FunctionName = new Variable(); - Variable X1Code = new Variable(); - Variable X2Code = new Variable(); - Variable BCode = new Variable(); - Variable Name = new Variable(); - Variable X1 = new Variable(); - Variable X2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor2(@"call", FunctionName, new ListPair(X1Code, new ListPair(X2Code, Atom.NIL))), BCode), Atom.NIL))) - { - foreach (bool l4 in YP.univ(A, new ListPair(Name, new ListPair(X1, new ListPair(X2, Atom.NIL))))) - { - foreach (bool l5 in binaryExpressionConditional(Name, FunctionName)) - { - foreach (bool l6 in compileExpression(X1, State, X1Code)) - { - foreach (bool l7 in compileExpression(X2, State, X2Code)) - { - foreach (bool l8 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - Variable C = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@",", A, B), C))) - { - foreach (bool l3 in compileRuleBody(new Functor2(@",", A, new Functor2(@",", B, C)), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable Template = new Variable(); - Variable Goal = new Variable(); - Variable Bag = new Variable(); - Variable B = new Variable(); - Variable TemplateCode = new Variable(); - Variable FindallAnswers = new Variable(); - Variable GoalAndAddCode = new Variable(); - Variable BagCode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"findall", Template, Goal, Bag), B))) - { - foreach (bool l3 in compileTerm(Template, State, TemplateCode)) - { - foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"findallAnswers"), FindallAnswers)) - { - foreach (bool l5 in compileRuleBody(new Functor2(@",", Goal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) - { - foreach (bool l6 in compileTerm(Bag, State, BagCode)) - { - foreach (bool l7 in compileRuleBody(B, State, BCode)) - { - foreach (bool l8 in append(new ListPair(new Functor3(@"declare", Atom.a(@"FindallAnswers"), FindallAnswers, new Functor2(@"new", Atom.a(@"FindallAnswers"), new ListPair(TemplateCode, Atom.NIL))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"result"), new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable Template = new Variable(); - Variable Goal = new Variable(); - Variable Bag = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"bagof", Template, Goal, Bag), B))) - { - foreach (bool l3 in compileBagof(Atom.a(@"result"), Template, Goal, Bag, B, State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable Template = new Variable(); - Variable Goal = new Variable(); - Variable Bag = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"setof", Template, Goal, Bag), B))) - { - foreach (bool l3 in compileBagof(Atom.a(@"resultSet"), Template, Goal, Bag, B, State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ATermCode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"call", A), B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL))) - { - foreach (bool l4 in compileTerm(A, State, ATermCode)) - { - foreach (bool l5 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", ACode, BCode), Atom.NIL))) - { - foreach (bool l4 in compileFunctorCall(A, State, ACode)) - { - foreach (bool l5 in compileRuleBody(B, State, BCode)) - { - yield return true; - yield break; - } - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) - { - if (YP.var(A)) - { - foreach (bool l4 in compileRuleBody(new Functor2(@";", new Functor1(@"call", A), B), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg2; - Variable A = new Variable(); - Variable T = new Variable(); - Variable B = new Variable(); - Variable CutIfLabel = new Variable(); - Variable Code = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@";", new Functor2(@"->", A, T), B))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"breakableBlock", CutIfLabel, Code), Atom.NIL))) - { - foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"cutIf"), CutIfLabel)) - { - foreach (bool l5 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, new Functor2(@",", new Functor1(@"$CUTIF", CutIfLabel), T)), B), State, Code)) - { - yield return true; - yield break; - } - } - } - } - } - { - object State = arg2; - object PseudoCode = arg3; - Variable A = new Variable(); - Variable B = new Variable(); - Variable ACode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) - { - foreach (bool l3 in compileRuleBody(A, State, ACode)) - { - foreach (bool l4 in compileRuleBody(B, State, BCode)) - { - foreach (bool l5 in append(ACode, BCode, PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - } - { - object A = arg1; - object State = arg2; - object PseudoCode = arg3; - foreach (bool l2 in compileRuleBody(new Functor2(@",", A, Atom.a(@"true")), State, PseudoCode)) - { - yield return true; - yield break; - } - } - } - - public static IEnumerable compileBagof(object ResultMethod, object Template, object Goal, object Bag, object B, object State, object PseudoCode) - { - { - Variable TemplateCode = new Variable(); - Variable GoalTermCode = new Variable(); - Variable UnqualifiedGoal = new Variable(); - Variable BagofAnswers = new Variable(); - Variable GoalAndAddCode = new Variable(); - Variable BagCode = new Variable(); - Variable BCode = new Variable(); - foreach (bool l2 in compileTerm(Template, State, TemplateCode)) - { - foreach (bool l3 in compileTerm(Goal, State, GoalTermCode)) - { - foreach (bool l4 in unqualifiedGoal(Goal, UnqualifiedGoal)) - { - foreach (bool l5 in CompilerState.gensym(State, Atom.a(@"bagofAnswers"), BagofAnswers)) - { - foreach (bool l6 in compileRuleBody(new Functor2(@",", UnqualifiedGoal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) - { - foreach (bool l7 in compileTerm(Bag, State, BagCode)) - { - foreach (bool l8 in compileRuleBody(B, State, BCode)) - { - foreach (bool l9 in append(new ListPair(new Functor3(@"declare", Atom.a(@"BagofAnswers"), BagofAnswers, new Functor2(@"new", Atom.a(@"BagofAnswers"), new ListPair(TemplateCode, new ListPair(GoalTermCode, Atom.NIL)))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), ResultMethod, new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - } - } - } - - public static IEnumerable unqualifiedGoal(object arg1, object arg2) - { - { - object Goal = arg1; - foreach (bool l2 in YP.unify(arg2, new Functor1(@"call", Goal))) - { - if (YP.var(Goal)) - { - yield return true; - yield break; - } - } - } - { - object UnqualifiedGoal = arg2; - Variable x1 = new Variable(); - Variable Goal = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"^", x1, Goal))) - { - foreach (bool l3 in unqualifiedGoal(Goal, UnqualifiedGoal)) - { - yield return true; - yield break; - } - } - } - { - Variable UnqualifiedGoal = new Variable(); - foreach (bool l2 in YP.unify(arg1, UnqualifiedGoal)) - { - foreach (bool l3 in YP.unify(arg2, UnqualifiedGoal)) - { - yield return true; - yield break; - } - } - } - } - - public static IEnumerable binaryExpressionConditional(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"=:="))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.equal"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"=\="))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.notEqual"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@">"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThan"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"<"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThan"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@">="))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThanOrEqual"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"=<"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThanOrEqual"))) - { - yield return true; - yield break; - } - } - } - } - - public static IEnumerable compileFunctorCall(object Functor_1, object State, object arg3) - { - { - Variable FunctionName = new Variable(); - Variable CompiledArgs = new Variable(); - Variable FunctorName = new Variable(); - Variable FunctorArgs = new Variable(); - Variable x7 = new Variable(); - Variable Arity = new Variable(); - foreach (bool l2 in YP.unify(arg3, new Functor2(@"call", FunctionName, CompiledArgs))) - { - foreach (bool l3 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs))) - { - foreach (bool l4 in YP.functor(Functor_1, x7, Arity)) - { - foreach (bool l5 in functorCallFunctionName(State, FunctorName, Arity, FunctionName)) - { - foreach (bool l6 in maplist_compileTerm(FunctorArgs, State, CompiledArgs)) - { - yield return true; - yield break; - } - } - } - } - } - } - } - - public static IEnumerable functorCallFunctionName(object arg1, object arg2, object arg3, object arg4) - { - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"="))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.unify"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"=.."))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.univ"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"var"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.var"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"nonvar"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.nonvar"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"arg"))) - { - foreach (bool l3 in YP.unify(arg3, 3)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.arg"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"functor"))) - { - foreach (bool l3 in YP.unify(arg3, 3)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.functor"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"repeat"))) - { - foreach (bool l3 in YP.unify(arg3, 0)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.repeat"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"get_code"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.get_code"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"current_op"))) - { - foreach (bool l3 in YP.unify(arg3, 3)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.current_op"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_length"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_length"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_concat"))) - { - foreach (bool l3 in YP.unify(arg3, 3)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_concat"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"sub_atom"))) - { - foreach (bool l3 in YP.unify(arg3, 5)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.sub_atom"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_codes"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_codes"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"number_codes"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.number_codes"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"copy_term"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.copy_term"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"sort"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.sort"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"script_event"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.script_event"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"nl"))) - { - foreach (bool l3 in YP.unify(arg3, 0)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.nl"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"write"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.write"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"put_code"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.put_code"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"number"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.number"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"=="))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termEqual"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"\=="))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termNotEqual"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"@<"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termLessThan"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"@=<"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termLessThanOrEqual"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"@>"))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termGreaterThan"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"@>="))) - { - foreach (bool l3 in YP.unify(arg3, 2)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termGreaterThanOrEqual"))) - { - yield return true; - yield break; - } - } - } - } - { - object x1 = arg1; - foreach (bool l2 in YP.unify(arg2, Atom.a(@"throw"))) - { - foreach (bool l3 in YP.unify(arg3, 1)) - { - foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.throwException"))) - { - yield return true; - yield break; - } - } - } - } - { - object State = arg1; - object Arity = arg3; - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg2, Name)) - { - foreach (bool l3 in YP.unify(arg4, Name)) - { - if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg1; - object _Arity = arg3; - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg2, Name)) - { - foreach (bool l3 in YP.unify(arg4, Name)) - { - foreach (bool l4 in Atom.module(Name, Atom.a(@""))) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg1; - object Name = arg2; - object Arity = arg3; - object x4 = arg4; - foreach (bool l2 in Atom.module(Name, Atom.NIL)) - { - YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Atom.a(@"Calls to dynamic predicates not supported"))); - yield return true; - yield break; - } - } - { - object _State = arg1; - object Name = arg2; - object Arity = arg3; - object x4 = arg4; - Variable Module = new Variable(); - Variable Message = new Variable(); - foreach (bool l2 in Atom.module(Name, Module)) - { - foreach (bool l3 in Atom.module(Name, Atom.NIL)) - { - foreach (bool l4 in YP.atom_concat(Atom.a(@"Not supporting calls to external module: "), Module, Message)) - { - YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Message)); - yield return true; - yield break; - } - } - } - } - } - - public static IEnumerable compileTerm(object arg1, object arg2, object arg3) - { - { - object Term = arg1; - object State = arg2; - Variable VariableName = new Variable(); - foreach (bool l2 in YP.unify(arg3, new Functor1(@"var", VariableName))) - { - if (YP.var(Term)) - { - foreach (bool l4 in CompilerState.getVariableName(State, Term, VariableName)) - { - yield return true; - yield break; - } - } - } - } - { - object _State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, new Functor1(@"var", Atom.a(@"Atom.NIL")))) - { - yield return true; - yield break; - } - } - } - { - object Term = arg1; - object State = arg2; - object Code = arg3; - Variable ModuleCode = new Variable(); - if (YP.atom(Term)) - { - foreach (bool l3 in compileAtomModule(Term, 0, State, ModuleCode)) - { - foreach (bool l4 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), new ListPair(ModuleCode, Atom.NIL))))) - { - yield return true; - yield break; - } - goto cutIf1; - } - foreach (bool l3 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), Atom.NIL)))) - { - yield return true; - yield break; - } - cutIf1: - { } - } - } - { - object State = arg2; - Variable First = new Variable(); - Variable Rest = new Variable(); - Variable Arg1 = new Variable(); - Variable Arg2 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) - { - foreach (bool l3 in YP.unify(arg3, new Functor2(@"new", Atom.a(@"ListPair"), new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) - { - foreach (bool l4 in compileTerm(First, State, Arg1)) - { - foreach (bool l5 in compileTerm(Rest, State, Arg2)) - { - yield return true; - yield break; - } - } - } - } - } - { - object Term = arg1; - object State = arg2; - object Result = arg3; - Variable Name = new Variable(); - Variable TermArgs = new Variable(); - Variable x6 = new Variable(); - Variable Arity = new Variable(); - Variable ModuleCode = new Variable(); - Variable NameCode = new Variable(); - Variable X1 = new Variable(); - Variable Arg1 = new Variable(); - Variable X2 = new Variable(); - Variable Arg2 = new Variable(); - Variable X3 = new Variable(); - Variable Arg3 = new Variable(); - Variable Args = new Variable(); - foreach (bool l2 in YP.univ(Term, new ListPair(Name, TermArgs))) - { - if (YP.termEqual(TermArgs, Atom.NIL)) - { - foreach (bool l4 in YP.unify(Result, new Functor1(@"object", Name))) - { - yield return true; - yield break; - } - goto cutIf2; - } - foreach (bool l3 in YP.functor(Term, x6, Arity)) - { - foreach (bool l4 in compileAtomModule(Name, Arity, State, ModuleCode)) - { - foreach (bool l5 in YP.unify(NameCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Name), new ListPair(ModuleCode, Atom.NIL))))) - { - foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) - { - foreach (bool l7 in compileTerm(X1, State, Arg1)) - { - foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) - { - yield return true; - yield break; - } - } - goto cutIf4; - } - foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) - { - foreach (bool l7 in compileTerm(X1, State, Arg1)) - { - foreach (bool l8 in compileTerm(X2, State, Arg2)) - { - foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) - { - yield return true; - yield break; - } - } - } - goto cutIf5; - } - foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) - { - foreach (bool l7 in compileTerm(X1, State, Arg1)) - { - foreach (bool l8 in compileTerm(X2, State, Arg2)) - { - foreach (bool l9 in compileTerm(X3, State, Arg3)) - { - foreach (bool l10 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) - { - yield return true; - yield break; - } - } - } - } - } - foreach (bool l6 in maplist_compileTerm(TermArgs, State, Args)) - { - foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) - { - yield return true; - yield break; - } - } - cutIf5: - cutIf4: - { } - } - goto cutIf3; - } - foreach (bool l4 in YP.unify(NameCode, new Functor1(@"object", Name))) - { - foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) - { - foreach (bool l6 in compileTerm(X1, State, Arg1)) - { - foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) - { - yield return true; - yield break; - } - } - goto cutIf6; - } - foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) - { - foreach (bool l6 in compileTerm(X1, State, Arg1)) - { - foreach (bool l7 in compileTerm(X2, State, Arg2)) - { - foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) - { - yield return true; - yield break; - } - } - } - goto cutIf7; - } - foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) - { - foreach (bool l6 in compileTerm(X1, State, Arg1)) - { - foreach (bool l7 in compileTerm(X2, State, Arg2)) - { - foreach (bool l8 in compileTerm(X3, State, Arg3)) - { - foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) - { - yield return true; - yield break; - } - } - } - } - } - foreach (bool l5 in maplist_compileTerm(TermArgs, State, Args)) - { - foreach (bool l6 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) - { - yield return true; - yield break; - } - } - cutIf7: - cutIf6: - { } - } - cutIf3: - { } - } - cutIf2: - { } - } - } - } - - public static IEnumerable compileAtomModule(object Name, object Arity, object State, object ModuleCode) - { - { - if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) - { - foreach (bool l3 in YP.unify(ModuleCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Atom.a(@"")), Atom.NIL)))) - { - yield return true; - yield break; - } - } - } - } - - public static IEnumerable maplist_compileTerm(object arg1, object arg2, object arg3) - { - { - object _State = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg3, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - { - object State = arg2; - Variable First = new Variable(); - Variable Rest = new Variable(); - Variable FirstResult = new Variable(); - Variable RestResults = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(FirstResult, RestResults))) - { - foreach (bool l4 in compileTerm(First, State, FirstResult)) - { - foreach (bool l5 in maplist_compileTerm(Rest, State, RestResults)) - { - yield return true; - yield break; - } - } - } - } - } - } - - public static IEnumerable compileExpression(object Term, object State, object Result) - { - { - Variable Name = new Variable(); - Variable TermArgs = new Variable(); - Variable X1 = new Variable(); - Variable FunctionName = new Variable(); - Variable Arg1 = new Variable(); - Variable x9 = new Variable(); - Variable X2 = new Variable(); - Variable Arg2 = new Variable(); - if (YP.nonvar(Term)) - { - foreach (bool l3 in YP.univ(Term, new ListPair(Name, TermArgs))) - { - if (YP.atom(Name)) - { - foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) - { - foreach (bool l6 in unaryFunction(Name, FunctionName)) - { - foreach (bool l7 in compileExpression(X1, State, Arg1)) - { - foreach (bool l8 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, Atom.NIL)))) - { - yield return true; - yield break; - } - } - goto cutIf1; - } - } - foreach (bool l5 in YP.unify(Term, new ListPair(x9, Atom.NIL))) - { - foreach (bool l6 in compileTerm(Term, State, Result)) - { - yield return true; - yield break; - } - goto cutIf2; - } - foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) - { - foreach (bool l6 in binaryFunction(Name, FunctionName)) - { - foreach (bool l7 in compileExpression(X1, State, Arg1)) - { - foreach (bool l8 in compileExpression(X2, State, Arg2)) - { - foreach (bool l9 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) - { - yield return true; - yield break; - } - } - } - goto cutIf3; - } - } - YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"evaluable"), Name), Atom.a(@"Not an expression function"))); - yield return false; - cutIf3: - cutIf2: - cutIf1: - { } - } - } - } - } - { - foreach (bool l2 in compileTerm(Term, State, Result)) - { - yield return true; - yield break; - } - } - } - - public static IEnumerable unaryFunction(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.negate"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"abs"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.abs"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"sign"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sign"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.floor"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"truncate"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.truncate"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"round"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.round"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.ceiling"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"sin"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sin"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"cos"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.cos"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"atan"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.atan"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"exp"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.exp"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"log"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.log"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"sqrt"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sqrt"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"\"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseComplement"))) - { - yield return true; - yield break; - } - } - } - } - - public static IEnumerable binaryFunction(object arg1, object arg2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"+"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.add"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.subtract"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"*"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.multiply"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"/"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.divide"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"//"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.intDivide"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"mod"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.mod"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"**"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.pow"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@">>"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftRight"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"<<"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftLeft"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"/\"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseAnd"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"\/"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseOr"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"min"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.min"))) - { - yield return true; - yield break; - } - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"max"))) - { - foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.max"))) - { - yield return true; - yield break; - } - } - } - } - - public static void convertFunctionCSharp(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) - { - YP.write(Atom.a(@"class YPInnerClass {}")); - YP.nl(); - YP.write(Atom.a(@"static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }")); - YP.nl(); - YP.nl(); - return; - } - } - { - Variable ReturnType = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable Body = new Variable(); - Variable Level = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { ReturnType, Name, ArgList, Body }))) - { - YP.write(Atom.a(@"public static ")); - YP.write(ReturnType); - YP.write(Atom.a(@" ")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@") {")); - YP.nl(); - foreach (bool l3 in YP.unify(Level, 1)) - { - convertStatementListCSharp(Body, Level); - YP.write(Atom.a(@"}")); - YP.nl(); - YP.nl(); - return; - } - } - } - } - - public static IEnumerable convertStatementListCSharp(object arg1, object x1, object x2) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - yield return true; - yield break; - } - } - } - - public static void convertStatementListCSharp(object arg1, object Level) - { - { - Variable Name = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NewStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) - { - foreach (bool l3 in append(Body, new ListPair(new Functor1(@"label", Name), RestStatements), NewStatements)) - { - convertStatementListCSharp(NewStatements, Level); - return; - } - } - } - { - Variable Type = new Variable(); - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", Type, Name, Expression), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Type); - YP.write(Atom.a(@" ")); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionCSharp(Expression); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionCSharp(Expression); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"yield return true;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"yield return false;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"yield break;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"return;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"return true;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"return false;")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable Name = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"label", Name), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Name); - YP.write(Atom.a(@":")); - YP.nl(); - if (YP.termEqual(RestStatements, Atom.NIL)) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"{}")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - goto cutIf1; - } - convertStatementListCSharp(RestStatements, Level); - return; - cutIf1: - { } - } - } - { - Variable Name = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"goto ")); - YP.write(Name); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@");")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@");")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - { - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"{")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListCSharp(Body, NextLevel); - convertIndentationCSharp(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - } - { - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"if (")); - convertExpressionCSharp(Expression); - YP.write(Atom.a(@") {")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListCSharp(Body, NextLevel); - convertIndentationCSharp(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - } - { - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) - { - convertIndentationCSharp(Level); - YP.write(Atom.a(@"foreach (bool l")); - YP.write(Level); - YP.write(Atom.a(@" in ")); - convertExpressionCSharp(Expression); - YP.write(Atom.a(@") {")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListCSharp(Body, NextLevel); - convertIndentationCSharp(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListCSharp(RestStatements, Level); - return; - } - } - } - } - - public static void convertIndentationCSharp(object Level) - { - { - Variable N = new Variable(); - foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) - { - repeatWrite(Atom.a(@" "), N); - return; - } - } - } - - public static void convertArgListCSharp(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Head = new Variable(); - Variable Tail = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) - { - convertExpressionCSharp(Head); - if (YP.termNotEqual(Tail, Atom.NIL)) - { - YP.write(Atom.a(@", ")); - convertArgListCSharp(Tail); - return; - goto cutIf1; - } - convertArgListCSharp(Tail); - return; - cutIf1: - { } - } - } - } - - public static void convertExpressionCSharp(object arg1) - { - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) - { - YP.write(Atom.a(@"object ")); - YP.write(X); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) - { - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) - { - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) - { - YP.write(Atom.a(@"new ")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) - { - YP.write(Name); - return; - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) - { - YP.write(Atom.a(@"null")); - return; - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) - { - YP.write(Atom.a(@"!(")); - convertExpressionCSharp(X); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable X = new Variable(); - Variable Y = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) - { - YP.write(Atom.a(@"(")); - convertExpressionCSharp(X); - YP.write(Atom.a(@") && (")); - convertExpressionCSharp(Y); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) - { - YP.write(Atom.a(@"new object[] {")); - convertArgListCSharp(ArgList); - YP.write(Atom.a(@"}")); - return; - } - } - { - Variable X = new Variable(); - Variable Codes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - if (YP.atom(X)) - { - YP.write(Atom.a(@"@""")); - foreach (bool l4 in YP.atom_codes(X, Codes)) - { - convertStringCodesCSharp(Codes); - YP.write(Atom.a(@"""")); - return; - } - } - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - YP.write(X); - return; - } - } - } - - public static void convertStringCodesCSharp(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Code = new Variable(); - Variable RestCodes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) - { - if (YP.termEqual(Code, 34)) - { - YP.put_code(34); - YP.put_code(Code); - convertStringCodesCSharp(RestCodes); - return; - goto cutIf1; - } - YP.put_code(Code); - convertStringCodesCSharp(RestCodes); - return; - cutIf1: - { } - } - } - } - - public static void convertFunctionJavascript(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) - { - YP.write(Atom.a(@"function getDeclaringClass() { return null; }")); - YP.nl(); - return; - } - } - { - Variable x1 = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable Body = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) - { - YP.write(Atom.a(@"function ")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@") {")); - YP.nl(); - convertStatementListJavascript(Body, 1); - YP.write(Atom.a(@"}")); - YP.nl(); - YP.nl(); - return; - } - } - } - - public static void convertStatementListJavascript(object arg1, object arg2) - { - { - object x1 = arg2; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - object Level = arg2; - Variable Name = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Name); - YP.write(Atom.a(@":")); - YP.nl(); - convertIndentationJavascript(Level); - YP.write(Atom.a(@"{")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListJavascript(Body, NextLevel); - convertIndentationJavascript(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - } - { - object Level = arg2; - Variable _Type = new Variable(); - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"var ")); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionJavascript(Expression); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionJavascript(Expression); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"yield true;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"yield false;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"return;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"return;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"return true;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"return false;")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable Name = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"break ")); - YP.write(Name); - YP.write(Atom.a(@";")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@");")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@");")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - { - object Level = arg2; - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"{")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListJavascript(Body, NextLevel); - convertIndentationJavascript(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - } - { - object Level = arg2; - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"if (")); - convertExpressionJavascript(Expression); - YP.write(Atom.a(@") {")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListJavascript(Body, NextLevel); - convertIndentationJavascript(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - } - { - object Level = arg2; - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) - { - convertIndentationJavascript(Level); - YP.write(Atom.a(@"for each (var l")); - YP.write(Level); - YP.write(Atom.a(@" in ")); - convertExpressionJavascript(Expression); - YP.write(Atom.a(@") {")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - convertStatementListJavascript(Body, NextLevel); - convertIndentationJavascript(Level); - YP.write(Atom.a(@"}")); - YP.nl(); - convertStatementListJavascript(RestStatements, Level); - return; - } - } - } - } - - public static void convertIndentationJavascript(object Level) - { - { - Variable N = new Variable(); - foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) - { - repeatWrite(Atom.a(@" "), N); - return; - } - } - } - - public static void convertArgListJavascript(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Head = new Variable(); - Variable Tail = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) - { - convertExpressionJavascript(Head); - if (YP.termNotEqual(Tail, Atom.NIL)) - { - YP.write(Atom.a(@", ")); - convertArgListJavascript(Tail); - return; - goto cutIf1; - } - convertArgListJavascript(Tail); - return; - cutIf1: - { } - } - } - } - - public static void convertExpressionJavascript(object arg1) - { - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) - { - YP.write(X); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) - { - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) - { - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) - { - YP.write(Atom.a(@"new ")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) - { - YP.write(Name); - return; - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) - { - YP.write(Atom.a(@"null")); - return; - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) - { - YP.write(Atom.a(@"!(")); - convertExpressionJavascript(X); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable X = new Variable(); - Variable Y = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) - { - YP.write(Atom.a(@"(")); - convertExpressionJavascript(X); - YP.write(Atom.a(@") && (")); - convertExpressionJavascript(Y); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) - { - YP.write(Atom.a(@"[")); - convertArgListJavascript(ArgList); - YP.write(Atom.a(@"]")); - return; - } - } - { - Variable X = new Variable(); - Variable Codes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - if (YP.atom(X)) - { - YP.write(Atom.a(@"""")); - foreach (bool l4 in YP.atom_codes(X, Codes)) - { - convertStringCodesJavascript(Codes); - YP.write(Atom.a(@"""")); - return; - } - } - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - YP.write(X); - return; - } - } - } - - public static void convertStringCodesJavascript(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Code = new Variable(); - Variable RestCodes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) - { - if (YP.termEqual(Code, 34)) - { - YP.put_code(92); - YP.put_code(Code); - convertStringCodesJavascript(RestCodes); - return; - goto cutIf1; - } - if (YP.termEqual(Code, 92)) - { - YP.put_code(92); - YP.put_code(Code); - convertStringCodesJavascript(RestCodes); - return; - goto cutIf1; - } - YP.put_code(Code); - convertStringCodesJavascript(RestCodes); - return; - cutIf1: - { } - } - } - } - - public static void convertFunctionPython(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) - { - YP.write(Atom.a(@"def getDeclaringClass():")); - YP.nl(); - YP.write(Atom.a(@" return None")); - YP.nl(); - YP.nl(); - return; - } - } - { - Variable x1 = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable Body = new Variable(); - Variable Level = new Variable(); - Variable HasBreakableBlock = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) - { - YP.write(Atom.a(@"def ")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@"):")); - YP.nl(); - foreach (bool l3 in YP.unify(Level, 1)) - { - if (hasBreakableBlockPython(Body)) - { - foreach (bool l5 in YP.unify(HasBreakableBlock, 1)) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"doBreak = False")); - YP.nl(); - foreach (bool l7 in convertStatementListPython(Body, Level, HasBreakableBlock)) - { - YP.nl(); - return; - } - goto cutIf2; - } - foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) - { - YP.nl(); - return; - } - cutIf2: - { } - } - goto cutIf1; - } - foreach (bool l4 in YP.unify(HasBreakableBlock, 0)) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"doBreak = False")); - YP.nl(); - foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) - { - YP.nl(); - return; - } - goto cutIf3; - } - foreach (bool l5 in convertStatementListPython(Body, Level, HasBreakableBlock)) - { - YP.nl(); - return; - } - cutIf3: - { } - } - cutIf1: - { } - } - } - } - } - - public static bool hasBreakableBlockPython(object arg1) - { - { - Variable _Name = new Variable(); - Variable _Body = new Variable(); - Variable _RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", _Name, _Body), _RestStatements))) - { - return true; - } - } - { - Variable Body = new Variable(); - Variable _RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), _RestStatements))) - { - if (hasBreakableBlockPython(Body)) - { - return true; - } - } - } - { - Variable _Expression = new Variable(); - Variable Body = new Variable(); - Variable _RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", _Expression, Body), _RestStatements))) - { - if (hasBreakableBlockPython(Body)) - { - return true; - } - } - } - { - Variable _Expression = new Variable(); - Variable Body = new Variable(); - Variable _RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", _Expression, Body), _RestStatements))) - { - if (hasBreakableBlockPython(Body)) - { - return true; - } - } - } - { - Variable x1 = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestStatements))) - { - if (hasBreakableBlockPython(RestStatements)) - { - return true; - } - } - } - return false; - } - - public static IEnumerable convertStatementListPython(object arg1, object arg2, object arg3) - { - { - object x1 = arg2; - object x2 = arg3; - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - yield return true; - yield break; - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Name = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Name); - YP.write(Atom.a(@" = False")); - YP.nl(); - convertIndentationPython(Level); - YP.write(Atom.a(@"for _ in [1]:")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"if ")); - YP.write(Name); - YP.write(Atom.a(@":")); - YP.nl(); - convertIndentationPython(NextLevel); - YP.write(Atom.a(@"doBreak = False")); - YP.nl(); - convertIndentationPython(Level); - YP.write(Atom.a(@"if doBreak:")); - YP.nl(); - convertIndentationPython(NextLevel); - YP.write(Atom.a(@"break")); - YP.nl(); - foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable _Type = new Variable(); - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionPython(Expression); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Name = new Variable(); - Variable Expression = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Name); - YP.write(Atom.a(@" = ")); - convertExpressionPython(Expression); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"yield True")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"yield False")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"return")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"return")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"return True")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"return False")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Name = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Name); - YP.write(Atom.a(@" = True")); - YP.nl(); - convertIndentationPython(Level); - YP.write(Atom.a(@"doBreak = True")); - YP.nl(); - convertIndentationPython(Level); - YP.write(Atom.a(@"break")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@")")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - Variable RestStatements = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@")")); - YP.nl(); - foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"for _ in [1]:")); - YP.nl(); - foreach (bool l4 in YP.unify(NextLevel, YP.add(Level, 1))) - { - foreach (bool l5 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - if (YP.greaterThan(Level, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"if doBreak:")); - YP.nl(); - convertIndentationPython(NextLevel); - YP.write(Atom.a(@"break")); - YP.nl(); - foreach (bool l8 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - goto cutIf3; - } - foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - cutIf3: - goto cutIf2; - } - foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - cutIf2: - { } - } - } - goto cutIf1; - } - foreach (bool l3 in YP.unify(NextLevel, Level)) - { - foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - if (YP.greaterThan(Level, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"if doBreak:")); - YP.nl(); - convertIndentationPython(NextLevel); - YP.write(Atom.a(@"break")); - YP.nl(); - foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - goto cutIf5; - } - foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - cutIf5: - goto cutIf4; - } - foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - cutIf4: - { } - } - } - cutIf1: - { } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"if ")); - convertExpressionPython(Expression); - YP.write(Atom.a(@":")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) - { - foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - } - } - } - } - { - object Level = arg2; - object HasBreakableBlock = arg3; - Variable Expression = new Variable(); - Variable Body = new Variable(); - Variable RestStatements = new Variable(); - Variable NextLevel = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"for l")); - YP.write(Level); - YP.write(Atom.a(@" in ")); - convertExpressionPython(Expression); - YP.write(Atom.a(@":")); - YP.nl(); - foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) - { - foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) - { - if (YP.termEqual(HasBreakableBlock, 1)) - { - convertIndentationPython(Level); - YP.write(Atom.a(@"if doBreak:")); - YP.nl(); - convertIndentationPython(NextLevel); - YP.write(Atom.a(@"break")); - YP.nl(); - foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - goto cutIf6; - } - foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) - { - yield return true; - yield break; - } - cutIf6: - { } - } - } - } - } - } - - public static void convertIndentationPython(object Level) - { - { - Variable N = new Variable(); - foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) - { - repeatWrite(Atom.a(@" "), N); - return; - } - } - } - - public static void convertArgListPython(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Head = new Variable(); - Variable Tail = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) - { - convertExpressionPython(Head); - if (YP.termNotEqual(Tail, Atom.NIL)) - { - YP.write(Atom.a(@", ")); - convertArgListPython(Tail); - return; - goto cutIf1; - } - convertArgListPython(Tail); - return; - cutIf1: - { } - } - } - } - - public static void convertExpressionPython(object arg1) - { - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) - { - YP.write(X); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) - { - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Obj = new Variable(); - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) - { - YP.write(Obj); - YP.write(Atom.a(@".")); - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) - { - YP.write(Name); - YP.write(Atom.a(@"(")); - convertArgListPython(ArgList); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable Name = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) - { - YP.write(Name); - return; - } - } - { - foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) - { - YP.write(Atom.a(@"None")); - return; - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) - { - YP.write(Atom.a(@"not (")); - convertExpressionPython(X); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable X = new Variable(); - Variable Y = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) - { - YP.write(Atom.a(@"(")); - convertExpressionPython(X); - YP.write(Atom.a(@") and (")); - convertExpressionPython(Y); - YP.write(Atom.a(@")")); - return; - } - } - { - Variable ArgList = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) - { - YP.write(Atom.a(@"[")); - convertArgListPython(ArgList); - YP.write(Atom.a(@"]")); - return; - } - } - { - Variable X = new Variable(); - Variable Codes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - if (YP.atom(X)) - { - YP.write(Atom.a(@"""")); - foreach (bool l4 in YP.atom_codes(X, Codes)) - { - convertStringCodesPython(Codes); - YP.write(Atom.a(@"""")); - return; - } - } - } - } - { - Variable X = new Variable(); - foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) - { - YP.write(X); - return; - } - } - } - - public static void convertStringCodesPython(object arg1) - { - { - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - return; - } - } - { - Variable Code = new Variable(); - Variable RestCodes = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) - { - if (YP.termEqual(Code, 34)) - { - YP.put_code(92); - YP.put_code(Code); - convertStringCodesPython(RestCodes); - return; - goto cutIf1; - } - if (YP.termEqual(Code, 92)) - { - YP.put_code(92); - YP.put_code(Code); - convertStringCodesPython(RestCodes); - return; - goto cutIf1; - } - YP.put_code(Code); - convertStringCodesPython(RestCodes); - return; - cutIf1: - { } - } - } - } - - public static IEnumerable member(object X, object arg2) - { - { - Variable x2 = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(X, x2))) - { - yield return false; - } - } - { - Variable x2 = new Variable(); - Variable Rest = new Variable(); - foreach (bool l2 in YP.unify(arg2, new ListPair(x2, Rest))) - { - foreach (bool l3 in member(X, Rest)) - { - yield return false; - } - } - } - } - - public static IEnumerable append(object arg1, object arg2, object arg3) - { - { - Variable List = new Variable(); - foreach (bool l2 in YP.unify(arg1, Atom.NIL)) - { - foreach (bool l3 in YP.unify(arg2, List)) - { - foreach (bool l4 in YP.unify(arg3, List)) - { - yield return false; - } - } - } - } - { - object List2 = arg2; - Variable X = new Variable(); - Variable List1 = new Variable(); - Variable List12 = new Variable(); - foreach (bool l2 in YP.unify(arg1, new ListPair(X, List1))) - { - foreach (bool l3 in YP.unify(arg3, new ListPair(X, List12))) - { - foreach (bool l4 in append(List1, List2, List12)) - { - yield return false; - } - } - } - } - } - - } -} +/* + * 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.IO; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System.CodeDom.Compiler; + +namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog +{ + public class YPCompiler + { + private class CompilerState + { + public IndexedAnswers _pred = new IndexedAnswers(); + public Dictionary _moduleForNameArity = new Dictionary(); + public int _gensymCounter; + public bool _useFinalCutCode; + public Variable _finalCutCode; + public bool _codeUsesYield; + public Atom _determinism; + // a list of '='(Name, Variable) + public List _variableNames; + + // Make these static functions that explicitly take the State so Prolog can call it. + + /// + /// Make a new CompilerState and bind it to State. + /// + /// + /// + public static IEnumerable make(object State) + { + return YP.unify(State, new CompilerState()); + } + + public static void assertPred(object State, object Pred, object Determinism) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Pred); + object[] functorArgs = YP.getFunctorArgs(Pred); + // Debug: Should check if it's already asserted and is the same. + ((CompilerState)State)._pred.addAnswer + (new object[] { functorName, functorArgs.Length, Pred, YP.getValue(Determinism) }); + } + + public static void assertModuleForNameArity(object State, object Name, object Arity, object Module) + { + State = YP.getValue(State); + Name = YP.getValue(Name); + Arity = YP.getValue(Arity); + Module = YP.getValue(Module); + // If the Module Atom comes from the parser, it always has null _declaringClass. + if (Module is Atom && ((Atom)Module)._module == null && Name is Atom && Arity is int) + { + // Replace a previous entry if it exists. + ((CompilerState)State)._moduleForNameArity[new YP.NameArity((Atom)Name, (int)Arity)] = + (Atom)Module; + } + } + + public static void startFunction(object State, object Head) + { + State = YP.getValue(State); + ((CompilerState)State)._gensymCounter = 0; + ((CompilerState)State)._useFinalCutCode = false; + ((CompilerState)State)._finalCutCode = new Variable(); + ((CompilerState)State)._codeUsesYield = false; + if (CompilerState.isDetNoneOut(State, Head)) + ((CompilerState)State)._determinism = Atom.a("detNoneOut"); + else if (CompilerState.isSemidetNoneOut(State, Head)) + ((CompilerState)State)._determinism = Atom.a("semidetNoneOut"); + else + ((CompilerState)State)._determinism = Atom.a("nondet"); + } + + public static void setCodeUsesYield(object State) + { + State = YP.getValue(State); + ((CompilerState)State)._codeUsesYield = true; + } + + public static bool codeUsesYield(object State) + { + State = YP.getValue(State); + return ((CompilerState)State)._codeUsesYield; + } + + public static bool determinismEquals(object State, object Term) + { + State = YP.getValue(State); + return YP.termEqual(((CompilerState)State)._determinism, Term); + } + + /// + /// Set _variableNames to a new list of (Name = Variable) for each unique variable in rule. + /// If the variable is in variableNameSuggestions, use it, otherwise use x1, x2, etc. + /// + /// + /// + /// + public static void newVariableNames(object State, object Rule, object VariableNameSuggestions) + { + State = YP.getValue(State); + List variablesSet = new List(); + YP.addUniqueVariables(Rule, variablesSet); + + ((CompilerState)State)._variableNames = new List(); + int xCounter = 0; + foreach (Variable variable in variablesSet) + ((CompilerState)State)._variableNames.Add + (new Functor2(Atom.a("="), makeVariableName(variable, VariableNameSuggestions, ++xCounter), + variable)); + } + + private static object makeVariableName(object variable, object variableNameSuggestions, int xCounter) + { + // Debug: should require named variables to start with _ or capital. Should + // check for duplicates and clashes with keywords. + for (object element = YP.getValue(variableNameSuggestions); + element is Functor2 && ((Functor2)element)._name == Atom.DOT; + element = YP.getValue(((Functor2)element)._arg2)) + { + object suggestionPair = YP.getValue(((Functor2)element)._arg1); + if (sameVariable(variable, ((Functor2)suggestionPair)._arg2)) + { + Atom suggestion = (Atom)YP.getValue(((Functor2)suggestionPair)._arg1); + if (suggestion.Equals(Atom.a("Atom"))) + suggestion = Atom.a("Atom_1"); + if (suggestion.Equals(Atom.a("Variable"))) + suggestion = Atom.a("Variable_1"); + if (suggestion.Equals(Atom.a("Functor"))) + suggestion = Atom.a("Functor_1"); + return suggestion; + } + } + + return Atom.a("x" + xCounter); + } + + /// + /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames + /// for variable. + /// + /// a Variable + /// + /// the assigned Name + public static IEnumerable getVariableName(object State, object variable, object Result) + { + State = YP.getValue(State); + foreach (object variableInfo in ((CompilerState)State)._variableNames) + { + if (variableInfo is Functor2 && ((Functor2)variableInfo)._name.Equals(Atom.a("="))) + { + if (sameVariable(variable, ((Functor2)variableInfo)._arg2)) + return YP.unify(Result, ((Functor2)variableInfo)._arg1); + } + } + + // We set up names for all unique variables, so this should never happen. + throw new PrologException(Atom.a("Can't find entry in _variableNames")); + } + + public static IEnumerable variableNamesList(object State, object VariableNamesList) + { + State = YP.getValue(State); + return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames)); + } + + public static IEnumerable gensym(object State, object Base, object Symbol) + { + State = YP.getValue(State); + return YP.unify(Symbol, Atom.a(Base.ToString() + ++((CompilerState)State)._gensymCounter)); + } + + public static bool isDetNoneOut(object State, object Term) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Term); + object[] functorArgs = YP.getFunctorArgs(Term); + + Variable pred = new Variable(); + foreach (bool l1 in ((CompilerState)State)._pred.match + (new object[] { functorName, functorArgs.Length, pred, Atom.a("det") })) + { + if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) + { + return true; + } + } + + return false; + } + + public static bool isSemidetNoneOut(object State, object Term) + { + State = YP.getValue(State); + object functorName = YP.getFunctorName(Term); + object[] functorArgs = YP.getFunctorArgs(Term); + + Variable pred = new Variable(); + foreach (bool l1 in ((CompilerState)State)._pred.match + (new object[] { functorName, functorArgs.Length, pred, Atom.a("semidet") })) + { + if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) + { + return true; + } + } + + return false; + } + + /// + /// Return false if any of args is out, otherwise true. + /// args is an array of ::(Type,Mode) where Mode is in or out. + /// + /// + /// + private static bool isNoneOut(object[] args) + { + foreach (object arg in args) + { + if (arg is Functor2 && ((Functor2)arg)._name == Atom.a("::") && + ((Functor2)arg)._arg2 == Atom.a("out")) + return false; + } + return true; + } + + public static bool nameArityHasModule(object State, object Name, object Arity, object Module) + { + State = YP.getValue(State); + Name = YP.getValue(Name); + Arity = YP.getValue(Arity); + Module = YP.getValue(Module); + if (Name is Atom && Arity is int) + { + Atom FoundModule; + if (!((CompilerState)State)._moduleForNameArity.TryGetValue + (new YP.NameArity((Atom)Name, (int)Arity), out FoundModule)) + return false; + return FoundModule == Module; + } + return false; + } + } + + /// + /// Use CodeDomProvider to compile the functionCode and return a YP.IClause. + /// The function name must be "function" and have nArgs arguments. + /// + /// the code for the iterator, such as + /// "public static IEnumerable function() { yield return false; }" + /// + /// the number of args in the function + /// if not null, then use the functionCode inside a class which + /// inherits from contextClass, so that references in functionCode to methods in declaringClass don't + /// have to be qualified + /// a new YP.IClause object on which you can call match(object[] args) where + /// args length is nArgs + public static YP.IClause compileAnonymousFunction(string functionCode, int nArgs, Type declaringClass) + { + CompilerParameters parameters = new CompilerParameters(); + // This gets the location of the System assembly. + parameters.ReferencedAssemblies.Add(typeof(System.Int32).Assembly.Location); + // This gets the location of this assembly which also has YieldProlog.YP, etc. + parameters.ReferencedAssemblies.Add(typeof(YPCompiler).Assembly.Location); + if (declaringClass != null) + parameters.ReferencedAssemblies.Add(declaringClass.Assembly.Location); + parameters.GenerateInMemory = true; + + StringBuilder sourceCode = new StringBuilder(); + sourceCode.Append(@" +using System; +using System.Collections.Generic; +using YieldProlog; + +namespace Temporary { + public class Temporary : YP.IClause { + public class Inner" + (declaringClass == null ? "" : " : " + declaringClass.FullName) + @" { +"); + sourceCode.Append(functionCode); + // Basically, match applies the args to function. + sourceCode.Append(@" + } + public IEnumerable match(object[] args) { + return Inner.function("); + if (nArgs >= 1) + sourceCode.Append("args[0]"); + for (int i = 1; i < nArgs; ++i) + sourceCode.Append(", args[" + i + "]"); + sourceCode.Append(@"); + } + } +} +"); + + CompilerResults results = CodeDomProvider.CreateProvider + ("CSharp").CompileAssemblyFromSource(parameters, sourceCode.ToString()); + if (results.Errors.Count > 0) + throw new Exception("Error evaluating code: " + results.Errors[0]); + + // Return a new Temporary.Temporary object. + return (YP.IClause)results.CompiledAssembly.GetType + ("Temporary.Temporary").GetConstructor(Type.EmptyTypes).Invoke(null); + } + + // Compiler output follows. + + class YPInnerClass { } + static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } + + public static void repeatWrite(object arg1, object N) + { + { + object _Value = arg1; + if (YP.termEqual(N, 0)) + { + return; + } + } + { + object Value = arg1; + Variable NextN = new Variable(); + YP.write(Value); + foreach (bool l2 in YP.unify(NextN, YP.subtract(N, 1))) + { + repeatWrite(Value, NextN); + return; + } + } + } + + public static bool sameVariable(object Variable1, object Variable2) + { + { + if (YP.var(Variable1)) + { + if (YP.var(Variable2)) + { + if (YP.termEqual(Variable1, Variable2)) + { + return true; + } + } + } + } + return false; + } + + public static IEnumerable makeFunctionPseudoCode(object RuleList, object FunctionCode) + { + { + Variable State = new Variable(); + foreach (bool l2 in CompilerState.make(State)) + { + CompilerState.assertPred(State, Atom.a(@"nl"), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"write", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"put_code", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"throw", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"det")); + CompilerState.assertPred(State, new Functor1(@"var", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"nonvar", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"atom", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor1(@"number", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"\==", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@=<", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@>", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + CompilerState.assertPred(State, new Functor2(@"@>=", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in")), new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet")); + processCompilerDirectives(RuleList, State); + foreach (bool l3 in YP.unify(FunctionCode, Atom.a(@"getDeclaringClass"))) + { + yield return false; + } + foreach (bool l3 in makeFunctionPseudoCode3(RuleList, State, FunctionCode)) + { + yield return false; + } + } + } + } + + public static void processCompilerDirectives(object arg1, object arg2) + { + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + object State = arg2; + Variable Pred = new Variable(); + Variable Determinism = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor1(@"pred", new Functor2(@"is", Pred, Determinism))), x3), RestRules))) + { + CompilerState.assertPred(State, Pred, Determinism); + processCompilerDirectives(RestRules, State); + return; + } + } + { + object State = arg2; + Variable Module = new Variable(); + Variable PredicateList = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", new Functor2(@"import", Module, PredicateList)), x3), RestRules))) + { + foreach (bool l3 in importPredicateList(State, Module, PredicateList)) + { + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable x1 = new Variable(); + Variable x2 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor1(@":-", x1), x2), RestRules))) + { + processCompilerDirectives(RestRules, State); + return; + } + } + { + object State = arg2; + Variable Head = new Variable(); + Variable _Body = new Variable(); + Variable x3 = new Variable(); + Variable RestRules = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", new Functor2(@":-", Head, _Body), x3), RestRules))) + { + foreach (bool l3 in YP.functor(Head, Name, Arity)) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable Fact = new Variable(); + Variable x2 = new Variable(); + Variable RestRules = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", Fact, x2), RestRules))) + { + foreach (bool l3 in YP.functor(Fact, Name, Arity)) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a(@"")); + processCompilerDirectives(RestRules, State); + return; + } + } + } + { + object State = arg2; + Variable x1 = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestRules))) + { + processCompilerDirectives(RestRules, State); + return; + } + } + } + + public static IEnumerable importPredicateList(object arg1, object arg2, object arg3) + { + { + object _State = arg1; + object _Module = arg2; + foreach (bool l2 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + { + object State = arg1; + object Module = arg2; + Variable Name = new Variable(); + Variable Arity = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2(@"/", Name, Arity), Rest))) + { + CompilerState.assertModuleForNameArity(State, Name, Arity, Module); + foreach (bool l3 in importPredicateList(State, Module, Rest)) + { + yield return true; + yield break; + } + } + } + { + object State = arg1; + object Module = arg2; + Variable x3 = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg3, new ListPair(x3, Rest))) + { + foreach (bool l3 in importPredicateList(State, Module, Rest)) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable makeFunctionPseudoCode3(object RuleList, object State, object FunctionCode) + { + { + Variable SamePredicateRuleList = new Variable(); + Variable RestRules = new Variable(); + foreach (bool l2 in samePredicateRuleList(RuleList, SamePredicateRuleList, RestRules)) + { + if (YP.termNotEqual(SamePredicateRuleList, Atom.NIL)) + { + foreach (bool l4 in compileSamePredicateFunction(SamePredicateRuleList, State, FunctionCode)) + { + yield return false; + } + foreach (bool l4 in makeFunctionPseudoCode3(RestRules, State, FunctionCode)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable compileSamePredicateFunction(object SamePredicateRuleList, object State, object FunctionCode) + { + { + Variable FirstRule = new Variable(); + Variable x5 = new Variable(); + Variable x6 = new Variable(); + Variable x7 = new Variable(); + Variable Head = new Variable(); + Variable x9 = new Variable(); + Variable ArgAssignments = new Variable(); + Variable Calls = new Variable(); + Variable Rule = new Variable(); + Variable VariableNameSuggestions = new Variable(); + Variable ClauseBag = new Variable(); + Variable Name = new Variable(); + Variable ArgsList = new Variable(); + Variable FunctionArgNames = new Variable(); + Variable MergedArgName = new Variable(); + Variable ArgName = new Variable(); + Variable MergedArgNames = new Variable(); + Variable FunctionArgs = new Variable(); + Variable BodyCode = new Variable(); + Variable ReturnType = new Variable(); + Variable BodyWithReturn = new Variable(); + foreach (bool l2 in YP.unify(new ListPair(new Functor2(@"f", FirstRule, x5), x6), SamePredicateRuleList)) + { + foreach (bool l3 in YP.unify(FirstRule, new Functor1(@":-", x7))) + { + goto cutIf1; + } + foreach (bool l3 in YP.unify(new Functor2(@":-", Head, x9), FirstRule)) + { + CompilerState.startFunction(State, Head); + FindallAnswers findallAnswers3 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); + foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) + { + foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) + { + findallAnswers3.add(); + } + } + foreach (bool l4 in findallAnswers3.result(ClauseBag)) + { + foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) + { + foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) + { + FindallAnswers findallAnswers4 = new FindallAnswers(MergedArgName); + foreach (bool l7 in member(ArgName, FunctionArgNames)) + { + foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) + { + findallAnswers4.add(); + goto cutIf5; + } + foreach (bool l8 in YP.unify(MergedArgName, ArgName)) + { + findallAnswers4.add(); + } + cutIf5: + { } + } + foreach (bool l7 in findallAnswers4.result(MergedArgNames)) + { + foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) + { + foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf7; + } + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf7: + { } + } + goto cutIf6; + } + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf9; + } + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf9: + { } + } + goto cutIf8; + } + foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf10; + } + foreach (bool l11 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf10: + { } + } + cutIf8: + cutIf6: + { } + } + } + } + } + } + } + goto cutIf2; + } + foreach (bool l3 in YP.unify(Head, FirstRule)) + { + CompilerState.startFunction(State, Head); + FindallAnswers findallAnswers11 = new FindallAnswers(new Functor2(@"f", ArgAssignments, Calls)); + foreach (bool l4 in member(new Functor2(@"f", Rule, VariableNameSuggestions), SamePredicateRuleList)) + { + foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) + { + findallAnswers11.add(); + } + } + foreach (bool l4 in findallAnswers11.result(ClauseBag)) + { + foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) + { + foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) + { + FindallAnswers findallAnswers12 = new FindallAnswers(MergedArgName); + foreach (bool l7 in member(ArgName, FunctionArgNames)) + { + foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) + { + findallAnswers12.add(); + goto cutIf13; + } + foreach (bool l8 in YP.unify(MergedArgName, ArgName)) + { + findallAnswers12.add(); + } + cutIf13: + { } + } + foreach (bool l7 in findallAnswers12.result(MergedArgNames)) + { + foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) + { + foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"void"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf15; + } + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf15: + { } + } + goto cutIf14; + } + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l11 in YP.unify(ReturnType, Atom.a(@"bool"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l13 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf17; + } + foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf17: + { } + } + goto cutIf16; + } + foreach (bool l10 in YP.unify(ReturnType, Atom.a(@"IEnumerable"))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + foreach (bool l12 in append(BodyCode, new ListPair(Atom.a(@"returnfalse"), Atom.NIL), BodyWithReturn)) + { + foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + goto cutIf18; + } + foreach (bool l11 in YP.unify(BodyWithReturn, BodyCode)) + { + foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) + { + yield return false; + } + } + cutIf18: + { } + } + cutIf16: + cutIf14: + { } + } + } + } + } + } + } + } + cutIf2: + cutIf1: + { } + } + } + } + + public static IEnumerable samePredicateRuleList(object arg1, object arg2, object arg3) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + } + { + Variable First = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Atom.NIL))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(First, Atom.NIL))) + { + foreach (bool l4 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + } + { + object SamePredicateRuleList = arg2; + object RestRules = arg3; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable FirstRule = new Variable(); + Variable x6 = new Variable(); + Variable SecondRule = new Variable(); + Variable x8 = new Variable(); + Variable x9 = new Variable(); + Variable FirstHead = new Variable(); + Variable x11 = new Variable(); + Variable SecondHead = new Variable(); + Variable x13 = new Variable(); + Variable Name = new Variable(); + Variable Arity = new Variable(); + Variable RestSamePredicates = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(new Functor2(@"f", FirstRule, x6), First)) + { + foreach (bool l4 in YP.unify(new ListPair(new Functor2(@"f", SecondRule, x8), x9), Rest)) + { + foreach (bool l5 in YP.unify(new Functor2(@":-", FirstHead, x11), FirstRule)) + { + foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf3; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf3: + { } + } + goto cutIf2; + } + foreach (bool l6 in YP.unify(SecondHead, SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf4; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf4: + { } + } + } + cutIf2: + goto cutIf1; + } + foreach (bool l5 in YP.unify(FirstHead, FirstRule)) + { + foreach (bool l6 in YP.unify(new Functor2(@":-", SecondHead, x13), SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf6; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf6: + { } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(SecondHead, SecondRule)) + { + foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) + { + foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) + { + foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) + { + foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) + { + yield return true; + yield break; + } + } + goto cutIf7; + } + foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) + { + foreach (bool l9 in YP.unify(RestRules, Rest)) + { + yield return true; + yield break; + } + } + cutIf7: + { } + } + } + cutIf5: + { } + } + cutIf1: + { } + } + } + } + } + } + + public static IEnumerable maplist_compileClause(object arg1, object arg2, object arg3) + { + { + object _MergedArgNames = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object MergedArgNames = arg2; + Variable ArgAssignments = new Variable(); + Variable Calls = new Variable(); + Variable Rest = new Variable(); + Variable ClauseCode = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", ArgAssignments, Calls), Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"blockScope", ClauseCode), RestResults))) + { + foreach (bool l4 in prependArgAssignments(ArgAssignments, Calls, MergedArgNames, ClauseCode)) + { + foreach (bool l5 in maplist_compileClause(Rest, MergedArgNames, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + } + + public static IEnumerable prependArgAssignments(object arg1, object arg2, object arg3, object arg4) + { + { + object _MergedArgNames = arg3; + Variable In = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, In)) + { + foreach (bool l4 in YP.unify(arg4, In)) + { + yield return true; + yield break; + } + } + } + } + { + object In = arg2; + object MergedArgNames = arg3; + object ClauseCode = arg4; + Variable VariableName = new Variable(); + Variable ArgName = new Variable(); + Variable RestArgAssignments = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"f", VariableName, ArgName), RestArgAssignments))) + { + foreach (bool l3 in member(VariableName, MergedArgNames)) + { + foreach (bool l4 in prependArgAssignments(RestArgAssignments, In, MergedArgNames, ClauseCode)) + { + yield return true; + yield break; + } + goto cutIf1; + } + foreach (bool l3 in prependArgAssignments(RestArgAssignments, new ListPair(new Functor3(@"declare", Atom.a(@"object"), VariableName, new Functor1(@"var", ArgName)), In), MergedArgNames, ClauseCode)) + { + yield return true; + yield break; + } + cutIf1: + { } + } + } + } + + public static IEnumerable argAssignedAll(object arg1, object arg2, object VariableName) + { + { + object _ArgName = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.NIL)) + { + if (YP.nonvar(VariableName)) + { + yield return true; + yield break; + } + } + } + { + object ArgName = arg1; + Variable ArgAssignments = new Variable(); + Variable _Calls = new Variable(); + Variable RestClauseBag = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(new Functor2(@"f", ArgAssignments, _Calls), RestClauseBag))) + { + foreach (bool l3 in member(new Functor2(@"f", VariableName, ArgName), ArgAssignments)) + { + foreach (bool l4 in argAssignedAll(ArgName, RestClauseBag, VariableName)) + { + yield return false; + } + } + } + } + } + + public static IEnumerable maplist_arg(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1(@"arg", First), RestResults))) + { + foreach (bool l4 in maplist_arg(Rest, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable getFunctionArgNames(object arg1, object arg2, object arg3) + { + { + object _StartArgNumber = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object StartArgNumber = arg2; + Variable x1 = new Variable(); + Variable Rest = new Variable(); + Variable ArgName = new Variable(); + Variable RestFunctionArgs = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable NextArgNumber = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ArgName, RestFunctionArgs))) + { + foreach (bool l4 in YP.number_codes(StartArgNumber, NumberCodes)) + { + foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l7 in YP.unify(NextArgNumber, YP.add(StartArgNumber, 1))) + { + foreach (bool l8 in getFunctionArgNames(Rest, NextArgNumber, RestFunctionArgs)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + + public static IEnumerable compileBodyWithHeadBindings(object Rule, object VariableNameSuggestions, object State, object ArgAssignments, object Calls) + { + { + Variable Head = new Variable(); + Variable Body = new Variable(); + Variable x8 = new Variable(); + Variable HeadArgs = new Variable(); + Variable CompiledHeadArgs = new Variable(); + Variable BodyCode = new Variable(); + Variable VariableNamesList = new Variable(); + Variable ArgUnifications = new Variable(); + foreach (bool l2 in YP.unify(new Functor2(@":-", Head, Body), Rule)) + { + CompilerState.newVariableNames(State, Rule, VariableNameSuggestions); + foreach (bool l3 in YP.univ(Head, new ListPair(x8, HeadArgs))) + { + foreach (bool l4 in maplist_compileTerm(HeadArgs, State, CompiledHeadArgs)) + { + foreach (bool l5 in compileRuleBody(Body, State, BodyCode)) + { + foreach (bool l6 in CompilerState.variableNamesList(State, VariableNamesList)) + { + foreach (bool l7 in compileArgUnifications(HeadArgs, CompiledHeadArgs, 1, HeadArgs, BodyCode, ArgUnifications)) + { + foreach (bool l8 in compileDeclarations(VariableNamesList, HeadArgs, Atom.NIL, ArgAssignments, ArgUnifications, Calls)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + foreach (bool l2 in compileBodyWithHeadBindings(new Functor2(@":-", Rule, Atom.a(@"true")), VariableNameSuggestions, State, ArgAssignments, Calls)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable compileArgUnifications(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object x1 = arg2; + object x2 = arg3; + object x3 = arg4; + Variable BodyCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg5, BodyCode)) + { + foreach (bool l4 in YP.unify(arg6, BodyCode)) + { + yield return true; + yield break; + } + } + } + } + { + object Index = arg3; + object AllHeadArgs = arg4; + object BodyCode = arg5; + object ArgUnifications = arg6; + Variable HeadArg = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable x3 = new Variable(); + Variable RestCompiledHeadArgs = new Variable(); + Variable _ArgIndex1 = new Variable(); + Variable NextIndex = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(HeadArg, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(x3, RestCompiledHeadArgs))) + { + foreach (bool l4 in getVariableArgIndex1(HeadArg, AllHeadArgs, _ArgIndex1)) + { + foreach (bool l5 in YP.unify(NextIndex, YP.add(Index, 1))) + { + foreach (bool l6 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, ArgUnifications)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object Index = arg3; + object AllHeadArgs = arg4; + object BodyCode = arg5; + Variable _HeadArg = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable CompiledHeadArg = new Variable(); + Variable RestCompiledHeadArgs = new Variable(); + Variable ArgName = new Variable(); + Variable RestArgUnifications = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable NextIndex = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(_HeadArg, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg2, new ListPair(CompiledHeadArg, RestCompiledHeadArgs))) + { + foreach (bool l4 in YP.unify(arg6, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(new Functor1(@"var", ArgName), new ListPair(CompiledHeadArg, Atom.NIL))), RestArgUnifications), Atom.NIL))) + { + foreach (bool l5 in YP.number_codes(Index, NumberCodes)) + { + foreach (bool l6 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l7 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l8 in YP.unify(NextIndex, YP.add(Index, 1))) + { + foreach (bool l9 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, RestArgUnifications)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + } + + public static IEnumerable compileDeclarations(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) + { + { + object _HeadArgs = arg2; + Variable ArgAssignmentsIn = new Variable(); + Variable DeclarationsIn = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, ArgAssignmentsIn)) + { + foreach (bool l4 in YP.unify(arg4, ArgAssignmentsIn)) + { + foreach (bool l5 in YP.unify(arg5, DeclarationsIn)) + { + foreach (bool l6 in YP.unify(arg6, DeclarationsIn)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object HeadArgs = arg2; + object ArgAssignmentsIn = arg3; + object ArgAssignmentsOut = arg4; + object DeclarationsIn = arg5; + object DeclarationsOut = arg6; + Variable VariableName = new Variable(); + Variable Var = new Variable(); + Variable RestVariableNames = new Variable(); + Variable ArgIndex1 = new Variable(); + Variable NumberCodes = new Variable(); + Variable NumberAtom = new Variable(); + Variable ArgName = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, Var), RestVariableNames))) + { + foreach (bool l3 in getVariableArgIndex1(Var, HeadArgs, ArgIndex1)) + { + foreach (bool l4 in YP.number_codes(ArgIndex1, NumberCodes)) + { + foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) + { + foreach (bool l6 in YP.atom_concat(Atom.a(@"arg"), NumberAtom, ArgName)) + { + foreach (bool l7 in compileDeclarations(RestVariableNames, HeadArgs, new ListPair(new Functor2(@"f", VariableName, ArgName), ArgAssignmentsIn), ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + { + object HeadArgs = arg2; + object ArgAssignmentsIn = arg3; + object ArgAssignmentsOut = arg4; + object DeclarationsIn = arg5; + Variable VariableName = new Variable(); + Variable _Var = new Variable(); + Variable RestVariableNames = new Variable(); + Variable DeclarationsOut = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"=", VariableName, _Var), RestVariableNames))) + { + foreach (bool l3 in YP.unify(arg6, new ListPair(new Functor3(@"declare", Atom.a(@"Variable"), VariableName, new Functor2(@"new", Atom.a(@"Variable"), Atom.NIL)), DeclarationsOut))) + { + foreach (bool l4 in compileDeclarations(RestVariableNames, HeadArgs, ArgAssignmentsIn, ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable getVariableArgIndex1(object Var, object arg2, object arg3) + { + { + Variable FirstHeadArgs = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable x4 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(FirstHeadArgs, RestHeadArgs))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + if (sameVariable(Var, FirstHeadArgs)) + { + foreach (bool l5 in getVariableArgIndex1(Var, RestHeadArgs, x4)) + { + goto cutIf1; + } + yield return false; + cutIf1: + yield break; + } + } + } + } + { + object Index = arg3; + Variable x2 = new Variable(); + Variable RestHeadArgs = new Variable(); + Variable RestIndex = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(x2, RestHeadArgs))) + { + foreach (bool l3 in getVariableArgIndex1(Var, RestHeadArgs, RestIndex)) + { + foreach (bool l4 in YP.unify(Index, YP.add(1, RestIndex))) + { + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable compileRuleBody(object arg1, object arg2, object arg3) + { + { + object A = arg1; + object State = arg2; + object PseudoCode = arg3; + if (YP.var(A)) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), Atom.a(@"true")), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"!"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldtrue"), new ListPair(Atom.a(@"yieldbreak"), Atom.NIL)))) + { + yield return true; + yield break; + } + } + } + { + object _State = arg2; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"$CUTIF", Name))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL))) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"return"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"returntrue"), Atom.NIL))) + { + if (CompilerState.determinismEquals(State, Atom.a(@"semidetNoneOut"))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.a(@"true"))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(@"yieldfalse"), Atom.NIL))) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + if (YP.var(A)) + { + foreach (bool l4 in compileRuleBody(new Functor2(@",", new Functor1(@"call", A), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@"->", A, new Functor2(@",", T, C)), new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@";", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, C), new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor1(@"not", ACode), BCode), Atom.NIL))) + { + if (CompilerState.isSemidetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"\+", A), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"fail")), Atom.a(@"true")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"once", A), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, Atom.a(@"true")), Atom.a(@"fail")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"->", A, T), B))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor2(@";", new Functor2(@"->", A, T), Atom.a(@"fail")), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"\=", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"\+", new Functor2(@"=", A, B)), C), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable ACode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"!"), A))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in append(ACode, new ListPair(Atom.a(@"yieldbreak"), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Name = new Variable(); + Variable A = new Variable(); + Variable ACode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$CUTIF", Name), A))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in append(ACode, new ListPair(new Functor1(@"breakBlock", Name), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + Variable x1 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"fail"), x1))) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", Atom.a(@"true"), A))) + { + foreach (bool l3 in compileRuleBody(A, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable Term = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable TermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@"is", A, Term), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.unify"), new ListPair(ACode, new ListPair(TermCode, Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in compileTerm(A, State, ACode)) + { + foreach (bool l5 in compileExpression(Term, State, TermCode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) + { + if (CompilerState.isDetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", ACode, BCode), Atom.NIL))) + { + if (CompilerState.isSemidetNoneOut(State, A)) + { + foreach (bool l5 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l6 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + { + object State = arg2; + Variable ACode = new Variable(); + Variable B = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", ACode), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) + { + foreach (bool l4 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable FunctionName = new Variable(); + Variable X1Code = new Variable(); + Variable X2Code = new Variable(); + Variable BCode = new Variable(); + Variable Name = new Variable(); + Variable X1 = new Variable(); + Variable X2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"if", new Functor2(@"call", FunctionName, new ListPair(X1Code, new ListPair(X2Code, Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in YP.univ(A, new ListPair(Name, new ListPair(X1, new ListPair(X2, Atom.NIL))))) + { + foreach (bool l5 in binaryExpressionConditional(Name, FunctionName)) + { + foreach (bool l6 in compileExpression(X1, State, X1Code)) + { + foreach (bool l7 in compileExpression(X2, State, X2Code)) + { + foreach (bool l8 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable C = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor2(@",", A, B), C))) + { + foreach (bool l3 in compileRuleBody(new Functor2(@",", A, new Functor2(@",", B, C)), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + Variable TemplateCode = new Variable(); + Variable FindallAnswers = new Variable(); + Variable GoalAndAddCode = new Variable(); + Variable BagCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"findall", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileTerm(Template, State, TemplateCode)) + { + foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"findallAnswers"), FindallAnswers)) + { + foreach (bool l5 in compileRuleBody(new Functor2(@",", Goal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) + { + foreach (bool l6 in compileTerm(Bag, State, BagCode)) + { + foreach (bool l7 in compileRuleBody(B, State, BCode)) + { + foreach (bool l8 in append(new ListPair(new Functor3(@"declare", Atom.a(@"FindallAnswers"), FindallAnswers, new Functor2(@"new", Atom.a(@"FindallAnswers"), new ListPair(TemplateCode, Atom.NIL))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", FindallAnswers), Atom.a(@"result"), new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"bagof", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileBagof(Atom.a(@"result"), Template, Goal, Bag, B, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable Template = new Variable(); + Variable Goal = new Variable(); + Variable Bag = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"setof", Template, Goal, Bag), B))) + { + foreach (bool l3 in compileBagof(Atom.a(@"resultSet"), Template, Goal, Bag, B, State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ATermCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"call", A), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL))) + { + foreach (bool l4 in compileTerm(A, State, ATermCode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@",", A, B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"foreach", ACode, BCode), Atom.NIL))) + { + foreach (bool l4 in compileFunctorCall(A, State, ACode)) + { + foreach (bool l5 in compileRuleBody(B, State, BCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) + { + if (YP.var(A)) + { + foreach (bool l4 in compileRuleBody(new Functor2(@";", new Functor1(@"call", A), B), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg2; + Variable A = new Variable(); + Variable T = new Variable(); + Variable B = new Variable(); + Variable CutIfLabel = new Variable(); + Variable Code = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", new Functor2(@"->", A, T), B))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"breakableBlock", CutIfLabel, Code), Atom.NIL))) + { + foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"cutIf"), CutIfLabel)) + { + foreach (bool l5 in compileRuleBody(new Functor2(@";", new Functor2(@",", A, new Functor2(@",", new Functor1(@"$CUTIF", CutIfLabel), T)), B), State, Code)) + { + yield return true; + yield break; + } + } + } + } + } + { + object State = arg2; + object PseudoCode = arg3; + Variable A = new Variable(); + Variable B = new Variable(); + Variable ACode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@";", A, B))) + { + foreach (bool l3 in compileRuleBody(A, State, ACode)) + { + foreach (bool l4 in compileRuleBody(B, State, BCode)) + { + foreach (bool l5 in append(ACode, BCode, PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + { + object A = arg1; + object State = arg2; + object PseudoCode = arg3; + foreach (bool l2 in compileRuleBody(new Functor2(@",", A, Atom.a(@"true")), State, PseudoCode)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable compileBagof(object ResultMethod, object Template, object Goal, object Bag, object B, object State, object PseudoCode) + { + { + Variable TemplateCode = new Variable(); + Variable GoalTermCode = new Variable(); + Variable UnqualifiedGoal = new Variable(); + Variable BagofAnswers = new Variable(); + Variable GoalAndAddCode = new Variable(); + Variable BagCode = new Variable(); + Variable BCode = new Variable(); + foreach (bool l2 in compileTerm(Template, State, TemplateCode)) + { + foreach (bool l3 in compileTerm(Goal, State, GoalTermCode)) + { + foreach (bool l4 in unqualifiedGoal(Goal, UnqualifiedGoal)) + { + foreach (bool l5 in CompilerState.gensym(State, Atom.a(@"bagofAnswers"), BagofAnswers)) + { + foreach (bool l6 in compileRuleBody(new Functor2(@",", UnqualifiedGoal, new Functor2(@",", new Functor1(@"$DET_NONE_OUT", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), Atom.a(@"add"), Atom.NIL)), Atom.a(@"fail"))), State, GoalAndAddCode)) + { + foreach (bool l7 in compileTerm(Bag, State, BagCode)) + { + foreach (bool l8 in compileRuleBody(B, State, BCode)) + { + foreach (bool l9 in append(new ListPair(new Functor3(@"declare", Atom.a(@"BagofAnswers"), BagofAnswers, new Functor2(@"new", Atom.a(@"BagofAnswers"), new ListPair(TemplateCode, new ListPair(GoalTermCode, Atom.NIL)))), GoalAndAddCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", BagofAnswers), ResultMethod, new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + } + } + } + + public static IEnumerable unqualifiedGoal(object arg1, object arg2) + { + { + object Goal = arg1; + foreach (bool l2 in YP.unify(arg2, new Functor1(@"call", Goal))) + { + if (YP.var(Goal)) + { + yield return true; + yield break; + } + } + } + { + object UnqualifiedGoal = arg2; + Variable x1 = new Variable(); + Variable Goal = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"^", x1, Goal))) + { + foreach (bool l3 in unqualifiedGoal(Goal, UnqualifiedGoal)) + { + yield return true; + yield break; + } + } + } + { + Variable UnqualifiedGoal = new Variable(); + foreach (bool l2 in YP.unify(arg1, UnqualifiedGoal)) + { + foreach (bool l3 in YP.unify(arg2, UnqualifiedGoal)) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable binaryExpressionConditional(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=:="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.equal"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=\="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.notEqual"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">="))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.greaterThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"=<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.lessThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable compileFunctorCall(object Functor_1, object State, object arg3) + { + { + Variable FunctionName = new Variable(); + Variable CompiledArgs = new Variable(); + Variable FunctorName = new Variable(); + Variable FunctorArgs = new Variable(); + Variable x7 = new Variable(); + Variable Arity = new Variable(); + foreach (bool l2 in YP.unify(arg3, new Functor2(@"call", FunctionName, CompiledArgs))) + { + foreach (bool l3 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs))) + { + foreach (bool l4 in YP.functor(Functor_1, x7, Arity)) + { + foreach (bool l5 in functorCallFunctionName(State, FunctorName, Arity, FunctionName)) + { + foreach (bool l6 in maplist_compileTerm(FunctorArgs, State, CompiledArgs)) + { + yield return true; + yield break; + } + } + } + } + } + } + } + + public static IEnumerable functorCallFunctionName(object arg1, object arg2, object arg3, object arg4) + { + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"="))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.unify"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"=.."))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.univ"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"var"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.var"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"nonvar"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.nonvar"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"arg"))) + { + foreach (bool l3 in YP.unify(arg3, 3)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.arg"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"functor"))) + { + foreach (bool l3 in YP.unify(arg3, 3)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.functor"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"repeat"))) + { + foreach (bool l3 in YP.unify(arg3, 0)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.repeat"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"get_code"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.get_code"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"current_op"))) + { + foreach (bool l3 in YP.unify(arg3, 3)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.current_op"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_length"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_length"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_concat"))) + { + foreach (bool l3 in YP.unify(arg3, 3)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_concat"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"sub_atom"))) + { + foreach (bool l3 in YP.unify(arg3, 5)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.sub_atom"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom_codes"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom_codes"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"number_codes"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.number_codes"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"copy_term"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.copy_term"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"sort"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.sort"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"script_event"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.script_event"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"nl"))) + { + foreach (bool l3 in YP.unify(arg3, 0)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.nl"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"write"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.write"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"put_code"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.put_code"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"atom"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.atom"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"number"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.number"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"=="))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"\=="))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termNotEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"@<"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termLessThan"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"@=<"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termLessThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"@>"))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termGreaterThan"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"@>="))) + { + foreach (bool l3 in YP.unify(arg3, 2)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.termGreaterThanOrEqual"))) + { + yield return true; + yield break; + } + } + } + } + { + object x1 = arg1; + foreach (bool l2 in YP.unify(arg2, Atom.a(@"throw"))) + { + foreach (bool l3 in YP.unify(arg3, 1)) + { + foreach (bool l4 in YP.unify(arg4, Atom.a(@"YP.throwException"))) + { + yield return true; + yield break; + } + } + } + } + { + object State = arg1; + object Arity = arg3; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg2, Name)) + { + foreach (bool l3 in YP.unify(arg4, Name)) + { + if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg1; + object _Arity = arg3; + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg2, Name)) + { + foreach (bool l3 in YP.unify(arg4, Name)) + { + foreach (bool l4 in Atom.module(Name, Atom.a(@""))) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg1; + object Name = arg2; + object Arity = arg3; + object x4 = arg4; + foreach (bool l2 in Atom.module(Name, Atom.NIL)) + { + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Atom.a(@"Calls to dynamic predicates not supported"))); + yield return true; + yield break; + } + } + { + object _State = arg1; + object Name = arg2; + object Arity = arg3; + object x4 = arg4; + Variable Module = new Variable(); + Variable Message = new Variable(); + foreach (bool l2 in Atom.module(Name, Module)) + { + foreach (bool l3 in Atom.module(Name, Atom.NIL)) + { + foreach (bool l4 in YP.atom_concat(Atom.a(@"Not supporting calls to external module: "), Module, Message)) + { + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), new Functor2(@"/", Name, Arity)), Message)); + yield return true; + yield break; + } + } + } + } + } + + public static IEnumerable compileTerm(object arg1, object arg2, object arg3) + { + { + object Term = arg1; + object State = arg2; + Variable VariableName = new Variable(); + foreach (bool l2 in YP.unify(arg3, new Functor1(@"var", VariableName))) + { + if (YP.var(Term)) + { + foreach (bool l4 in CompilerState.getVariableName(State, Term, VariableName)) + { + yield return true; + yield break; + } + } + } + } + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, new Functor1(@"var", Atom.a(@"Atom.NIL")))) + { + yield return true; + yield break; + } + } + } + { + object Term = arg1; + object State = arg2; + object Code = arg3; + Variable ModuleCode = new Variable(); + if (YP.atom(Term)) + { + foreach (bool l3 in compileAtomModule(Term, 0, State, ModuleCode)) + { + foreach (bool l4 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), new ListPair(ModuleCode, Atom.NIL))))) + { + yield return true; + yield break; + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(Code, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Term), Atom.NIL)))) + { + yield return true; + yield break; + } + cutIf1: + { } + } + } + { + object State = arg2; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable Arg1 = new Variable(); + Variable Arg2 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new Functor2(@"new", Atom.a(@"ListPair"), new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) + { + foreach (bool l4 in compileTerm(First, State, Arg1)) + { + foreach (bool l5 in compileTerm(Rest, State, Arg2)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Term = arg1; + object State = arg2; + object Result = arg3; + Variable Name = new Variable(); + Variable TermArgs = new Variable(); + Variable x6 = new Variable(); + Variable Arity = new Variable(); + Variable ModuleCode = new Variable(); + Variable NameCode = new Variable(); + Variable X1 = new Variable(); + Variable Arg1 = new Variable(); + Variable X2 = new Variable(); + Variable Arg2 = new Variable(); + Variable X3 = new Variable(); + Variable Arg3 = new Variable(); + Variable Args = new Variable(); + foreach (bool l2 in YP.univ(Term, new ListPair(Name, TermArgs))) + { + if (YP.termEqual(TermArgs, Atom.NIL)) + { + foreach (bool l4 in YP.unify(Result, new Functor1(@"object", Name))) + { + yield return true; + yield break; + } + goto cutIf2; + } + foreach (bool l3 in YP.functor(Term, x6, Arity)) + { + foreach (bool l4 in compileAtomModule(Name, Arity, State, ModuleCode)) + { + foreach (bool l5 in YP.unify(NameCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Name), new ListPair(ModuleCode, Atom.NIL))))) + { + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) + { + yield return true; + yield break; + } + } + goto cutIf4; + } + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in compileTerm(X2, State, Arg2)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) + { + yield return true; + yield break; + } + } + } + goto cutIf5; + } + foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) + { + foreach (bool l7 in compileTerm(X1, State, Arg1)) + { + foreach (bool l8 in compileTerm(X2, State, Arg2)) + { + foreach (bool l9 in compileTerm(X3, State, Arg3)) + { + foreach (bool l10 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) + { + yield return true; + yield break; + } + } + } + } + } + foreach (bool l6 in maplist_compileTerm(TermArgs, State, Args)) + { + foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) + { + yield return true; + yield break; + } + } + cutIf5: + cutIf4: + { } + } + goto cutIf3; + } + foreach (bool l4 in YP.unify(NameCode, new Functor1(@"object", Name))) + { + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) + { + yield return true; + yield break; + } + } + goto cutIf6; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in compileTerm(X2, State, Arg2)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor2"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL)))))) + { + yield return true; + yield break; + } + } + } + goto cutIf7; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, new ListPair(X3, Atom.NIL))))) + { + foreach (bool l6 in compileTerm(X1, State, Arg1)) + { + foreach (bool l7 in compileTerm(X2, State, Arg2)) + { + foreach (bool l8 in compileTerm(X3, State, Arg3)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor3"), new ListPair(NameCode, new ListPair(Arg1, new ListPair(Arg2, new ListPair(Arg3, Atom.NIL))))))) + { + yield return true; + yield break; + } + } + } + } + } + foreach (bool l5 in maplist_compileTerm(TermArgs, State, Args)) + { + foreach (bool l6 in YP.unify(Result, new Functor2(@"new", Atom.a(@"Functor"), new ListPair(NameCode, new ListPair(new Functor1(@"objectArray", Args), Atom.NIL))))) + { + yield return true; + yield break; + } + } + cutIf7: + cutIf6: + { } + } + cutIf3: + { } + } + cutIf2: + { } + } + } + } + + public static IEnumerable compileAtomModule(object Name, object Arity, object State, object ModuleCode) + { + { + if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(@""))) + { + foreach (bool l3 in YP.unify(ModuleCode, new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", Atom.a(@"")), Atom.NIL)))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable maplist_compileTerm(object arg1, object arg2, object arg3) + { + { + object _State = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg3, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + { + object State = arg2; + Variable First = new Variable(); + Variable Rest = new Variable(); + Variable FirstResult = new Variable(); + Variable RestResults = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(FirstResult, RestResults))) + { + foreach (bool l4 in compileTerm(First, State, FirstResult)) + { + foreach (bool l5 in maplist_compileTerm(Rest, State, RestResults)) + { + yield return true; + yield break; + } + } + } + } + } + } + + public static IEnumerable compileExpression(object Term, object State, object Result) + { + { + Variable Name = new Variable(); + Variable TermArgs = new Variable(); + Variable X1 = new Variable(); + Variable FunctionName = new Variable(); + Variable Arg1 = new Variable(); + Variable x9 = new Variable(); + Variable X2 = new Variable(); + Variable Arg2 = new Variable(); + if (YP.nonvar(Term)) + { + foreach (bool l3 in YP.univ(Term, new ListPair(Name, TermArgs))) + { + if (YP.atom(Name)) + { + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) + { + foreach (bool l6 in unaryFunction(Name, FunctionName)) + { + foreach (bool l7 in compileExpression(X1, State, Arg1)) + { + foreach (bool l8 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, Atom.NIL)))) + { + yield return true; + yield break; + } + } + goto cutIf1; + } + } + foreach (bool l5 in YP.unify(Term, new ListPair(x9, Atom.NIL))) + { + foreach (bool l6 in compileTerm(Term, State, Result)) + { + yield return true; + yield break; + } + goto cutIf2; + } + foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) + { + foreach (bool l6 in binaryFunction(Name, FunctionName)) + { + foreach (bool l7 in compileExpression(X1, State, Arg1)) + { + foreach (bool l8 in compileExpression(X2, State, Arg2)) + { + foreach (bool l9 in YP.unify(Result, new Functor2(@"call", FunctionName, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) + { + yield return true; + yield break; + } + } + } + goto cutIf3; + } + } + YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"evaluable"), Name), Atom.a(@"Not an expression function"))); + yield return false; + cutIf3: + cutIf2: + cutIf1: + { } + } + } + } + } + { + foreach (bool l2 in compileTerm(Term, State, Result)) + { + yield return true; + yield break; + } + } + } + + public static IEnumerable unaryFunction(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.negate"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"abs"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.abs"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sign"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sign"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.floor"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"truncate"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.truncate"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"round"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.round"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"floor"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.ceiling"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sin"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sin"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"cos"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.cos"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"atan"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.atan"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"exp"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.exp"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"log"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.log"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"sqrt"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.sqrt"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"\"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseComplement"))) + { + yield return true; + yield break; + } + } + } + } + + public static IEnumerable binaryFunction(object arg1, object arg2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"+"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.add"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"-"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.subtract"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"*"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.multiply"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"/"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.divide"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"//"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.intDivide"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"mod"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.mod"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"**"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.pow"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@">>"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftRight"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"<<"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseShiftLeft"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"/\"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseAnd"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"\/"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.bitwiseOr"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"min"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.min"))) + { + yield return true; + yield break; + } + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"max"))) + { + foreach (bool l3 in YP.unify(arg2, Atom.a(@"YP.max"))) + { + yield return true; + yield break; + } + } + } + } + + public static void convertFunctionCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"class YPInnerClass {}")); + YP.nl(); + YP.write(Atom.a(@"static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }")); + YP.nl(); + YP.nl(); + return; + } + } + { + Variable ReturnType = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + Variable Level = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { ReturnType, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"public static ")); + YP.write(ReturnType); + YP.write(Atom.a(@" ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(Level, 1)) + { + convertStatementListCSharp(Body, Level); + YP.write(Atom.a(@"}")); + YP.nl(); + YP.nl(); + return; + } + } + } + } + + public static IEnumerable convertStatementListCSharp(object arg1, object x1, object x2) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return true; + yield break; + } + } + } + + public static void convertStatementListCSharp(object arg1, object Level) + { + { + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NewStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + foreach (bool l3 in append(Body, new ListPair(new Functor1(@"label", Name), RestStatements), NewStatements)) + { + convertStatementListCSharp(NewStatements, Level); + return; + } + } + } + { + Variable Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", Type, Name, Expression), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Type); + YP.write(Atom.a(@" ")); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield return true;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield return false;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"yield break;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return true;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"return false;")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"label", Name), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + if (YP.termEqual(RestStatements, Atom.NIL)) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"{}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + goto cutIf1; + } + convertStatementListCSharp(RestStatements, Level); + return; + cutIf1: + { } + } + } + { + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"goto ")); + YP.write(Name); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + { + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + { + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"if (")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + { + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationCSharp(Level); + YP.write(Atom.a(@"foreach (bool l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionCSharp(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListCSharp(Body, NextLevel); + convertIndentationCSharp(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListCSharp(RestStatements, Level); + return; + } + } + } + } + + public static void convertIndentationCSharp(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionCSharp(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListCSharp(Tail); + return; + goto cutIf1; + } + convertArgListCSharp(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionCSharp(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(Atom.a(@"object ")); + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Atom.a(@"new ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"null")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"!(")); + convertExpressionCSharp(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionCSharp(X); + YP.write(Atom.a(@") && (")); + convertExpressionCSharp(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"new object[] {")); + convertArgListCSharp(ArgList); + YP.write(Atom.a(@"}")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"@""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesCSharp(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesCSharp(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(34); + YP.put_code(Code); + convertStringCodesCSharp(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesCSharp(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static void convertFunctionJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"function getDeclaringClass() { return null; }")); + YP.nl(); + return; + } + } + { + Variable x1 = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"function ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@") {")); + YP.nl(); + convertStatementListJavascript(Body, 1); + YP.write(Atom.a(@"}")); + YP.nl(); + YP.nl(); + return; + } + } + } + + public static void convertStatementListJavascript(object arg1, object arg2) + { + { + object x1 = arg2; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable _Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"var ")); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"yield true;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"yield false;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return true;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"return false;")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"break ")); + YP.write(Name); + YP.write(Atom.a(@";")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@");")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + { + object Level = arg2; + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"{")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"if (")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + { + object Level = arg2; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationJavascript(Level); + YP.write(Atom.a(@"for each (var l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionJavascript(Expression); + YP.write(Atom.a(@") {")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + convertStatementListJavascript(Body, NextLevel); + convertIndentationJavascript(Level); + YP.write(Atom.a(@"}")); + YP.nl(); + convertStatementListJavascript(RestStatements, Level); + return; + } + } + } + } + + public static void convertIndentationJavascript(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionJavascript(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListJavascript(Tail); + return; + goto cutIf1; + } + convertArgListJavascript(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionJavascript(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Atom.a(@"new ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"null")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"!(")); + convertExpressionJavascript(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionJavascript(X); + YP.write(Atom.a(@") && (")); + convertExpressionJavascript(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"[")); + convertArgListJavascript(ArgList); + YP.write(Atom.a(@"]")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesJavascript(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesJavascript(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + goto cutIf1; + } + if (YP.termEqual(Code, 92)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesJavascript(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static void convertFunctionPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"getDeclaringClass"))) + { + YP.write(Atom.a(@"def getDeclaringClass():")); + YP.nl(); + YP.write(Atom.a(@" return None")); + YP.nl(); + YP.nl(); + return; + } + } + { + Variable x1 = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable Body = new Variable(); + Variable Level = new Variable(); + Variable HasBreakableBlock = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor(@"function", new object[] { x1, Name, ArgList, Body }))) + { + YP.write(Atom.a(@"def ")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@"):")); + YP.nl(); + foreach (bool l3 in YP.unify(Level, 1)) + { + if (hasBreakableBlockPython(Body)) + { + foreach (bool l5 in YP.unify(HasBreakableBlock, 1)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + foreach (bool l7 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + goto cutIf2; + } + foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + cutIf2: + { } + } + goto cutIf1; + } + foreach (bool l4 in YP.unify(HasBreakableBlock, 0)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + goto cutIf3; + } + foreach (bool l5 in convertStatementListPython(Body, Level, HasBreakableBlock)) + { + YP.nl(); + return; + } + cutIf3: + { } + } + cutIf1: + { } + } + } + } + } + + public static bool hasBreakableBlockPython(object arg1) + { + { + Variable _Name = new Variable(); + Variable _Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", _Name, _Body), _RestStatements))) + { + return true; + } + } + { + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable _Expression = new Variable(); + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", _Expression, Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable _Expression = new Variable(); + Variable Body = new Variable(); + Variable _RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", _Expression, Body), _RestStatements))) + { + if (hasBreakableBlockPython(Body)) + { + return true; + } + } + } + { + Variable x1 = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestStatements))) + { + if (hasBreakableBlockPython(RestStatements)) + { + return true; + } + } + } + return false; + } + + public static IEnumerable convertStatementListPython(object arg1, object arg2, object arg3) + { + { + object x1 = arg2; + object x2 = arg3; + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + yield return true; + yield break; + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"breakableBlock", Name, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = False")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"for _ in [1]:")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if ")); + YP.write(Name); + YP.write(Atom.a(@":")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"doBreak = False")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable _Type = new Variable(); + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"declare", _Type, Name, Expression), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionPython(Expression); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable Expression = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"assign", Name, Expression), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = ")); + convertExpressionPython(Expression); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldtrue"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"yield True")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldfalse"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"yield False")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"yieldbreak"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"return"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returntrue"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return True")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(@"returnfalse"), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"return False")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"breakBlock", Name), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@" = True")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"doBreak = True")); + YP.nl(); + convertIndentationPython(Level); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"call", Name, ArgList), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + Variable RestStatements = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + YP.nl(); + foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"blockScope", Body), RestStatements))) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"for _ in [1]:")); + YP.nl(); + foreach (bool l4 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l5 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + if (YP.greaterThan(Level, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l8 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf3; + } + foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf3: + goto cutIf2; + } + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf2: + { } + } + } + goto cutIf1; + } + foreach (bool l3 in YP.unify(NextLevel, Level)) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + if (YP.greaterThan(Level, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf5; + } + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf5: + goto cutIf4; + } + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf4: + { } + } + } + cutIf1: + { } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"if", Expression, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if ")); + convertExpressionPython(Expression); + YP.write(Atom.a(@":")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + } + } + } + } + { + object Level = arg2; + object HasBreakableBlock = arg3; + Variable Expression = new Variable(); + Variable Body = new Variable(); + Variable RestStatements = new Variable(); + Variable NextLevel = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2(@"foreach", Expression, Body), RestStatements))) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"for l")); + YP.write(Level); + YP.write(Atom.a(@" in ")); + convertExpressionPython(Expression); + YP.write(Atom.a(@":")); + YP.nl(); + foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) + { + foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) + { + if (YP.termEqual(HasBreakableBlock, 1)) + { + convertIndentationPython(Level); + YP.write(Atom.a(@"if doBreak:")); + YP.nl(); + convertIndentationPython(NextLevel); + YP.write(Atom.a(@"break")); + YP.nl(); + foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + goto cutIf6; + } + foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) + { + yield return true; + yield break; + } + cutIf6: + { } + } + } + } + } + } + + public static void convertIndentationPython(object Level) + { + { + Variable N = new Variable(); + foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) + { + repeatWrite(Atom.a(@" "), N); + return; + } + } + } + + public static void convertArgListPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Head = new Variable(); + Variable Tail = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) + { + convertExpressionPython(Head); + if (YP.termNotEqual(Tail, Atom.NIL)) + { + YP.write(Atom.a(@", ")); + convertArgListPython(Tail); + return; + goto cutIf1; + } + convertArgListPython(Tail); + return; + cutIf1: + { } + } + } + } + + public static void convertExpressionPython(object arg1) + { + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"arg", X))) + { + YP.write(X); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"call", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Obj = new Variable(); + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor3(@"callMember", new Functor1(@"var", Obj), Name, ArgList))) + { + YP.write(Obj); + YP.write(Atom.a(@".")); + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"new", Name, ArgList))) + { + YP.write(Name); + YP.write(Atom.a(@"(")); + convertArgListPython(ArgList); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable Name = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"var", Name))) + { + YP.write(Name); + return; + } + } + { + foreach (bool l2 in YP.unify(arg1, Atom.a(@"null"))) + { + YP.write(Atom.a(@"None")); + return; + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"not", X))) + { + YP.write(Atom.a(@"not (")); + convertExpressionPython(X); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable X = new Variable(); + Variable Y = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor2(@"and", X, Y))) + { + YP.write(Atom.a(@"(")); + convertExpressionPython(X); + YP.write(Atom.a(@") and (")); + convertExpressionPython(Y); + YP.write(Atom.a(@")")); + return; + } + } + { + Variable ArgList = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"objectArray", ArgList))) + { + YP.write(Atom.a(@"[")); + convertArgListPython(ArgList); + YP.write(Atom.a(@"]")); + return; + } + } + { + Variable X = new Variable(); + Variable Codes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + if (YP.atom(X)) + { + YP.write(Atom.a(@"""")); + foreach (bool l4 in YP.atom_codes(X, Codes)) + { + convertStringCodesPython(Codes); + YP.write(Atom.a(@"""")); + return; + } + } + } + } + { + Variable X = new Variable(); + foreach (bool l2 in YP.unify(arg1, new Functor1(@"object", X))) + { + YP.write(X); + return; + } + } + } + + public static void convertStringCodesPython(object arg1) + { + { + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + return; + } + } + { + Variable Code = new Variable(); + Variable RestCodes = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) + { + if (YP.termEqual(Code, 34)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + goto cutIf1; + } + if (YP.termEqual(Code, 92)) + { + YP.put_code(92); + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + goto cutIf1; + } + YP.put_code(Code); + convertStringCodesPython(RestCodes); + return; + cutIf1: + { } + } + } + } + + public static IEnumerable member(object X, object arg2) + { + { + Variable x2 = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(X, x2))) + { + yield return false; + } + } + { + Variable x2 = new Variable(); + Variable Rest = new Variable(); + foreach (bool l2 in YP.unify(arg2, new ListPair(x2, Rest))) + { + foreach (bool l3 in member(X, Rest)) + { + yield return false; + } + } + } + } + + public static IEnumerable append(object arg1, object arg2, object arg3) + { + { + Variable List = new Variable(); + foreach (bool l2 in YP.unify(arg1, Atom.NIL)) + { + foreach (bool l3 in YP.unify(arg2, List)) + { + foreach (bool l4 in YP.unify(arg3, List)) + { + yield return false; + } + } + } + } + { + object List2 = arg2; + Variable X = new Variable(); + Variable List1 = new Variable(); + Variable List12 = new Variable(); + foreach (bool l2 in YP.unify(arg1, new ListPair(X, List1))) + { + foreach (bool l3 in YP.unify(arg3, new ListPair(X, List12))) + { + foreach (bool l4 in append(List1, List2, List12)) + { + yield return false; + } + } + } + } + } + + } +} diff --git a/doc/doxygen.conf b/doc/doxygen.conf index 1ee1c05..3712dfa 100644 --- a/doc/doxygen.conf +++ b/doc/doxygen.conf @@ -1,1356 +1,1356 @@ -# Doxyfile 1.5.5 - -# This file describes the settings to be used by the documentation system -# doxygen (www.doxygen.org) for a project -# -# All text after a hash (#) is considered a comment and will be ignored -# The format is: -# TAG = value [value, ...] -# For lists items can also be appended using: -# TAG += value [value, ...] -# Values that contain spaces should be placed between quotes (" ") - -#--------------------------------------------------------------------------- -# Project related configuration options -#--------------------------------------------------------------------------- - -# This tag specifies the encoding used for all characters in the config file -# that follow. The default is UTF-8 which is also the encoding used for all -# text before the first occurrence of this tag. Doxygen uses libiconv (or the -# iconv built into libc) for the transcoding. See -# http://www.gnu.org/software/libiconv for the list of possible encodings. - -DOXYFILE_ENCODING = UTF-8 - -# The PROJECT_NAME tag is a single word (or a sequence of words surrounded -# by quotes) that should identify the project. - -PROJECT_NAME = OpenSim - -# The PROJECT_NUMBER tag can be used to enter a project or revision number. -# This could be handy for archiving the generated documentation or -# if some version control system is used. - -PROJECT_NUMBER = SVN - -# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) -# base path where the generated documentation will be put. -# If a relative path is entered, it will be relative to the location -# where doxygen was started. If left blank the current directory will be used. - -OUTPUT_DIRECTORY = - -# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create -# 4096 sub-directories (in 2 levels) under the output directory of each output -# format and will distribute the generated files over these directories. -# Enabling this option can be useful when feeding doxygen a huge amount of -# source files, where putting all generated files in the same directory would -# otherwise cause performance problems for the file system. - -CREATE_SUBDIRS = NO - -# The OUTPUT_LANGUAGE tag is used to specify the language in which all -# documentation generated by doxygen is written. Doxygen will use this -# information to generate all constant output in the proper language. -# The default language is English, other supported languages are: -# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, -# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, -# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), -# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, -# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, -# and Ukrainian. - -OUTPUT_LANGUAGE = English - -# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will -# include brief member descriptions after the members that are listed in -# the file and class documentation (similar to JavaDoc). -# Set to NO to disable this. - -BRIEF_MEMBER_DESC = YES - -# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend -# the brief description of a member or function before the detailed description. -# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the -# brief descriptions will be completely suppressed. - -REPEAT_BRIEF = YES - -# This tag implements a quasi-intelligent brief description abbreviator -# that is used to form the text in various listings. Each string -# in this list, if found as the leading text of the brief description, will be -# stripped from the text and the result after processing the whole list, is -# used as the annotated text. Otherwise, the brief description is used as-is. -# If left blank, the following values are used ("$name" is automatically -# replaced with the name of the entity): "The $name class" "The $name widget" -# "The $name file" "is" "provides" "specifies" "contains" -# "represents" "a" "an" "the" - -ABBREVIATE_BRIEF = - -# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then -# Doxygen will generate a detailed section even if there is only a brief -# description. - -ALWAYS_DETAILED_SEC = NO - -# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all -# inherited members of a class in the documentation of that class as if those -# members were ordinary class members. Constructors, destructors and assignment -# operators of the base classes will not be shown. - -INLINE_INHERITED_MEMB = NO - -# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full -# path before files name in the file list and in the header files. If set -# to NO the shortest path that makes the file name unique will be used. - -FULL_PATH_NAMES = YES - -# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag -# can be used to strip a user-defined part of the path. Stripping is -# only done if one of the specified strings matches the left-hand part of -# the path. The tag can be used to show relative paths in the file list. -# If left blank the directory from which doxygen is run is used as the -# path to strip. - -STRIP_FROM_PATH = - -# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of -# the path mentioned in the documentation of a class, which tells -# the reader which header file to include in order to use a class. -# If left blank only the name of the header file containing the class -# definition is used. Otherwise one should specify the include paths that -# are normally passed to the compiler using the -I flag. - -STRIP_FROM_INC_PATH = - -# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter -# (but less readable) file names. This can be useful is your file systems -# doesn't support long names like on DOS, Mac, or CD-ROM. - -SHORT_NAMES = NO - -# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen -# will interpret the first line (until the first dot) of a JavaDoc-style -# comment as the brief description. If set to NO, the JavaDoc -# comments will behave just like regular Qt-style comments -# (thus requiring an explicit @brief command for a brief description.) - -JAVADOC_AUTOBRIEF = NO - -# If the QT_AUTOBRIEF tag is set to YES then Doxygen will -# interpret the first line (until the first dot) of a Qt-style -# comment as the brief description. If set to NO, the comments -# will behave just like regular Qt-style comments (thus requiring -# an explicit \brief command for a brief description.) - -QT_AUTOBRIEF = NO - -# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen -# treat a multi-line C++ special comment block (i.e. a block of //! or /// -# comments) as a brief description. This used to be the default behaviour. -# The new default is to treat a multi-line C++ comment block as a detailed -# description. Set this tag to YES if you prefer the old behaviour instead. - -MULTILINE_CPP_IS_BRIEF = NO - -# If the DETAILS_AT_TOP tag is set to YES then Doxygen -# will output the detailed description near the top, like JavaDoc. -# If set to NO, the detailed description appears after the member -# documentation. - -DETAILS_AT_TOP = NO - -# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented -# member inherits the documentation from any documented member that it -# re-implements. - -INHERIT_DOCS = YES - -# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce -# a new page for each member. If set to NO, the documentation of a member will -# be part of the file/class/namespace that contains it. - -SEPARATE_MEMBER_PAGES = NO - -# The TAB_SIZE tag can be used to set the number of spaces in a tab. -# Doxygen uses this value to replace tabs by spaces in code fragments. - -TAB_SIZE = 8 - -# This tag can be used to specify a number of aliases that acts -# as commands in the documentation. An alias has the form "name=value". -# For example adding "sideeffect=\par Side Effects:\n" will allow you to -# put the command \sideeffect (or @sideeffect) in the documentation, which -# will result in a user-defined paragraph with heading "Side Effects:". -# You can put \n's in the value part of an alias to insert newlines. - -ALIASES = - -# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C -# sources only. Doxygen will then generate output that is more tailored for C. -# For instance, some of the names that are used will be different. The list -# of all members will be omitted, etc. - -OPTIMIZE_OUTPUT_FOR_C = NO - -# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java -# sources only. Doxygen will then generate output that is more tailored for -# Java. For instance, namespaces will be presented as packages, qualified -# scopes will look different, etc. - -OPTIMIZE_OUTPUT_JAVA = NO - -# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran -# sources only. Doxygen will then generate output that is more tailored for -# Fortran. - -OPTIMIZE_FOR_FORTRAN = NO - -# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL -# sources. Doxygen will then generate output that is tailored for -# VHDL. - -OPTIMIZE_OUTPUT_VHDL = NO - -# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want -# to include (a tag file for) the STL sources as input, then you should -# set this tag to YES in order to let doxygen match functions declarations and -# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. -# func(std::string) {}). This also make the inheritance and collaboration -# diagrams that involve STL classes more complete and accurate. - -BUILTIN_STL_SUPPORT = NO - -# If you use Microsoft's C++/CLI language, you should set this option to YES to -# enable parsing support. - -CPP_CLI_SUPPORT = NO - -# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. -# Doxygen will parse them like normal C++ but will assume all classes use public -# instead of private inheritance when no explicit protection keyword is present. - -SIP_SUPPORT = NO - -# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC -# tag is set to YES, then doxygen will reuse the documentation of the first -# member in the group (if any) for the other members of the group. By default -# all members of a group must be documented explicitly. - -DISTRIBUTE_GROUP_DOC = NO - -# Set the SUBGROUPING tag to YES (the default) to allow class member groups of -# the same type (for instance a group of public functions) to be put as a -# subgroup of that type (e.g. under the Public Functions section). Set it to -# NO to prevent subgrouping. Alternatively, this can be done per class using -# the \nosubgrouping command. - -SUBGROUPING = YES - -# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum -# is documented as struct, union, or enum with the name of the typedef. So -# typedef struct TypeS {} TypeT, will appear in the documentation as a struct -# with name TypeT. When disabled the typedef will appear as a member of a file, -# namespace, or class. And the struct will be named TypeS. This can typically -# be useful for C code in case the coding convention dictates that all compound -# types are typedef'ed and only the typedef is referenced, never the tag name. - -TYPEDEF_HIDES_STRUCT = NO - -#--------------------------------------------------------------------------- -# Build related configuration options -#--------------------------------------------------------------------------- - -# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in -# documentation are documented, even if no documentation was available. -# Private class members and static file members will be hidden unless -# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES - -EXTRACT_ALL = YES - -# If the EXTRACT_PRIVATE tag is set to YES all private members of a class -# will be included in the documentation. - -EXTRACT_PRIVATE = NO - -# If the EXTRACT_STATIC tag is set to YES all static members of a file -# will be included in the documentation. - -EXTRACT_STATIC = NO - -# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) -# defined locally in source files will be included in the documentation. -# If set to NO only classes defined in header files are included. - -EXTRACT_LOCAL_CLASSES = YES - -# This flag is only useful for Objective-C code. When set to YES local -# methods, which are defined in the implementation section but not in -# the interface are included in the documentation. -# If set to NO (the default) only methods in the interface are included. - -EXTRACT_LOCAL_METHODS = NO - -# If this flag is set to YES, the members of anonymous namespaces will be -# extracted and appear in the documentation as a namespace called -# 'anonymous_namespace{file}', where file will be replaced with the base -# name of the file that contains the anonymous namespace. By default -# anonymous namespace are hidden. - -EXTRACT_ANON_NSPACES = NO - -# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all -# undocumented members of documented classes, files or namespaces. -# If set to NO (the default) these members will be included in the -# various overviews, but no documentation section is generated. -# This option has no effect if EXTRACT_ALL is enabled. - -HIDE_UNDOC_MEMBERS = NO - -# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all -# undocumented classes that are normally visible in the class hierarchy. -# If set to NO (the default) these classes will be included in the various -# overviews. This option has no effect if EXTRACT_ALL is enabled. - -HIDE_UNDOC_CLASSES = NO - -# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all -# friend (class|struct|union) declarations. -# If set to NO (the default) these declarations will be included in the -# documentation. - -HIDE_FRIEND_COMPOUNDS = NO - -# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any -# documentation blocks found inside the body of a function. -# If set to NO (the default) these blocks will be appended to the -# function's detailed documentation block. - -HIDE_IN_BODY_DOCS = NO - -# The INTERNAL_DOCS tag determines if documentation -# that is typed after a \internal command is included. If the tag is set -# to NO (the default) then the documentation will be excluded. -# Set it to YES to include the internal documentation. - -INTERNAL_DOCS = NO - -# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate -# file names in lower-case letters. If set to YES upper-case letters are also -# allowed. This is useful if you have classes or files whose names only differ -# in case and if your file system supports case sensitive file names. Windows -# and Mac users are advised to set this option to NO. - -CASE_SENSE_NAMES = YES - -# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen -# will show members with their full class and namespace scopes in the -# documentation. If set to YES the scope will be hidden. - -HIDE_SCOPE_NAMES = NO - -# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen -# will put a list of the files that are included by a file in the documentation -# of that file. - -SHOW_INCLUDE_FILES = YES - -# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] -# is inserted in the documentation for inline members. - -INLINE_INFO = YES - -# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen -# will sort the (detailed) documentation of file and class members -# alphabetically by member name. If set to NO the members will appear in -# declaration order. - -SORT_MEMBER_DOCS = YES - -# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the -# brief documentation of file, namespace and class members alphabetically -# by member name. If set to NO (the default) the members will appear in -# declaration order. - -SORT_BRIEF_DOCS = NO - -# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the -# hierarchy of group names into alphabetical order. If set to NO (the default) -# the group names will appear in their defined order. - -SORT_GROUP_NAMES = NO - -# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be -# sorted by fully-qualified names, including namespaces. If set to -# NO (the default), the class list will be sorted only by class name, -# not including the namespace part. -# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. -# Note: This option applies only to the class list, not to the -# alphabetical list. - -SORT_BY_SCOPE_NAME = NO - -# The GENERATE_TODOLIST tag can be used to enable (YES) or -# disable (NO) the todo list. This list is created by putting \todo -# commands in the documentation. - -GENERATE_TODOLIST = YES - -# The GENERATE_TESTLIST tag can be used to enable (YES) or -# disable (NO) the test list. This list is created by putting \test -# commands in the documentation. - -GENERATE_TESTLIST = YES - -# The GENERATE_BUGLIST tag can be used to enable (YES) or -# disable (NO) the bug list. This list is created by putting \bug -# commands in the documentation. - -GENERATE_BUGLIST = YES - -# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or -# disable (NO) the deprecated list. This list is created by putting -# \deprecated commands in the documentation. - -GENERATE_DEPRECATEDLIST= YES - -# The ENABLED_SECTIONS tag can be used to enable conditional -# documentation sections, marked by \if sectionname ... \endif. - -ENABLED_SECTIONS = - -# The MAX_INITIALIZER_LINES tag determines the maximum number of lines -# the initial value of a variable or define consists of for it to appear in -# the documentation. If the initializer consists of more lines than specified -# here it will be hidden. Use a value of 0 to hide initializers completely. -# The appearance of the initializer of individual variables and defines in the -# documentation can be controlled using \showinitializer or \hideinitializer -# command in the documentation regardless of this setting. - -MAX_INITIALIZER_LINES = 30 - -# Set the SHOW_USED_FILES tag to NO to disable the list of files generated -# at the bottom of the documentation of classes and structs. If set to YES the -# list will mention the files that were used to generate the documentation. - -SHOW_USED_FILES = YES - -# If the sources in your project are distributed over multiple directories -# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy -# in the documentation. The default is NO. - -SHOW_DIRECTORIES = NO - -# The FILE_VERSION_FILTER tag can be used to specify a program or script that -# doxygen should invoke to get the current version for each file (typically from -# the version control system). Doxygen will invoke the program by executing (via -# popen()) the command , where is the value of -# the FILE_VERSION_FILTER tag, and is the name of an input file -# provided by doxygen. Whatever the program writes to standard output -# is used as the file version. See the manual for examples. - -FILE_VERSION_FILTER = - -#--------------------------------------------------------------------------- -# configuration options related to warning and progress messages -#--------------------------------------------------------------------------- - -# The QUIET tag can be used to turn on/off the messages that are generated -# by doxygen. Possible values are YES and NO. If left blank NO is used. - -QUIET = NO - -# The WARNINGS tag can be used to turn on/off the warning messages that are -# generated by doxygen. Possible values are YES and NO. If left blank -# NO is used. - -WARNINGS = YES - -# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings -# for undocumented members. If EXTRACT_ALL is set to YES then this flag will -# automatically be disabled. - -WARN_IF_UNDOCUMENTED = YES - -# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for -# potential errors in the documentation, such as not documenting some -# parameters in a documented function, or documenting parameters that -# don't exist or using markup commands wrongly. - -WARN_IF_DOC_ERROR = YES - -# This WARN_NO_PARAMDOC option can be abled to get warnings for -# functions that are documented, but have no documentation for their parameters -# or return value. If set to NO (the default) doxygen will only warn about -# wrong or incomplete parameter documentation, but not about the absence of -# documentation. - -WARN_NO_PARAMDOC = NO - -# The WARN_FORMAT tag determines the format of the warning messages that -# doxygen can produce. The string should contain the $file, $line, and $text -# tags, which will be replaced by the file and line number from which the -# warning originated and the warning text. Optionally the format may contain -# $version, which will be replaced by the version of the file (if it could -# be obtained via FILE_VERSION_FILTER) - -WARN_FORMAT = "$file:$line: $text" - -# The WARN_LOGFILE tag can be used to specify a file to which warning -# and error messages should be written. If left blank the output is written -# to stderr. - -WARN_LOGFILE = - -#--------------------------------------------------------------------------- -# configuration options related to the input files -#--------------------------------------------------------------------------- - -# The INPUT tag can be used to specify the files and/or directories that contain -# documented source files. You may enter file names like "myfile.cpp" or -# directories like "/usr/src/myproject". Separate the files or directories -# with spaces. - -INPUT = ../OpenSim - -# This tag can be used to specify the character encoding of the source files -# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is -# also the default input encoding. Doxygen uses libiconv (or the iconv built -# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for -# the list of possible encodings. - -INPUT_ENCODING = UTF-8 - -# If the value of the INPUT tag contains directories, you can use the -# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp -# and *.h) to filter out the source-files in the directories. If left -# blank the following patterns are tested: -# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx -# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 - -FILE_PATTERNS = - -# The RECURSIVE tag can be used to turn specify whether or not subdirectories -# should be searched for input files as well. Possible values are YES and NO. -# If left blank NO is used. - -RECURSIVE = YES - -# The EXCLUDE tag can be used to specify files and/or directories that should -# excluded from the INPUT source files. This way you can easily exclude a -# subdirectory from a directory tree whose root is specified with the INPUT tag. - -EXCLUDE = - -# The EXCLUDE_SYMLINKS tag can be used select whether or not files or -# directories that are symbolic links (a Unix filesystem feature) are excluded -# from the input. - -EXCLUDE_SYMLINKS = NO - -# If the value of the INPUT tag contains directories, you can use the -# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude -# certain files from those directories. Note that the wildcards are matched -# against the file with absolute path, so to exclude all test directories -# for example use the pattern */test/* - -EXCLUDE_PATTERNS = - -# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names -# (namespaces, classes, functions, etc.) that should be excluded from the -# output. The symbol name can be a fully qualified name, a word, or if the -# wildcard * is used, a substring. Examples: ANamespace, AClass, -# AClass::ANamespace, ANamespace::*Test - -EXCLUDE_SYMBOLS = - -# The EXAMPLE_PATH tag can be used to specify one or more files or -# directories that contain example code fragments that are included (see -# the \include command). - -EXAMPLE_PATH = - -# If the value of the EXAMPLE_PATH tag contains directories, you can use the -# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp -# and *.h) to filter out the source-files in the directories. If left -# blank all files are included. - -EXAMPLE_PATTERNS = - -# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be -# searched for input files to be used with the \include or \dontinclude -# commands irrespective of the value of the RECURSIVE tag. -# Possible values are YES and NO. If left blank NO is used. - -EXAMPLE_RECURSIVE = NO - -# The IMAGE_PATH tag can be used to specify one or more files or -# directories that contain image that are included in the documentation (see -# the \image command). - -IMAGE_PATH = - -# The INPUT_FILTER tag can be used to specify a program that doxygen should -# invoke to filter for each input file. Doxygen will invoke the filter program -# by executing (via popen()) the command , where -# is the value of the INPUT_FILTER tag, and is the name of an -# input file. Doxygen will then use the output that the filter program writes -# to standard output. If FILTER_PATTERNS is specified, this tag will be -# ignored. - -INPUT_FILTER = - -# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern -# basis. Doxygen will compare the file name with each pattern and apply the -# filter if there is a match. The filters are a list of the form: -# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further -# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER -# is applied to all files. - -FILTER_PATTERNS = - -# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using -# INPUT_FILTER) will be used to filter the input files when producing source -# files to browse (i.e. when SOURCE_BROWSER is set to YES). - -FILTER_SOURCE_FILES = NO - -#--------------------------------------------------------------------------- -# configuration options related to source browsing -#--------------------------------------------------------------------------- - -# If the SOURCE_BROWSER tag is set to YES then a list of source files will -# be generated. Documented entities will be cross-referenced with these sources. -# Note: To get rid of all source code in the generated output, make sure also -# VERBATIM_HEADERS is set to NO. - -SOURCE_BROWSER = NO - -# Setting the INLINE_SOURCES tag to YES will include the body -# of functions and classes directly in the documentation. - -INLINE_SOURCES = NO - -# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct -# doxygen to hide any special comment blocks from generated source code -# fragments. Normal C and C++ comments will always remain visible. - -STRIP_CODE_COMMENTS = YES - -# If the REFERENCED_BY_RELATION tag is set to YES (the default) -# then for each documented function all documented -# functions referencing it will be listed. - -REFERENCED_BY_RELATION = NO - -# If the REFERENCES_RELATION tag is set to YES (the default) -# then for each documented function all documented entities -# called/used by that function will be listed. - -REFERENCES_RELATION = NO - -# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) -# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from -# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will -# link to the source code. Otherwise they will link to the documentstion. - -REFERENCES_LINK_SOURCE = YES - -# If the USE_HTAGS tag is set to YES then the references to source code -# will point to the HTML generated by the htags(1) tool instead of doxygen -# built-in source browser. The htags tool is part of GNU's global source -# tagging system (see http://www.gnu.org/software/global/global.html). You -# will need version 4.8.6 or higher. - -USE_HTAGS = NO - -# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen -# will generate a verbatim copy of the header file for each class for -# which an include is specified. Set to NO to disable this. - -VERBATIM_HEADERS = YES - -#--------------------------------------------------------------------------- -# configuration options related to the alphabetical class index -#--------------------------------------------------------------------------- - -# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index -# of all compounds will be generated. Enable this if the project -# contains a lot of classes, structs, unions or interfaces. - -ALPHABETICAL_INDEX = NO - -# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then -# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns -# in which this list will be split (can be a number in the range [1..20]) - -COLS_IN_ALPHA_INDEX = 5 - -# In case all classes in a project start with a common prefix, all -# classes will be put under the same header in the alphabetical index. -# The IGNORE_PREFIX tag can be used to specify one or more prefixes that -# should be ignored while generating the index headers. - -IGNORE_PREFIX = - -#--------------------------------------------------------------------------- -# configuration options related to the HTML output -#--------------------------------------------------------------------------- - -# If the GENERATE_HTML tag is set to YES (the default) Doxygen will -# generate HTML output. - -GENERATE_HTML = YES - -# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `html' will be used as the default path. - -HTML_OUTPUT = html - -# The HTML_FILE_EXTENSION tag can be used to specify the file extension for -# each generated HTML page (for example: .htm,.php,.asp). If it is left blank -# doxygen will generate files with .html extension. - -HTML_FILE_EXTENSION = .html - -# The HTML_HEADER tag can be used to specify a personal HTML header for -# each generated HTML page. If it is left blank doxygen will generate a -# standard header. - -HTML_HEADER = - -# The HTML_FOOTER tag can be used to specify a personal HTML footer for -# each generated HTML page. If it is left blank doxygen will generate a -# standard footer. - -HTML_FOOTER = - -# The HTML_STYLESHEET tag can be used to specify a user-defined cascading -# style sheet that is used by each HTML page. It can be used to -# fine-tune the look of the HTML output. If the tag is left blank doxygen -# will generate a default style sheet. Note that doxygen will try to copy -# the style sheet file to the HTML output directory, so don't put your own -# stylesheet in the HTML output directory as well, or it will be erased! - -HTML_STYLESHEET = - -# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, -# files or namespaces will be aligned in HTML using tables. If set to -# NO a bullet list will be used. - -HTML_ALIGN_MEMBERS = YES - -# If the GENERATE_HTMLHELP tag is set to YES, additional index files -# will be generated that can be used as input for tools like the -# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) -# of the generated HTML documentation. - -GENERATE_HTMLHELP = NO - -# If the GENERATE_DOCSET tag is set to YES, additional index files -# will be generated that can be used as input for Apple's Xcode 3 -# integrated development environment, introduced with OSX 10.5 (Leopard). -# To create a documentation set, doxygen will generate a Makefile in the -# HTML output directory. Running make will produce the docset in that -# directory and running "make install" will install the docset in -# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find -# it at startup. - -GENERATE_DOCSET = NO - -# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the -# feed. A documentation feed provides an umbrella under which multiple -# documentation sets from a single provider (such as a company or product suite) -# can be grouped. - -DOCSET_FEEDNAME = "Doxygen generated docs" - -# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that -# should uniquely identify the documentation set bundle. This should be a -# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen -# will append .docset to the name. - -DOCSET_BUNDLE_ID = org.doxygen.Project - -# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML -# documentation will contain sections that can be hidden and shown after the -# page has loaded. For this to work a browser that supports -# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox -# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). - -HTML_DYNAMIC_SECTIONS = NO - -# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can -# be used to specify the file name of the resulting .chm file. You -# can add a path in front of the file if the result should not be -# written to the html output directory. - -CHM_FILE = - -# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can -# be used to specify the location (absolute path including file name) of -# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run -# the HTML help compiler on the generated index.hhp. - -HHC_LOCATION = - -# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag -# controls if a separate .chi index file is generated (YES) or that -# it should be included in the master .chm file (NO). - -GENERATE_CHI = NO - -# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag -# controls whether a binary table of contents is generated (YES) or a -# normal table of contents (NO) in the .chm file. - -BINARY_TOC = NO - -# The TOC_EXPAND flag can be set to YES to add extra items for group members -# to the contents of the HTML help documentation and to the tree view. - -TOC_EXPAND = NO - -# The DISABLE_INDEX tag can be used to turn on/off the condensed index at -# top of each HTML page. The value NO (the default) enables the index and -# the value YES disables it. - -DISABLE_INDEX = NO - -# This tag can be used to set the number of enum values (range [1..20]) -# that doxygen will group on one line in the generated HTML documentation. - -ENUM_VALUES_PER_LINE = 4 - -# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be -# generated containing a tree-like index structure (just like the one that -# is generated for HTML Help). For this to work a browser that supports -# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, -# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are -# probably better off using the HTML help feature. - -GENERATE_TREEVIEW = NO - -# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be -# used to set the initial width (in pixels) of the frame in which the tree -# is shown. - -TREEVIEW_WIDTH = 250 - -#--------------------------------------------------------------------------- -# configuration options related to the LaTeX output -#--------------------------------------------------------------------------- - -# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will -# generate Latex output. - -GENERATE_LATEX = NO - -# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `latex' will be used as the default path. - -LATEX_OUTPUT = latex - -# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be -# invoked. If left blank `latex' will be used as the default command name. - -LATEX_CMD_NAME = latex - -# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to -# generate index for LaTeX. If left blank `makeindex' will be used as the -# default command name. - -MAKEINDEX_CMD_NAME = makeindex - -# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact -# LaTeX documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_LATEX = NO - -# The PAPER_TYPE tag can be used to set the paper type that is used -# by the printer. Possible values are: a4, a4wide, letter, legal and -# executive. If left blank a4wide will be used. - -PAPER_TYPE = a4wide - -# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX -# packages that should be included in the LaTeX output. - -EXTRA_PACKAGES = - -# The LATEX_HEADER tag can be used to specify a personal LaTeX header for -# the generated latex document. The header should contain everything until -# the first chapter. If it is left blank doxygen will generate a -# standard header. Notice: only use this tag if you know what you are doing! - -LATEX_HEADER = - -# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated -# is prepared for conversion to pdf (using ps2pdf). The pdf file will -# contain links (just like the HTML output) instead of page references -# This makes the output suitable for online browsing using a pdf viewer. - -PDF_HYPERLINKS = YES - -# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of -# plain latex in the generated Makefile. Set this option to YES to get a -# higher quality PDF documentation. - -USE_PDFLATEX = YES - -# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. -# command to the generated LaTeX files. This will instruct LaTeX to keep -# running if errors occur, instead of asking the user for help. -# This option is also used when generating formulas in HTML. - -LATEX_BATCHMODE = NO - -# If LATEX_HIDE_INDICES is set to YES then doxygen will not -# include the index chapters (such as File Index, Compound Index, etc.) -# in the output. - -LATEX_HIDE_INDICES = NO - -#--------------------------------------------------------------------------- -# configuration options related to the RTF output -#--------------------------------------------------------------------------- - -# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output -# The RTF output is optimized for Word 97 and may not look very pretty with -# other RTF readers or editors. - -GENERATE_RTF = NO - -# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `rtf' will be used as the default path. - -RTF_OUTPUT = rtf - -# If the COMPACT_RTF tag is set to YES Doxygen generates more compact -# RTF documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_RTF = NO - -# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated -# will contain hyperlink fields. The RTF file will -# contain links (just like the HTML output) instead of page references. -# This makes the output suitable for online browsing using WORD or other -# programs which support those fields. -# Note: wordpad (write) and others do not support links. - -RTF_HYPERLINKS = NO - -# Load stylesheet definitions from file. Syntax is similar to doxygen's -# config file, i.e. a series of assignments. You only have to provide -# replacements, missing definitions are set to their default value. - -RTF_STYLESHEET_FILE = - -# Set optional variables used in the generation of an rtf document. -# Syntax is similar to doxygen's config file. - -RTF_EXTENSIONS_FILE = - -#--------------------------------------------------------------------------- -# configuration options related to the man page output -#--------------------------------------------------------------------------- - -# If the GENERATE_MAN tag is set to YES (the default) Doxygen will -# generate man pages - -GENERATE_MAN = NO - -# The MAN_OUTPUT tag is used to specify where the man pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `man' will be used as the default path. - -MAN_OUTPUT = man - -# The MAN_EXTENSION tag determines the extension that is added to -# the generated man pages (default is the subroutine's section .3) - -MAN_EXTENSION = .3 - -# If the MAN_LINKS tag is set to YES and Doxygen generates man output, -# then it will generate one additional man file for each entity -# documented in the real man page(s). These additional files -# only source the real man page, but without them the man command -# would be unable to find the correct page. The default is NO. - -MAN_LINKS = NO - -#--------------------------------------------------------------------------- -# configuration options related to the XML output -#--------------------------------------------------------------------------- - -# If the GENERATE_XML tag is set to YES Doxygen will -# generate an XML file that captures the structure of -# the code including all documentation. - -GENERATE_XML = NO - -# The XML_OUTPUT tag is used to specify where the XML pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `xml' will be used as the default path. - -XML_OUTPUT = xml - -# The XML_SCHEMA tag can be used to specify an XML schema, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_SCHEMA = - -# The XML_DTD tag can be used to specify an XML DTD, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_DTD = - -# If the XML_PROGRAMLISTING tag is set to YES Doxygen will -# dump the program listings (including syntax highlighting -# and cross-referencing information) to the XML output. Note that -# enabling this will significantly increase the size of the XML output. - -XML_PROGRAMLISTING = YES - -#--------------------------------------------------------------------------- -# configuration options for the AutoGen Definitions output -#--------------------------------------------------------------------------- - -# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will -# generate an AutoGen Definitions (see autogen.sf.net) file -# that captures the structure of the code including all -# documentation. Note that this feature is still experimental -# and incomplete at the moment. - -GENERATE_AUTOGEN_DEF = NO - -#--------------------------------------------------------------------------- -# configuration options related to the Perl module output -#--------------------------------------------------------------------------- - -# If the GENERATE_PERLMOD tag is set to YES Doxygen will -# generate a Perl module file that captures the structure of -# the code including all documentation. Note that this -# feature is still experimental and incomplete at the -# moment. - -GENERATE_PERLMOD = NO - -# If the PERLMOD_LATEX tag is set to YES Doxygen will generate -# the necessary Makefile rules, Perl scripts and LaTeX code to be able -# to generate PDF and DVI output from the Perl module output. - -PERLMOD_LATEX = NO - -# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be -# nicely formatted so it can be parsed by a human reader. This is useful -# if you want to understand what is going on. On the other hand, if this -# tag is set to NO the size of the Perl module output will be much smaller -# and Perl will parse it just the same. - -PERLMOD_PRETTY = YES - -# The names of the make variables in the generated doxyrules.make file -# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. -# This is useful so different doxyrules.make files included by the same -# Makefile don't overwrite each other's variables. - -PERLMOD_MAKEVAR_PREFIX = - -#--------------------------------------------------------------------------- -# Configuration options related to the preprocessor -#--------------------------------------------------------------------------- - -# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will -# evaluate all C-preprocessor directives found in the sources and include -# files. - -ENABLE_PREPROCESSING = YES - -# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro -# names in the source code. If set to NO (the default) only conditional -# compilation will be performed. Macro expansion can be done in a controlled -# way by setting EXPAND_ONLY_PREDEF to YES. - -MACRO_EXPANSION = NO - -# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES -# then the macro expansion is limited to the macros specified with the -# PREDEFINED and EXPAND_AS_DEFINED tags. - -EXPAND_ONLY_PREDEF = NO - -# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files -# in the INCLUDE_PATH (see below) will be search if a #include is found. - -SEARCH_INCLUDES = YES - -# The INCLUDE_PATH tag can be used to specify one or more directories that -# contain include files that are not input files but should be processed by -# the preprocessor. - -INCLUDE_PATH = - -# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard -# patterns (like *.h and *.hpp) to filter out the header-files in the -# directories. If left blank, the patterns specified with FILE_PATTERNS will -# be used. - -INCLUDE_FILE_PATTERNS = - -# The PREDEFINED tag can be used to specify one or more macro names that -# are defined before the preprocessor is started (similar to the -D option of -# gcc). The argument of the tag is a list of macros of the form: name -# or name=definition (no spaces). If the definition and the = are -# omitted =1 is assumed. To prevent a macro definition from being -# undefined via #undef or recursively expanded use the := operator -# instead of the = operator. - -PREDEFINED = - -# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then -# this tag can be used to specify a list of macro names that should be expanded. -# The macro definition that is found in the sources will be used. -# Use the PREDEFINED tag if you want to use a different macro definition. - -EXPAND_AS_DEFINED = - -# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then -# doxygen's preprocessor will remove all function-like macros that are alone -# on a line, have an all uppercase name, and do not end with a semicolon. Such -# function macros are typically used for boiler-plate code, and will confuse -# the parser if not removed. - -SKIP_FUNCTION_MACROS = YES - -#--------------------------------------------------------------------------- -# Configuration::additions related to external references -#--------------------------------------------------------------------------- - -# The TAGFILES option can be used to specify one or more tagfiles. -# Optionally an initial location of the external documentation -# can be added for each tagfile. The format of a tag file without -# this location is as follows: -# TAGFILES = file1 file2 ... -# Adding location for the tag files is done as follows: -# TAGFILES = file1=loc1 "file2 = loc2" ... -# where "loc1" and "loc2" can be relative or absolute paths or -# URLs. If a location is present for each tag, the installdox tool -# does not have to be run to correct the links. -# Note that each tag file must have a unique name -# (where the name does NOT include the path) -# If a tag file is not located in the directory in which doxygen -# is run, you must also specify the path to the tagfile here. - -TAGFILES = - -# When a file name is specified after GENERATE_TAGFILE, doxygen will create -# a tag file that is based on the input files it reads. - -GENERATE_TAGFILE = - -# If the ALLEXTERNALS tag is set to YES all external classes will be listed -# in the class index. If set to NO only the inherited external classes -# will be listed. - -ALLEXTERNALS = NO - -# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed -# in the modules index. If set to NO, only the current project's groups will -# be listed. - -EXTERNAL_GROUPS = YES - -# The PERL_PATH should be the absolute path and name of the perl script -# interpreter (i.e. the result of `which perl'). - -PERL_PATH = /usr/bin/perl - -#--------------------------------------------------------------------------- -# Configuration options related to the dot tool -#--------------------------------------------------------------------------- - -# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will -# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base -# or super classes. Setting the tag to NO turns the diagrams off. Note that -# this option is superseded by the HAVE_DOT option below. This is only a -# fallback. It is recommended to install and use dot, since it yields more -# powerful graphs. - -CLASS_DIAGRAMS = YES - -# You can define message sequence charts within doxygen comments using the \msc -# command. Doxygen will then run the mscgen tool (see -# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the -# documentation. The MSCGEN_PATH tag allows you to specify the directory where -# the mscgen tool resides. If left empty the tool is assumed to be found in the -# default search path. - -MSCGEN_PATH = - -# If set to YES, the inheritance and collaboration graphs will hide -# inheritance and usage relations if the target is undocumented -# or is not a class. - -HIDE_UNDOC_RELATIONS = YES - -# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is -# available from the path. This tool is part of Graphviz, a graph visualization -# toolkit from AT&T and Lucent Bell Labs. The other options in this section -# have no effect if this option is set to NO (the default) - -HAVE_DOT = NO - -# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect inheritance relations. Setting this tag to YES will force the -# the CLASS_DIAGRAMS tag to NO. - -CLASS_GRAPH = YES - -# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect implementation dependencies (inheritance, containment, and -# class references variables) of the class with other documented classes. - -COLLABORATION_GRAPH = YES - -# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for groups, showing the direct groups dependencies - -GROUP_GRAPHS = YES - -# If the UML_LOOK tag is set to YES doxygen will generate inheritance and -# collaboration diagrams in a style similar to the OMG's Unified Modeling -# Language. - -UML_LOOK = NO - -# If set to YES, the inheritance and collaboration graphs will show the -# relations between templates and their instances. - -TEMPLATE_RELATIONS = NO - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT -# tags are set to YES then doxygen will generate a graph for each documented -# file showing the direct and indirect include dependencies of the file with -# other documented files. - -INCLUDE_GRAPH = YES - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and -# HAVE_DOT tags are set to YES then doxygen will generate a graph for each -# documented header file showing the documented files that directly or -# indirectly include this file. - -INCLUDED_BY_GRAPH = YES - -# If the CALL_GRAPH and HAVE_DOT options are set to YES then -# doxygen will generate a call dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable call graphs -# for selected functions only using the \callgraph command. - -CALL_GRAPH = NO - -# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then -# doxygen will generate a caller dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable caller -# graphs for selected functions only using the \callergraph command. - -CALLER_GRAPH = NO - -# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen -# will graphical hierarchy of all classes instead of a textual one. - -GRAPHICAL_HIERARCHY = YES - -# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES -# then doxygen will show the dependencies a directory has on other directories -# in a graphical way. The dependency relations are determined by the #include -# relations between the files in the directories. - -DIRECTORY_GRAPH = YES - -# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images -# generated by dot. Possible values are png, jpg, or gif -# If left blank png will be used. - -DOT_IMAGE_FORMAT = png - -# The tag DOT_PATH can be used to specify the path where the dot tool can be -# found. If left blank, it is assumed the dot tool can be found in the path. - -DOT_PATH = - -# The DOTFILE_DIRS tag can be used to specify one or more directories that -# contain dot files that are included in the documentation (see the -# \dotfile command). - -DOTFILE_DIRS = - -# The MAX_DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of -# nodes that will be shown in the graph. If the number of nodes in a graph -# becomes larger than this value, doxygen will truncate the graph, which is -# visualized by representing a node as a red box. Note that doxygen if the -# number of direct children of the root node in a graph is already larger than -# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note -# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. - -DOT_GRAPH_MAX_NODES = 50 - -# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the -# graphs generated by dot. A depth value of 3 means that only nodes reachable -# from the root by following a path via at most 3 edges will be shown. Nodes -# that lay further from the root node will be omitted. Note that setting this -# option to 1 or 2 may greatly reduce the computation time needed for large -# code bases. Also note that the size of a graph can be further restricted by -# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. - -MAX_DOT_GRAPH_DEPTH = 0 - -# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent -# background. This is enabled by default, which results in a transparent -# background. Warning: Depending on the platform used, enabling this option -# may lead to badly anti-aliased labels on the edges of a graph (i.e. they -# become hard to read). - -DOT_TRANSPARENT = YES - -# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output -# files in one run (i.e. multiple -o and -T options on the command line). This -# makes dot run faster, but since only newer versions of dot (>1.8.10) -# support this, this feature is disabled by default. - -DOT_MULTI_TARGETS = NO - -# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will -# generate a legend page explaining the meaning of the various boxes and -# arrows in the dot generated graphs. - -GENERATE_LEGEND = YES - -# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will -# remove the intermediate dot files that are used to generate -# the various graphs. - -DOT_CLEANUP = YES - -#--------------------------------------------------------------------------- -# Configuration::additions related to the search engine -#--------------------------------------------------------------------------- - -# The SEARCHENGINE tag specifies whether or not a search engine should be -# used. If set to NO the values of all tags below this one will be ignored. - -SEARCHENGINE = YES +# Doxyfile 1.5.5 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# http://www.gnu.org/software/libiconv for the list of possible encodings. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = OpenSim + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = SVN + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, +# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek, +# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish, +# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, +# and Ukrainian. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = YES + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like regular Qt-style comments +# (thus requiring an explicit @brief command for a brief description.) + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then Doxygen will +# interpret the first line (until the first dot) of a Qt-style +# comment as the brief description. If set to NO, the comments +# will behave just like regular Qt-style comments (thus requiring +# an explicit \brief command for a brief description.) + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java +# sources only. Doxygen will then generate output that is more tailored for +# Java. For instance, namespaces will be presented as packages, qualified +# scopes will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources only. Doxygen will then generate output that is more tailored for +# Fortran. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for +# VHDL. + +OPTIMIZE_OUTPUT_VHDL = NO + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should +# set this tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. +# func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. +# Doxygen will parse them like normal C++ but will assume all classes use public +# instead of private inheritance when no explicit protection keyword is present. + +SIP_SUPPORT = NO + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum +# is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically +# be useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. + +TYPEDEF_HIDES_STRUCT = NO + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base +# name of the file that contains the anonymous namespace. By default +# anonymous namespace are hidden. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the +# hierarchy of group names into alphabetical order. If set to NO (the default) +# the group names will appear in their defined order. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. The default is NO. + +SHOW_DIRECTORIES = NO + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the program writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = ../OpenSim + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is +# also the default input encoding. Doxygen uses libiconv (or the iconv built +# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for +# the list of possible encodings. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. Note that the wildcards are matched +# against the file with absolute path, so to exclude all test directories +# for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) +# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from +# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will +# link to the source code. Otherwise they will link to the documentstion. + +REFERENCES_LINK_SOURCE = YES + +# If the USE_HTAGS tag is set to YES then the references to source code +# will point to the HTML generated by the htags(1) tool instead of doxygen +# built-in source browser. The htags tool is part of GNU's global source +# tagging system (see http://www.gnu.org/software/global/global.html). You +# will need version 4.8.6 or higher. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_DOCSET tag is set to YES, additional index files +# will be generated that can be used as input for Apple's Xcode 3 +# integrated development environment, introduced with OSX 10.5 (Leopard). +# To create a documentation set, doxygen will generate a Makefile in the +# HTML output directory. Running make will produce the docset in that +# directory and running "make install" will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find +# it at startup. + +GENERATE_DOCSET = NO + +# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the +# feed. A documentation feed provides an umbrella under which multiple +# documentation sets from a single provider (such as a company or product suite) +# can be grouped. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that +# should uniquely identify the documentation set bundle. This should be a +# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen +# will append .docset to the name. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. For this to work a browser that supports +# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox +# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). + +HTML_DYNAMIC_SECTIONS = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_DEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see +# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT options are set to YES then +# doxygen will generate a call dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable call graphs +# for selected functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then +# doxygen will generate a caller dependency graph for every global function +# or class method. Note that enabling this option will significantly increase +# the time of a run. So in most cases it will be better to enable caller +# graphs for selected functions only using the \callergraph command. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of +# nodes that will be shown in the graph. If the number of nodes in a graph +# becomes larger than this value, doxygen will truncate the graph, which is +# visualized by representing a node as a red box. Note that doxygen if the +# number of direct children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note +# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is enabled by default, which results in a transparent +# background. Warning: Depending on the platform used, enabling this option +# may lead to badly anti-aliased labels on the edges of a graph (i.e. they +# become hard to read). + +DOT_TRANSPARENT = YES + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = YES diff --git a/update-svn-properties.py b/update-svn-properties.py index 8cb564d..01480e5 100755 --- a/update-svn-properties.py +++ b/update-svn-properties.py @@ -45,6 +45,7 @@ property_map = { ".build" : text, ".cfg" : text, ".cgi" : text, + ".conf" : text, ".config" : text, ".cs" : text, ".csproj" : text, -- cgit v1.1