Esempio n. 1
0
        // Parse and generate a syntax tree
        protected void Parse()
        {
            ExprBuilder exprBuilder = new ExprBuilder();
            ExprNode    expr        = exprBuilder.Build(formula);

            formulaExpr = expr;
        }
    public static void Main()
    {
        // ((10 * 20) + 30)
        Expr expr = new ExprBuilder().Const(10).Mult(20).Plus(30).Build();

        expr.GenCode();
    }
Esempio n. 3
0
 public static ExprAnalyzer Rule <A>(ExprBuilder <A> builder, Parser <A> a)
 {
     return(parser => {
         var aVal = a(parser);
         if (aVal == null)
         {
             return null;
         }
         return analyzer => builder(analyzer, aVal);
     });
 }
Esempio n. 4
0
 public static ExprInfixAnalyzer Rule <A>(ExprBuilder <ExprBuilderObj, A> builder, int weight, Parser <A> a)
 {
     return(new ExprInfixAnalyzer((parser, left) => {
         var aVal = a(parser);
         if (aVal == null)
         {
             return null;
         }
         return analyzer => builder(analyzer, left, aVal);
     }, weight));
 }
Esempio n. 5
0
 public static ExprAnalyzer Rule <A, B>(ExprBuilder <A, B> builder, Parser <A> a, Parser <B> b)
 {
     return(parser => {
         var aVal = a(parser);
         if (aVal == null)
         {
             return null;
         }
         var bVal = b(parser);
         return analyzer => builder(analyzer, aVal, bVal);
     });
 }
Esempio n. 6
0
        private void Test(string text, string expectedNode, string expectedExpr)
        {
            Parser parser = new Parser();

            var root = parser.Parse(text);

            var actualNode = NodeToString(root);

            Assert.That(actualNode, Is.EqualTo(expectedNode));

            var expr = new ExprBuilder().Build(root);

            var actualExpr = ExprToString(expr);

            Assert.That(actualExpr, Is.EqualTo(expectedExpr));
        }
Esempio n. 7
0
 public ExprBuilderObj(ExprBuilder builder, Token firstToken)
 {
     this.builder    = builder;
     this.FirstToken = firstToken;
 }
Esempio n. 8
0
        private string Build(string text)
        {
            var tokeniser = new Parser();
            var builder = new ExprBuilder();

            var block = builder.Build(tokeniser.Parse(text));

            return ExprToString(block);
        }
Esempio n. 9
0
 ExprBuilder(ExprBuilder sub)
     : base(sub)
 {
     type = sub.type;
 }
Esempio n. 10
0
 public static ExprAnalyzer Rule(ExprBuilder builder, Token token)
 {
     return(parser => parser.TryConsume(token) ? builder : null);
 }
Esempio n. 11
0
 public ESRuntime()
 {
     eb      = new ExprBuilder(ep);
     context = ev.CreateContext();
 }
Esempio n. 12
0
 public static void SetUpClass(TestContext testContext)
 {
     context     = testContext;
     ExprBuilder = new ExprBuilder();
 }
Esempio n. 13
0
 static void Main(string[] args)
 {
     ep = new iExpr.Exprs.Program.EParse();
     ev = new iExpr.Exprs.Program.EEval();
     eb = new ExprBuilder(ep);
     Console.ForegroundColor = ConsoleColor.White;
     while (true)
     {
         Console.Write("> ");
         string s = Console.ReadLine();
         if (s == "exit")
         {
             return;
         }
         if (s == "cls")
         {
             Console.Clear(); continue;
         }
         if (s == "view")
         {
             foreach (var v in ev.Variables)
             {
                 Console.Write(v.Key + ",");
             }
             Console.WriteLine();
             continue;
         }
         if (s == "code")
         {
             try
             {
                 Console.Write("Input a file: ");
                 string path = Console.ReadLine();
                 if (File.Exists(path))
                 {
                     string code = File.ReadAllText(path);
                     var    e    = eb.GetExpr(code);
                     var    v    = ev.CreateContext().Evaluate(e);
                     Console.WriteLine(v);
                 }
                 else
                 {
                     Console.WriteLine("File not found.");
                 }
             }
             catch (Exception ex)
             {
                 Console.Write("Error: " + ex.Message);
             }
             continue;
         }
         try
         {
             Console.WriteLine(eval(s).ToString());
         }
         catch (Exception ex)
         {
             Console.WriteLine("Error: " + ex.Message);
         }
     }
 }