/// <summary>
/// Parse goalString and yield for each Goal, setting VariableList to a list of
/// (variableAtom = Var).
/// </summary>
/// <param name="goalString"></param>
/// <param name="Goal"></param>
/// <param name="VariableList"></param>
/// <returns></returns>
static IEnumerable <bool> parseGoal(string goalString, object Goal, object VariableList)
{
// The parser requires a newline at the end.
YP.see(new StringReader(goalString + "\n"));
object TermList = new Variable();
// parseInput set TermList to a list of f(Goal, VariableList).
foreach (bool l1 in Parser.parseInput(TermList))
{
// Close the input now before yielding.
YP.seen();
// Iterate through each member of TermList.
for (TermList = YP.getValue(TermList);
TermList is Functor2 && ((Functor2)TermList)._name == Atom.DOT;
TermList = YP.getValue(((Functor2)TermList)._arg2))
{
// Unify the head of the list with f(Goal, VariableList).
foreach (bool l2 in YP.unify
(((Functor2)TermList)._arg1, new Functor2(Atom.F, Goal, VariableList)))
{
yield return(false);
}
}
yield break;
}
// Close the input in case parseInput failed.
YP.seen();
}
static void compileAndWrite(string prologCode)
{
YP.tell(Console.Out);
YP.see(new StringReader(prologCode));
Variable TermList = new Variable();
Variable PseudoCode = new Variable();
foreach (bool l1 in Parser.parseInput(TermList))
{
foreach (bool l2 in Compiler.makeFunctionPseudoCode
(TermList, PseudoCode))
{
Compiler.convertFunctionCSharp(PseudoCode);
}
}
YP.seen();
}
/// <summary>
/// Traduit le code Prolog d'une clause de Horn en fonction en C# et l'exécute à partir des prédicats contenus dans la base de données.
/// A utiliser uniquement dans un nouveau <see cref="AppDomain"/> sous peine de fuite de mémoire.
/// </summary>
/// <returns> Un objet <see cref="YP.IClause"/>, qui peut être manipulé pour obtenir une liste de concordance <see cref="IEnumerable{bool}"/> de la clause par rapport aux prédicats dans la base de données. </returns>
public void YPwriteAndCompile()
{
string codeToCorrect;
using (StringWriter sw = new StringWriter())
{
//Console.WriteLine("// Compiled code:" + ToPrologCode());
YP.tell(sw);
YP.see(new StringReader(ToPrologCode()));
Variable TermList = new Variable();
Variable PseudoCode = new Variable();
foreach (bool l1 in Parser.parseInput(TermList))
{
foreach (bool l2 in Compiler.makeFunctionPseudoCode
(TermList, PseudoCode))
{
Compiler.convertFunctionCSharp(PseudoCode);
}
}
YP.seen();
codeToCorrect = sw.ToString();
}
StringBuilder sb = new StringBuilder(codeToCorrect);
sb.Remove(0, 115);
int i = 0;
while (!sb.ToString().ToCharArray()[i].Equals('('))
{
i++;
}
sb.Remove(0, i);
sb.Insert(0, "public static IEnumerable<bool> function");
sb.Replace(head.name, "function");
string finalCode = sb.ToString();
clause = Compiler.compileAnonymousFunction(finalCode, head.arity, null);
}
static string GenCode(string myCode)
{
Variable TermList = new Variable();
Variable FunctionCode = new Variable();
string CS_code = "";
int cs_pointer = myCode.IndexOf("\n//cs");
if (cs_pointer > 0)
{
CS_code = myCode.Substring(cs_pointer); // CS code comes after
myCode = myCode.Substring(0, cs_pointer);
}
myCode.Replace("//yp", "%YPCode");
StringWriter myCS_SW = new StringWriter();
StringReader myCode_SR = new StringReader(" yp_nop_header_nop. \n " + myCode + "\n");
YP.see(myCode_SR);
YP.tell(myCS_SW);
//m_log.Debug("Mycode\n ===================================\n" + myCode+"\n");
// disable warning: don't see how we can code this differently short
// of rewriting the whole thing
#pragma warning disable 0168, 0219
foreach (bool l1 in Parser.parseInput(TermList))
{
foreach (bool l2 in YPCompiler.makeFunctionPseudoCode(TermList, FunctionCode))
{
// ListPair VFC = new ListPair(FunctionCode, new Variable());
//m_log.Debug("-------------------------")
//m_log.Debug(FunctionCode.ToString())
//m_log.Debug("-------------------------")
YPCompiler.convertFunctionCSharp(FunctionCode);
//YPCompiler.convertStringCodesCSharp(VFC);
}
}
#pragma warning restore 0168, 0219
YP.seen();
myCS_SW.Close();
YP.told();
StringBuilder bu = myCS_SW.GetStringBuilder();
string finalcode = "//YPEncoded\n" + bu.ToString();
// FIX script events (we're in the same script)
// 'YP.script_event(Atom.a(@"sayit"),' ==> 'sayit('
finalcode = Regex.Replace(finalcode,
@"YP.script_event\(Atom.a\(\@\""(.*?)""\)\,",
@"this.$1(",
RegexOptions.Compiled | RegexOptions.Singleline);
finalcode = Regex.Replace(finalcode,
@"YP.script_event\(Atom.a\(\""(.*?)""\)\,",
@"this.$1(",
RegexOptions.Compiled | RegexOptions.Singleline);
finalcode = Regex.Replace(finalcode,
@" static ",
@" ",
RegexOptions.Compiled | RegexOptions.Singleline);
finalcode = CS_code + "\n\r" + finalcode;
finalcode = Regex.Replace(finalcode,
@"PrologCallback",
@"public IEnumerable<bool> ",
RegexOptions.Compiled | RegexOptions.Singleline);
return(finalcode);
}