Merge pull request sprache#23 from tibel/master

LinqyCalculator: additonal operators and math functions

Author: mikehadlow

src/LinqyCalculator/ExpressionParser.cs

@@ -1,12 +1,13 @@
 using System;
+using System.Linq;
 using System.Linq.Expressions;
 using Sprache;
 
 namespace LinqyCalculator
 {
     static class ExpressionParser
     {
-        public static Expression<Func<decimal>> ParseExpression(string text)
+        public static Expression<Func<double>> ParseExpression(string text)
         {
             return Lambda.Parse(text);
         }
@@ -20,23 +21,52 @@ static Parser<ExpressionType> Operator(string op, ExpressionType opType)
         static readonly Parser<ExpressionType> Subtract = Operator("-", ExpressionType.SubtractChecked);
         static readonly Parser<ExpressionType> Multiply = Operator("*", ExpressionType.MultiplyChecked);
         static readonly Parser<ExpressionType> Divide = Operator("/", ExpressionType.Divide);
+        static readonly Parser<ExpressionType> Modulo = Operator("%", ExpressionType.Modulo);
+        static readonly Parser<ExpressionType> Power = Operator("^", ExpressionType.Power);
+
+        static readonly Parser<Expression> Function =
+            from name in Parse.Letter.AtLeastOnce().Text()
+            from lparen in Parse.Char('(')
+            from expr in Parse.Ref(() => Expr).DelimitedBy(Parse.Char(',').Token())
+            from rparen in Parse.Char(')')
+            select CallFunction(name, expr.ToArray());
+
+        static Expression CallFunction(string name, Expression[] parameters)
+        {
+            var methodInfo = typeof (Math).GetMethod(name, parameters.Select(e => e.Type).ToArray());
+            if (methodInfo == null)
+                throw new ParseException(string.Format("Function '{0}({1})' does not exist.", name,
+                                                       string.Join(",", parameters.Select(e => e.Type.Name))));
+            
+            return Expression.Call(methodInfo, parameters);
+        }
 
         static readonly Parser<Expression> Constant =
-            (from d in Parse.Decimal.Token()
-             select (Expression)Expression.Constant(decimal.Parse(d))).Named("number");
+             Parse.Decimal
+             .Select(x => Expression.Constant(double.Parse(x)))
+             .Named("number");
 
         static readonly Parser<Expression> Factor =
-            ((from lparen in Parse.Char('(')
+            (from lparen in Parse.Char('(')
               from expr in Parse.Ref(() => Expr)
               from rparen in Parse.Char(')')
               select expr).Named("expression")
-             .XOr(Constant)).Token();
+             .XOr(Constant)
+             .XOr(Function);
 
-        static readonly Parser<Expression> Term = Parse.ChainOperator(Multiply.Or(Divide), Factor, Expression.MakeBinary);
+        static readonly Parser<Expression> Operand =
+            ((from sign in Parse.Char('-')
+              from factor in Factor
+              select Expression.Negate(factor)
+             ).XOr(Factor)).Token();
+
+        static readonly Parser<Expression> InnerTerm = Parse.ChainOperator(Power, Operand, Expression.MakeBinary);
+
+        static readonly Parser<Expression> Term = Parse.ChainOperator(Multiply.Or(Divide).Or(Modulo), InnerTerm, Expression.MakeBinary);
 
         static readonly Parser<Expression> Expr = Parse.ChainOperator(Add.Or(Subtract), Term, Expression.MakeBinary);
-        
-        static readonly Parser<Expression<Func<decimal>>> Lambda =
-            Expr.End().Select(body => Expression.Lambda<Func<decimal>>(body));
+
+        static readonly Parser<Expression<Func<double>>> Lambda =
+            Expr.End().Select(body => Expression.Lambda<Func<double>>(body));
     }
 }