Added type conversion for function input arguments

 - this uses the built-in go methods to convert from one type to another
 - the main impetus was to support function calls with numeric parameters that weren’t doubles

Author: sambonfire

dummies_test.go

@@ -2,6 +2,7 @@ package govaluate
 
 import (
 	"errors"
+	"fmt"
 )
 
 /*
@@ -31,6 +32,16 @@ func (this dummyParameter) FuncArgStr(arg1 string) string {
 	return arg1
 }
 
+func (this dummyParameter) TestArgs(str string, ui uint, ui8 uint8, ui16 uint16, ui32 uint32, ui64 uint64, i int, i8 int8, i16 int16, i32 int32, i64 int64, f32 float32, f64 float64) string {
+	var sum float64
+	sum = float64(ui) + float64(ui8) + float64(ui16) + float64(ui32) + float64(ui64)
+	sum += float64(i) + float64(i8) + float64(i16) + float64(i32) + float64(i64)
+	sum += float64(f32)
+	sum += f64
+
+	return fmt.Sprintf("%v: %v", str, sum)
+}
+
 func (this dummyParameter) AlwaysFail() (interface{}, error) {
 	return nil, errors.New("function should always fail")
 }

evaluationFailure_test.go

@@ -33,9 +33,9 @@ const (
 	ABSENT_PARAMETER                = "No parameter"
 	INVALID_REGEX                   = "Unable to compile regexp pattern"
 	INVALID_PARAMETER_CALL          = "No method or field"
-	TOO_FEW_ARGS                    = "reflect: Call with too few input arguments"
-	TOO_MANY_ARGS                   = "reflect: Call with too many input arguments"
-	MISMATCHED_PARAMETERS           = "reflect: Call using"
+	TOO_FEW_ARGS                    = "Too few arguments to parameter call"
+	TOO_MANY_ARGS                   = "Too many arguments to parameter call"
+	MISMATCHED_PARAMETERS           = "Argument type conversion failed"
 )
 
 // preset parameter map of types that can be used in an evaluation failure test to check typing.

evaluationStage.go

@@ -247,6 +247,48 @@ func makeFunctionStage(function ExpressionFunction) evaluationOperator {
 	}
 }
 
+func typeConvertParam(p reflect.Value, t reflect.Type) (ret reflect.Value, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			errorMsg := fmt.Sprintf("Argument type conversion failed: failed to convert '%s' to '%s'", p.Kind().String(), t.Kind().String())
+			err = errors.New(errorMsg)
+			ret = p
+		}
+	}()
+
+	return p.Convert(t), nil
+}
+
+func typeConvertParams(method reflect.Value, params []reflect.Value) ([]reflect.Value, error) {
+
+	methodType := method.Type()
+	numIn := methodType.NumIn()
+	numParams := len(params)
+
+	if numIn != numParams {
+		if numIn > numParams {
+			return nil, fmt.Errorf("Too few arguments to parameter call: got %d arguments, expected %d", len(params), numIn)
+		}
+		return nil, fmt.Errorf("Too many arguments to parameter call: got %d arguments, expected %d", len(params), numIn)
+	}
+
+	for i := 0; i < numIn; i++ {
+		t := methodType.In(i)
+		p := params[i]
+		pt := p.Type()
+
+		if t.Kind() != pt.Kind() {
+			np, err := typeConvertParam(p, t)
+			if err != nil {
+				return nil, err
+			}
+			params[i] = np
+		}
+	}
+
+	return params, nil
+}
+
 func makeAccessorStage(pair []string) evaluationOperator {
 
 	reconstructed := strings.Join(pair, ".")
@@ -322,6 +364,12 @@ func makeAccessorStage(pair []string) evaluationOperator {
 				params = []reflect.Value{reflect.ValueOf(right.(interface{}))}
 			}
 
+			params, err = typeConvertParams(method, params)
+
+			if err != nil {
+				return nil, errors.New("Method call failed - '" + pair[0] + "." + pair[1] + "': " + err.Error())
+			}
+
 			returned := method.Call(params)
 			retLength := len(returned)
 

evaluation_test.go

@@ -1328,6 +1328,14 @@ func TestParameterizedEvaluation(test *testing.T) {
 			Parameters: []EvaluationParameter{fooParameter},
 			Expected:   "frink",
 		},
+		EvaluationTest{
+
+			Name:       "Parameter function call with all argument types",
+			Input:      "foo.TestArgs(\"hello\", 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1.0, 2.0)",
+			Parameters: []EvaluationParameter{fooParameter},
+			Expected:   "hello: 33",
+		},
+
 		EvaluationTest{
 
 			Name:       "Simple parameter function call, one arg",