Overload for And,Or operators. Custom Error messages.

README.markdown

@@ -34,6 +34,12 @@ You should install [Flee with NuGet](https://www.nuget.org/packages/Flee):
 Or via the .NET Core command line interface:
 
     dotnet add package Flee
+
+## NuGet Packages
+
+| Name  | NuGet |
+| :---  | :---  |
+| [Flee](https://www.nuget.org/packages/Flee)                       | [![Flee](https://img.shields.io/badge/nuget-v1.2.2-blue.svg)](https://www.nuget.org/packages/Flee)                 
 
 ## More information
 * [Examples](https://github.com/mparlak/Flee/wiki/Examples) to learn how to create and evaluate expressions.

nuget/flee.nuspec

@@ -3,7 +3,7 @@
   <metadata>
     <id>Flee</id>
     <title>Flee</title>
-    <version>1.0.7</version>
+    <version>1.2.1</version>
     <authors>Muhammet Parlak</authors>
     <owners>Muhammet Parlak</owners>
     <licenseUrl>https://github.com/mparlak/Flee</licenseUrl>
@@ -14,6 +14,13 @@
     <copyright>Copyright 2017</copyright>
     <tags>flee,expression evaluator,Expression Evaluator for c#</tags>
     <releaseNotes>
+      1.2.1
+      • Fix for IndexOutOfRange when running complex(?) formulas
+      • Update Arithmetic.cs
+      1.2.0
+      • new – digitally sign a strong named assembly
+      1.1.0
+      • new – added strong name key
       1.0.7
       • Fixed – Flee fails to parse "if" formula
       1.0.6

src/Flee.Net45/ExpressionElements/Base/Binary.cs

@@ -92,9 +92,10 @@ protected MethodInfo GetOverloadedBinaryOperator(string name, object operation)
             }
             else
             {
+                return leftMethod;
                 // Ambiguous call
-                base.ThrowAmbiguousCallException(leftType, rightType, operation);
-                return null;
+                //base.ThrowAmbiguousCallException(leftType, rightType, operation);
+                //return null;
             }
         }
 

src/Flee.Net45/ExpressionElements/Base/ExpressionElement.cs

@@ -36,7 +36,7 @@ protected void ThrowCompileException(string messageKey, CompileExceptionReason r
             string messageTemplate = FleeResourceManager.Instance.GetCompileErrorString(messageKey);
             string message = string.Format(messageTemplate, arguments);
             message = string.Concat(this.Name, ": ", message);
-            throw new ExpressionCompileException(message, reason);
+            throw new ExpressionCompileException(message, reason, arguments);
         }
 
         protected void ThrowAmbiguousCallException(Type leftType, Type rightType, object operation)

src/Flee.Net45/ExpressionElements/Compare.cs

@@ -24,7 +24,7 @@ public CompareElement()
         public void Initialize(ExpressionElement leftChild, ExpressionElement rightChild, LogicalCompareOperation op)
         {
             MyLeftChild = leftChild;
-            MyRightChild = (Int32LiteralElement)rightChild;
+            MyRightChild = rightChild;
             _myOperation = op;
         }
 

src/Flee.Net45/ExpressionElements/Conditional.cs

@@ -22,8 +22,8 @@ public ConditionalElement(ExpressionElement condition, ExpressionElement whenTru
             _myCondition = condition;
             _myWhenTrue = whenTrue;
             _myWhenFalse = whenFalse;
-
-            if ((!object.ReferenceEquals(_myCondition.ResultType, typeof(bool))))
+            
+            if (!ImplicitConverter.EmitImplicitConvert(_myCondition.ResultType, typeof(bool), null))
             {
                 base.ThrowCompileException(CompileErrorResourceKeys.FirstArgNotBoolean, CompileExceptionReason.TypeMismatch);
             }

src/Flee.Net45/ExpressionElements/LogicalBitwise/AndOr.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reflection;
 using System.Reflection.Emit;
 using Flee.ExpressionElements.Base;
 using Flee.InternalTypes;
@@ -26,6 +27,15 @@ protected override void GetOperation(object operation)
 
         protected override System.Type GetResultType(System.Type leftType, System.Type rightType)
         {
+            MethodInfo overloadedMethod = this.GetOverloadedAndOrOperator();
+
+            // Is an overloaded operator defined for our left and right children?
+            if ((overloadedMethod != null))
+            {
+                // Yes, so use its return type
+                return overloadedMethod.ReturnType;
+            }
+
             Type bitwiseOpType = Utility.GetBitwiseOpType(leftType, rightType);
             if ((bitwiseOpType != null))
             {
@@ -41,21 +51,52 @@ protected override System.Type GetResultType(System.Type leftType, System.Type r
             }
         }
 
+        private MethodInfo GetOverloadedAndOrOperator()
+        {
+            // Get the name of the operator
+            string name = GetOverloadedOperatorFunctionName(_myOperation);
+            return base.GetOverloadedBinaryOperator(name, _myOperation);
+        }
+
+        private static string GetOverloadedOperatorFunctionName(AndOrOperation op)
+        {
+            switch (op)
+            {
+                case AndOrOperation.And:
+                    return "BitwiseAnd";
+                case AndOrOperation.Or:
+                    return "BitwiseOr";
+                default:
+                    Debug.Assert(false, "unknown operator type");
+                    return null;
+            }
+        }
+
         public override void Emit(FleeILGenerator ilg, IServiceProvider services)
         {
-            Type resultType = this.ResultType;
+            MethodInfo overloadedMethod = this.GetOverloadedAndOrOperator();
 
-            if (object.ReferenceEquals(resultType, typeof(bool)))
+            if ((overloadedMethod != null))
             {
-                this.DoEmitLogical(ilg, services);
+                // Emit a call to an overloaded operator
+                this.EmitOverloadedOperatorCall(overloadedMethod, ilg, services);
             }
             else
             {
-                MyLeftChild.Emit(ilg, services);
-                ImplicitConverter.EmitImplicitConvert(MyLeftChild.ResultType, resultType, ilg);
-                MyRightChild.Emit(ilg, services);
-                ImplicitConverter.EmitImplicitConvert(MyRightChild.ResultType, resultType, ilg);
-                EmitBitwiseOperation(ilg, _myOperation);
+                Type resultType = this.ResultType;
+
+                if (object.ReferenceEquals(resultType, typeof(bool)))
+                {
+                    this.DoEmitLogical(ilg, services);
+                }
+                else
+                {
+                    MyLeftChild.Emit(ilg, services);
+                    ImplicitConverter.EmitImplicitConvert(MyLeftChild.ResultType, resultType, ilg);
+                    MyRightChild.Emit(ilg, services);
+                    ImplicitConverter.EmitImplicitConvert(MyRightChild.ResultType, resultType, ilg);
+                    EmitBitwiseOperation(ilg, _myOperation);
+                }
             }
         }
 

src/Flee.Net45/Flee.Net45.csproj

@@ -31,7 +31,7 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
+    <SignAssembly>false</SignAssembly>
   </PropertyGroup>
   <PropertyGroup>
     <AssemblyOriginatorKeyFile>flee.pfx</AssemblyOriginatorKeyFile>

src/Flee.Net45/InternalTypes/BranchManager.cs

@@ -108,13 +108,10 @@ public bool IsLongBranch(FleeILGenerator ilg, Label target)
 			if (index > -1 && index < MyBranchInfos.Count)
 			{
 				bi = MyBranchInfos[index];
-				return bi.IsLongBranch;
 			}
-			else
-			{
-				return true; // temp fix: not sure why, but MyBranchInfos seems to be missing elements when executing long scripts
-			}
-		}
+
+            return bi.IsLongBranch;
+        }
 
         /// <summary>
         /// Add a branch from a location to a target label

src/Flee.Net45/InternalTypes/Expression.cs

@@ -157,15 +157,55 @@ private void ValidateOwner(object owner)
             }
         }
 
