5665 lines
251 KiB
C#
5665 lines
251 KiB
C#
/*
|
|
* 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.Shared.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();
|
|
// disable warning: don't see how we can code this differently short
|
|
// of rewriting the whole thing
|
|
#pragma warning disable 0168
|
|
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;
|
|
}
|
|
}
|
|
#pragma warning restore 0168
|
|
|
|
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();
|
|
// disable warning: don't see how we can code this differently short
|
|
// of rewriting the whole thing
|
|
#pragma warning disable 0168
|
|
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;
|
|
}
|
|
}
|
|
#pragma warning restore 0168
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
// disable warning unused variables, the following code is
|
|
// infested with it.
|
|
#pragma warning disable 0168, 0219
|
|
|
|
/// <summary>
|
|
/// Use makeFunctionPseudoCode, convertFunctionCSharp and compileAnonymousFunction
|
|
/// to return an anonymous YP.IClause for the Head and Body of a rule clause.
|
|
/// </summary>
|
|
/// <param name="Head">a prolog term such as new Functor2("test1", X, Y).
|
|
/// Note that the name of the head is ignored.
|
|
/// </param>
|
|
/// <param name="Body">a prolog term such as
|
|
/// new Functor2(",", new Functor1(Atom.a("test2", Atom.a("")), X),
|
|
/// new Functor2("=", Y, X)).
|
|
/// This may not be null. (For a head-only clause, set the Body to Atom.a("true").
|
|
/// </param>
|
|
/// <param name="declaringClass">if not null, the code is compiled as a subclass of this class
|
|
/// to resolve references to the default module Atom.a("")</param>
|
|
/// <returns>a new YP.IClause object on which you can call match(object[] args) where
|
|
/// args length is the arity of the Head</returns>
|
|
public static YP.IClause compileAnonymousClause(object Head, object Body, Type declaringClass)
|
|
{
|
|
object[] args = YP.getFunctorArgs(Head);
|
|
// compileAnonymousFunction wants "function".
|
|
object Rule = new Functor2(Atom.RULE, Functor.make("function", args), Body);
|
|
object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL));
|
|
|
|
StringWriter functionCode = new StringWriter();
|
|
Variable SaveOutputStream = new Variable();
|
|
foreach (bool l1 in YP.current_output(SaveOutputStream))
|
|
{
|
|
try
|
|
{
|
|
YP.tell(functionCode);
|
|
Variable FunctionCode = new Variable();
|
|
foreach (bool l2 in makeFunctionPseudoCode(RuleList, FunctionCode))
|
|
{
|
|
if (YP.termEqual(FunctionCode, Atom.a("getDeclaringClass")))
|
|
// Ignore getDeclaringClass since we have access to the one passed in.
|
|
continue;
|
|
|
|
// Debug: should check if FunctionCode is a single call.
|
|
convertFunctionCSharp(FunctionCode);
|
|
}
|
|
YP.told();
|
|
}
|
|
finally
|
|
{
|
|
// Restore after calling tell.
|
|
YP.tell(SaveOutputStream.getValue());
|
|
}
|
|
}
|
|
return YPCompiler.compileAnonymousFunction
|
|
(functionCode.ToString(), args.Length, declaringClass);
|
|
}
|
|
|
|
/// <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 OpenSim.Region.ScriptEngine.Shared.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.
|
|
|
|
public class YPInnerClass { }
|
|
public static System.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(@"integer", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
|
|
CompilerState.assertPred(State, new Functor1(@"float", 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 Functor1(@"atomic", new Functor2(@"::", Atom.a(@"univ"), Atom.a(@"in"))), Atom.a(@"semidet"));
|
|
CompilerState.assertPred(State, new Functor1(@"compound", 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;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf8;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
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 append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf9:
|
|
cutIf8:
|
|
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 cutIf11;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf12;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf13;
|
|
}
|
|
foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf13:
|
|
cutIf12:
|
|
cutIf11:
|
|
{ }
|
|
}
|
|
goto cutIf10;
|
|
}
|
|
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 cutIf14;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
goto cutIf15;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
goto cutIf16;
|
|
}
|
|
foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf16:
|
|
cutIf15:
|
|
cutIf14:
|
|
{ }
|
|
}
|
|
cutIf10:
|
|
cutIf6:
|
|
{ }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
goto cutIf2;
|
|
}
|
|
foreach (bool l3 in YP.unify(Head, FirstRule))
|
|
{
|
|
CompilerState.startFunction(State, Head);
|
|
FindallAnswers findallAnswers17 = 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))
|
|
{
|
|
findallAnswers17.add();
|
|
}
|
|
}
|
|
foreach (bool l4 in findallAnswers17.result(ClauseBag))
|
|
{
|
|
foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList)))
|
|
{
|
|
foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames))
|
|
{
|
|
FindallAnswers findallAnswers18 = new FindallAnswers(MergedArgName);
|
|
foreach (bool l7 in member(ArgName, FunctionArgNames))
|
|
{
|
|
foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName))
|
|
{
|
|
findallAnswers18.add();
|
|
goto cutIf19;
|
|
}
|
|
foreach (bool l8 in YP.unify(MergedArgName, ArgName))
|
|
{
|
|
findallAnswers18.add();
|
|
}
|
|
cutIf19:
|
|
{ }
|
|
}
|
|
foreach (bool l7 in findallAnswers18.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 cutIf21;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf22;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf23;
|
|
}
|
|
foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf23:
|
|
cutIf22:
|
|
cutIf21:
|
|
{ }
|
|
}
|
|
goto cutIf20;
|
|
}
|
|
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 cutIf25;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf26;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode))
|
|
{
|
|
foreach (bool l14 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
goto cutIf27;
|
|
}
|
|
foreach (bool l12 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l13 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf27:
|
|
cutIf26:
|
|
cutIf25:
|
|
{ }
|
|
}
|
|
goto cutIf24;
|
|
}
|
|
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 cutIf28;
|
|
}
|
|
if (CompilerState.determinismEquals(State, Atom.a(@"detNoneOut")))
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
goto cutIf29;
|
|
}
|
|
if (CompilerState.codeUsesYield(State))
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
goto cutIf30;
|
|
}
|
|
foreach (bool l11 in append(BodyCode, new ListPair(new Functor2(@"foreach", new Functor2(@"call", Atom.a(@"YP.fail"), Atom.NIL), new ListPair(Atom.a(@"yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn))
|
|
{
|
|
foreach (bool l12 in YP.unify(FunctionCode, new Functor(@"function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn })))
|
|
{
|
|
yield return false;
|
|
}
|
|
}
|
|
cutIf30:
|
|
cutIf29:
|
|
cutIf28:
|
|
{ }
|
|
}
|
|
cutIf24:
|
|
cutIf20:
|
|
{ }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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))))
|
|
{
|
|
CompilerState.setCodeUsesYield(State);
|
|
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)))
|
|
{
|
|
CompilerState.setCodeUsesYield(State);
|
|
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 ATermCode = new Variable();
|
|
Variable BCode = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"asserta", A), B)))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.asserta"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode)))
|
|
{
|
|
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 ATermCode = new Variable();
|
|
Variable BCode = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor1(@"assertz", A), B)))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2(@"call", Atom.a(@"YP.assertz"), new ListPair(ATermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode)))
|
|
{
|
|
foreach (bool l4 in compileTerm(A, State, ATermCode))
|
|
{
|
|
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(@",", new Functor1(@"assert", A), B)))
|
|
{
|
|
foreach (bool l3 in compileRuleBody(new Functor2(@",", new Functor1(@"assertz", A), B), State, PseudoCode))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
object State = arg2;
|
|
Variable Goal = new Variable();
|
|
Variable Catcher = new Variable();
|
|
Variable Handler = new Variable();
|
|
Variable B = new Variable();
|
|
Variable CatchGoal = new Variable();
|
|
Variable GoalTermCode = new Variable();
|
|
Variable BCode = new Variable();
|
|
Variable CatcherTermCode = new Variable();
|
|
Variable HandlerAndBCode = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new Functor2(@",", new Functor3(@"catch", Goal, Catcher, Handler), B)))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor3(@"declare", Atom.a(@"YP.Catch"), CatchGoal, new Functor2(@"new", Atom.a(@"YP.Catch"), new ListPair(new Functor2(@"call", Atom.a(@"YP.getIterator"), new ListPair(GoalTermCode, new ListPair(new Functor2(@"call", Atom.a(@"getDeclaringClass"), Atom.NIL), Atom.NIL))), Atom.NIL))), new ListPair(new Functor2(@"foreach", new Functor1(@"var", CatchGoal), BCode), new ListPair(new Functor2(@"foreach", new Functor3(@"callMember", new Functor1(@"var", CatchGoal), Atom.a(@"unifyExceptionOrThrow"), new ListPair(CatcherTermCode, Atom.NIL)), HandlerAndBCode), Atom.NIL)))))
|
|
{
|
|
foreach (bool l4 in CompilerState.gensym(State, Atom.a(@"catchGoal"), CatchGoal))
|
|
{
|
|
foreach (bool l5 in compileTerm(Goal, State, GoalTermCode))
|
|
{
|
|
foreach (bool l6 in compileTerm(Catcher, State, CatcherTermCode))
|
|
{
|
|
foreach (bool l7 in compileRuleBody(B, State, BCode))
|
|
{
|
|
foreach (bool l8 in compileRuleBody(new Functor2(@",", Handler, B), State, HandlerAndBCode))
|
|
{
|
|
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 PseudoCode)
|
|
{
|
|
{
|
|
Variable FunctorName = new Variable();
|
|
Variable FunctorArgs = new Variable();
|
|
Variable x6 = new Variable();
|
|
Variable Arity = new Variable();
|
|
Variable CompiledArgs = new Variable();
|
|
Variable FunctionName = new Variable();
|
|
foreach (bool l2 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs)))
|
|
{
|
|
foreach (bool l3 in YP.functor(Functor_1, x6, Arity))
|
|
{
|
|
foreach (bool l4 in maplist_compileTerm(FunctorArgs, State, CompiledArgs))
|
|
{
|
|
foreach (bool l5 in functorCallFunctionName(State, FunctorName, Arity, FunctionName))
|
|
{
|
|
if (YP.termEqual(FunctionName, Atom.NIL))
|
|
{
|
|
foreach (bool l7 in YP.unify(PseudoCode, new Functor2(@"call", Atom.a(@"YP.matchDynamic"), new ListPair(new Functor2(@"call", Atom.a(@"Atom.a"), new ListPair(new Functor1(@"object", FunctorName), Atom.NIL)), new ListPair(new Functor1(@"objectArray", CompiledArgs), Atom.NIL)))))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
goto cutIf1;
|
|
}
|
|
foreach (bool l6 in YP.unify(PseudoCode, new Functor2(@"call", FunctionName, CompiledArgs)))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
cutIf1:
|
|
{ }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<bool> functorCallFunctionName(object arg1, object arg2, object arg3, object arg4)
|
|
{
|
|
{
|
|
object x1 = arg1;
|
|
object Name = arg2;
|
|
object Arity = arg3;
|
|
object FunctionName = arg4;
|
|
foreach (bool l2 in functorCallYPFunctionName(Name, Arity, FunctionName))
|
|
{
|
|
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;
|
|
foreach (bool l2 in YP.unify(arg4, Atom.NIL))
|
|
{
|
|
foreach (bool l3 in Atom.module(Name, Atom.NIL))
|
|
{
|
|
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 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;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
object _State = arg1;
|
|
object Name = arg2;
|
|
object _Arity = arg3;
|
|
object x4 = arg4;
|
|
YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"callable"), Name), Atom.a(@"Term is not callable")));
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<bool> functorCallYPFunctionName(object arg1, object arg2, object arg3)
|
|
{
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"=")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.unify")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"=..")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.univ")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"var")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.var")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"nonvar")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nonvar")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"arg")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 3))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.arg")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"functor")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 3))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.functor")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"repeat")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 0))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.repeat")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"get_code")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.get_code")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"current_op")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 3))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.current_op")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_length")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_length")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_concat")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 3))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_concat")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"sub_atom")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 5))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sub_atom")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom_codes")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom_codes")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"number_codes")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number_codes")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"copy_term")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.copy_term")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"sort")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.sort")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
// Manually included : script_event for callback to LSL/C#
|
|
|
|
//object x1 = arg1;
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"script_event")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.script_event")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"nl")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 0))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.nl")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"write")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.write")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"put_code")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.put_code")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"atom")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atom")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"integer")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.integer")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"float")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.isFloat")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"number")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.number")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"atomic")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.atomic")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"compound")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.compound")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"==")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termEqual")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"\==")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termNotEqual")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"@<")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThan")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"@=<")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termLessThanOrEqual")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThan")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"@>=")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 2))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.termGreaterThanOrEqual")))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
foreach (bool l2 in YP.unify(arg1, Atom.a(@"throw")))
|
|
{
|
|
foreach (bool l3 in YP.unify(arg2, 1))
|
|
{
|
|
foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.throwException")))
|
|
{
|
|
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();
|
|
Variable x12 = new Variable();
|
|
Variable Arity = 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;
|
|
}
|
|
}
|
|
foreach (bool l5 in YP.functor(Term, x12, Arity))
|
|
{
|
|
YP.throwException(new Functor2(@"error", new Functor2(@"type_error", Atom.a(@"evaluable"), new Functor2(@"/", Name, Arity)), 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(@"public class YPInnerClass {}"));
|
|
YP.nl();
|
|
YP.write(Atom.a(@"public 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;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
Variable Expression = new Variable();
|
|
Variable RestStatements = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
|
|
{
|
|
convertIndentationCSharp(Level);
|
|
YP.write(Atom.a(@"throw "));
|
|
convertExpressionCSharp(Expression);
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
object Level = arg2;
|
|
Variable Expression = new Variable();
|
|
Variable RestStatements = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
|
|
{
|
|
convertIndentationJavascript(Level);
|
|
YP.write(Atom.a(@"throw "));
|
|
convertExpressionJavascript(Expression);
|
|
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:
|
|
{ }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{
|
|
object Level = arg2;
|
|
object HasBreakableBlock = arg3;
|
|
Variable Expression = new Variable();
|
|
Variable RestStatements = new Variable();
|
|
foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1(@"throw", Expression), RestStatements)))
|
|
{
|
|
convertIndentationPython(Level);
|
|
YP.write(Atom.a(@"raise "));
|
|
convertExpressionPython(Expression);
|
|
YP.nl();
|
|
foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock))
|
|
{
|
|
yield return true;
|
|
yield break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#pragma warning restore 0168
|
|
|
|
}
|
|
}
|