|
@@ -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<YP.NameArity, Atom> _moduleForNameArity = new Dictionary<YP.NameArity, Atom>();
|
|
|
- public int _gensymCounter;
|
|
|
- public bool _useFinalCutCode;
|
|
|
- public Variable _finalCutCode;
|
|
|
- public bool _codeUsesYield;
|
|
|
- public Atom _determinism;
|
|
|
- // a list of '='(Name, Variable)
|
|
|
- public List<object> _variableNames;
|
|
|
-
|
|
|
- // Make these static functions that explicitly take the State so Prolog can call it.
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Make a new CompilerState and bind it to State.
|
|
|
- /// </summary>
|
|
|
- /// <param name="State"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IEnumerable<bool> 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);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 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.
|
|
|
- /// </summary>
|
|
|
- /// <param name="State"></param>
|
|
|
- /// <param name="rule"></param>
|
|
|
- /// <param name="variableNameSuggestions"></param>
|
|
|
- public static void newVariableNames(object State, object Rule, object VariableNameSuggestions)
|
|
|
- {
|
|
|
- State = YP.getValue(State);
|
|
|
- List<Variable> variablesSet = new List<Variable>();
|
|
|
- YP.addUniqueVariables(Rule, variablesSet);
|
|
|
-
|
|
|
- ((CompilerState)State)._variableNames = new List<object>();
|
|
|
- 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);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames
|
|
|
- /// for variable.
|
|
|
- /// </summary>
|
|
|
- /// <param name="variable">a Variable</param>
|
|
|
- /// <param name="State"></param>
|
|
|
- /// <param name="Result">the assigned Name</param>
|
|
|
- public static IEnumerable<bool> 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<bool> variableNamesList(object State, object VariableNamesList)
|
|
|
- {
|
|
|
- State = YP.getValue(State);
|
|
|
- return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames));
|
|
|
- }
|
|
|
-
|
|
|
- public static IEnumerable<bool> 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;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Return false if any of args is out, otherwise true.
|
|
|
- /// args is an array of ::(Type,Mode) where Mode is in or out.
|
|
|
- /// </summary>
|
|
|
- /// <param name="args"></param>
|
|
|
- /// <returns></returns>
|
|
|
- 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;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Use CodeDomProvider to compile the functionCode and return a YP.IClause.
|
|
|
- /// The function name must be "function" and have nArgs arguments.
|
|
|
- /// </summary>
|
|
|
- /// <param name="functionCode">the code for the iterator, such as
|
|
|
- /// "public static IEnumerable<bool> function() { yield return false; }"
|
|
|
- /// </param>
|
|
|
- /// <param name="nArgs">the number of args in the function</param>
|
|
|
- /// <param name="declaringClass">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</param>
|
|
|
- /// <returns>a new YP.IClause object on which you can call match(object[] args) where
|
|
|
- /// args length is nArgs</returns>
|
|
|
- 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool>")))
|
|
|
- {
|
|
|
- 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<bool>")))
|
|
|
- {
|
|
|
- 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<YP.NameArity, Atom> _moduleForNameArity = new Dictionary<YP.NameArity, Atom>();
|
|
|
+ public int _gensymCounter;
|
|
|
+ public bool _useFinalCutCode;
|
|
|
+ public Variable _finalCutCode;
|
|
|
+ public bool _codeUsesYield;
|
|
|
+ public Atom _determinism;
|
|
|
+ // a list of '='(Name, Variable)
|
|
|
+ public List<object> _variableNames;
|
|
|
+
|
|
|
+ // Make these static functions that explicitly take the State so Prolog can call it.
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Make a new CompilerState and bind it to State.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="State"></param>
|
|
|
+ /// <returns></returns>
|
|
|
+ public static IEnumerable<bool> 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// 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.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="State"></param>
|
|
|
+ /// <param name="rule"></param>
|
|
|
+ /// <param name="variableNameSuggestions"></param>
|
|
|
+ public static void newVariableNames(object State, object Rule, object VariableNameSuggestions)
|
|
|
+ {
|
|
|
+ State = YP.getValue(State);
|
|
|
+ List<Variable> variablesSet = new List<Variable>();
|
|
|
+ YP.addUniqueVariables(Rule, variablesSet);
|
|
|
+
|
|
|
+ ((CompilerState)State)._variableNames = new List<object>();
|
|
|
+ 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames
|
|
|
+ /// for variable.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="variable">a Variable</param>
|
|
|
+ /// <param name="State"></param>
|
|
|
+ /// <param name="Result">the assigned Name</param>
|
|
|
+ public static IEnumerable<bool> 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<bool> variableNamesList(object State, object VariableNamesList)
|
|
|
+ {
|
|
|
+ State = YP.getValue(State);
|
|
|
+ return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames));
|
|
|
+ }
|
|
|
+
|
|
|
+ public static IEnumerable<bool> 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;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Return false if any of args is out, otherwise true.
|
|
|
+ /// args is an array of ::(Type,Mode) where Mode is in or out.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="args"></param>
|
|
|
+ /// <returns></returns>
|
|
|
+ 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;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Use CodeDomProvider to compile the functionCode and return a YP.IClause.
|
|
|
+ /// The function name must be "function" and have nArgs arguments.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="functionCode">the code for the iterator, such as
|
|
|
+ /// "public static IEnumerable<bool> function() { yield return false; }"
|
|
|
+ /// </param>
|
|
|
+ /// <param name="nArgs">the number of args in the function</param>
|
|
|
+ /// <param name="declaringClass">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</param>
|
|
|
+ /// <returns>a new YP.IClause object on which you can call match(object[] args) where
|
|
|
+ /// args length is nArgs</returns>
|
|
|
+ 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool>")))
|
|
|
+ {
|
|
|
+ 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<bool>")))
|
|
|
+ {
|
|
|
+ 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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<bool> 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;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+}
|