+        private T HandleEvaluationException<T>(Func<T> function)
+        {
+            try
+            {
+                return function.Invoke();
+            }
+            catch (Exception e)
+            {
+                if (e.InnerException?.Message != null)
+                {
+                    throw new ExpressionEvaluationException(e.InnerException.Message);
+                }
+                var variables = _myInfo.GetReferencedVariables();
+                if (variables.Length != 0)
+                {
+                    var exception = GetCustomExceptionMessage<T>(variables);
+                    throw new ExpressionEvaluationException(exception);
+                }
+                throw new ExpressionEvaluationException(e.Message);
+            }
+        }
+
+        private string GetCustomExceptionMessage<T>(string[] variables)
+        {
+            var errorMessage = "";
+            foreach (var variable in variables)
+            {
+                var inputValue = Context.Variables.GetVariableValueInternal<string>(variable);
+                errorMessage += string.IsNullOrWhiteSpace(inputValue)
+                    ? $"{variable} = empty "
+                    : $"{variable} = {inputValue} " + " ";
+            }
+
+            var exception = variables.Length == 1
+                ? $"failed to run expression {_myExpression} with input {errorMessage}"
+                : $"failed to run expression {_myExpression} with inputs: {errorMessage}";
+            return exception;
+        }
+
         public object Evaluate()
         {
-            return _myEvaluator(_myOwner, _myContext, _myContext.Variables);
+            return HandleEvaluationException(() => _myEvaluator(_myOwner, _myContext, _myContext.Variables));
         }
 
         public T EvaluateGeneric()
         {
-            return _myEvaluator(_myOwner, _myContext, _myContext.Variables);
+            return HandleEvaluationException(() => _myEvaluator(_myOwner, _myContext, _myContext.Variables));
         }
