예제 #1
0
    /// <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();
    }
예제 #2
0
    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);
        }
예제 #4
0
        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);
        }