+
         T IGenericExpression<T>.Evaluate()
         {
             return EvaluateGeneric();

src/Flee.Net45/PublicTypes/Exceptions.cs

@@ -28,8 +28,11 @@ public enum CompileExceptionReason
     public sealed class ExpressionCompileException : Exception
     {
         private readonly CompileExceptionReason _myReason;
-        internal ExpressionCompileException(string message, CompileExceptionReason reason) : base(message)
+        public object[] Arguments { get; }
+
+        internal ExpressionCompileException(string message, CompileExceptionReason reason, object[] arguments) : base(message)
         {
+            Arguments = arguments;
             _myReason = reason;
         }
 
@@ -68,4 +71,16 @@ public override string Message
 
         public CompileExceptionReason Reason => _myReason;
     }
+
+    /// <summary>
+    /// Exception, which occured during expression evaluation.
+    /// </summary>
+    [Serializable]
+    public sealed class ExpressionEvaluationException : Exception
+    {
+
+        public ExpressionEvaluationException(string message) : base(message)
+        {
+        }
+    }
 }

src/Flee.Net45/Resources/CompileErrors.resx

@@ -220,10 +220,10 @@
     <value>Type '{0}' is not an array and does not have an indexer which accepts '{1}'</value>
   </data>
   <data name="UndefinedFunction" xml:space="preserve">
-    <value>Could find not function '{0}({1})'</value>
+    <value>Could not find function '{0}({1})'</value>
   </data>
   <data name="UndefinedFunctionOnType" xml:space="preserve">
-    <value>Could find not function '{0}({1})' on type '{2}'</value>
+    <value>Could not find function '{0}({1})' on type '{2}'</value>
   </data>
   <data name="UNEXPECTED_CHAR" xml:space="preserve">
     <value>Unexpected character: {0}</value>

src/Flee.NetStandard20/ExpressionElements/Arithmetic.cs

@@ -316,7 +316,7 @@ private bool IsOptimizablePower
         {
             get
             {
-                if (_myOperation != BinaryArithmeticOperation.Power)
+                if (_myOperation != BinaryArithmeticOperation.Power || !(MyRightChild is Int32LiteralElement))
                 {
                     return false;
                 }

src/Flee.NetStandard20/ExpressionElements/Base/Binary.cs

@@ -92,9 +92,10 @@ protected MethodInfo GetOverloadedBinaryOperator(string name, object operation)
             }
             else
             {
+                return leftMethod;
                 // Ambiguous call
-                base.ThrowAmbiguousCallException(leftType, rightType, operation);
-                return null;
+                //base.ThrowAmbiguousCallException(leftType, rightType, operation);
+                //return null;
             }
         }
 

src/Flee.NetStandard20/ExpressionElements/Base/ExpressionElement.cs

@@ -36,7 +36,7 @@ protected void ThrowCompileException(string messageKey, CompileExceptionReason r
             string messageTemplate = FleeResourceManager.Instance.GetCompileErrorString(messageKey);
             string message = string.Format(messageTemplate, arguments);
             message = string.Concat(this.Name, ": ", message);
-            throw new ExpressionCompileException(message, reason);
+            throw new ExpressionCompileException(message, reason, arguments);
         }
 
         protected void ThrowAmbiguousCallException(Type leftType, Type rightType, object operation)

src/Flee.NetStandard20/ExpressionElements/Compare.cs

@@ -24,7 +24,7 @@ public CompareElement()
         public void Initialize(ExpressionElement leftChild, ExpressionElement rightChild, LogicalCompareOperation op)
         {
             MyLeftChild = leftChild;
-            MyRightChild = (Int32LiteralElement)rightChild;
+            MyRightChild = rightChild;
             _myOperation = op;
         }
 

src/Flee.NetStandard20/ExpressionElements/Conditional.cs

@@ -23,7 +23,7 @@ public ConditionalElement(ExpressionElement condition, ExpressionElement whenTru
             _myWhenTrue = whenTrue;
             _myWhenFalse = whenFalse;
 
-            if ((!object.ReferenceEquals(_myCondition.ResultType, typeof(bool))))
+            if (!ImplicitConverter.EmitImplicitConvert(_myCondition.ResultType, typeof(bool), null))
             {
                 base.ThrowCompileException(CompileErrorResourceKeys.FirstArgNotBoolean, CompileExceptionReason.TypeMismatch);
             }