moved a subset of source file to the kern package

function.go

@@ -6,19 +6,20 @@ package expr
 
 import (
 	"fmt"
-	"strconv"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // ---- Function template
-type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
+// type FuncTemplate func(ctx expr.ExprContext, name string, args map[string]any) (result any, err error)
 
 // ---- Common functor definition
-type baseFunctor struct {
-	info ExprFunc
+type BaseFunctor struct {
+	info kern.ExprFunc
 }
 
-func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
+func (functor *BaseFunctor) ToString(opt kern.FmtOpt) (s string) {
 	if functor.info != nil {
 		s = functor.info.ToString(opt)
 	} else {
@@ -27,23 +28,23 @@ func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
 	return s
 }
 
-func (functor *baseFunctor) GetParams() (params []ExprFuncParam) {
+func (functor *BaseFunctor) GetParams() (params []kern.ExprFuncParam) {
 	if functor.info != nil {
 		return functor.info.Params()
 	} else {
-		return []ExprFuncParam{}
+		return []kern.ExprFuncParam{}
 	}
 }
 
-func (functor *baseFunctor) SetFunc(info ExprFunc) {
+func (functor *BaseFunctor) SetFunc(info kern.ExprFunc) {
 	functor.info = info
 }
 
-func (functor *baseFunctor) GetFunc() ExprFunc {
+func (functor *BaseFunctor) GetFunc() kern.ExprFunc {
 	return functor.info
 }
 
-func (functor *baseFunctor) GetDefinitionContext() ExprContext {
+func (functor *BaseFunctor) GetDefinitionContext() kern.ExprContext {
 	return nil
 }
 
@@ -62,11 +63,11 @@ type funcParamInfo struct {
 	defaultValue any
 }
 
-func NewFuncParam(name string) ExprFuncParam {
+func NewFuncParam(name string) kern.ExprFuncParam {
 	return &funcParamInfo{name: name}
 }
 
-func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+func NewFuncParamFlag(name string, flags paramFlags) kern.ExprFuncParam {
 	return &funcParamInfo{name: name, flags: flags}
 }
 
@@ -79,7 +80,7 @@ func (param *funcParamInfo) Name() string {
 }
 
 func (param *funcParamInfo) Type() string {
-	return TypeAny
+	return kern.TypeAny
 }
 
 func (param *funcParamInfo) IsDefault() bool {
@@ -100,17 +101,17 @@ func (param *funcParamInfo) DefaultValue() any {
 
 // --- Functions
 
-// funcInfo implements ExprFunc
+// funcInfo implements expr.ExprFunc
 type funcInfo struct {
 	name         string
 	minArgs      int
 	maxArgs      int
-	functor      Functor
-	formalParams []ExprFuncParam
+	functor      kern.Functor
+	formalParams []kern.ExprFuncParam
 	returnType   string
 }
 
-func newFuncInfo(name string, functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
+func newFuncInfo(name string, functor kern.Functor, returnType string, params []kern.ExprFuncParam) (info *funcInfo, err error) {
 	var minArgs = 0
 	var maxArgs = 0
 	for _, p := range params {
@@ -138,7 +139,7 @@ func newFuncInfo(name string, functor Functor, returnType string, params []ExprF
 	return info, nil
 }
 
-func (info *funcInfo) Params() []ExprFuncParam {
+func (info *funcInfo) Params() []kern.ExprFuncParam {
 	return info.formalParams
 }
 
@@ -146,7 +147,7 @@ func (info *funcInfo) ReturnType() string {
 	return info.returnType
 }
 
-func (info *funcInfo) ToString(opt FmtOpt) string {
+func (info *funcInfo) ToString(opt kern.FmtOpt) string {
 	var sb strings.Builder
 	if len(info.Name()) == 0 {
 		sb.WriteString("func")
@@ -180,7 +181,7 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 	if len(info.returnType) > 0 {
 		sb.WriteString(info.returnType)
 	} else {
-		sb.WriteString(TypeAny)
+		sb.WriteString(kern.TypeAny)
 	}
 	sb.WriteString("{}")
 	return sb.String()
@@ -198,11 +199,11 @@ func (info *funcInfo) MaxArgs() int {
 	return info.maxArgs
 }
 
-func (info *funcInfo) Functor() Functor {
+func (info *funcInfo) Functor() kern.Functor {
 	return info.functor
 }
 
-func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
+func (info *funcInfo) AllocContext(parentCtx kern.ExprContext) (ctx kern.ExprContext) {
 	if defCtx := info.functor.GetDefinitionContext(); defCtx != nil {
 		ctx = defCtx.Clone()
 		ctx.SetParent(defCtx)
@@ -213,7 +214,7 @@ func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
 	return
 }
 
-func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
+func (info *funcInfo) ParamSpec(paramName string) kern.ExprFuncParam {
 	for _, spec := range info.formalParams {
 		if spec.Name() == paramName {
 			return spec
@@ -222,7 +223,7 @@ func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
 	return nil
 }
 
-func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
+func initActualParams(ctx kern.ExprContext, info kern.ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
 	var varArgs []any
 	var varName string
 
@@ -237,10 +238,10 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 	for i, tree := range callTerm.children {
 		var paramValue any
 		paramCtx := ctx.Clone()
-		if paramValue, err = tree.compute(paramCtx); err != nil {
+		if paramValue, err = tree.Compute(paramCtx); err != nil {
 			break
 		}
-		if paramName, namedParam := getAssignVarName(tree); namedParam {
+		if paramName, namedParam := kern.GetAssignVarName(tree); namedParam {
 			if info.ParamSpec(paramName) == nil {
 				err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
 				break
@@ -260,7 +261,7 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 					actualParams[spec.Name()] = paramValue
 				}
 			} else {
-				err = ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
+				err = kern.ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
 				break
 			}
 		} else {
@@ -279,7 +280,7 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err error) {
 	passedCount := len(actualParams)
 	if info.MinArgs() > passedCount {
-		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+		err = kern.ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
 		return
 	}
 
@@ -301,86 +302,86 @@ func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err
 	}
 
 	if info.MaxArgs() >= 0 && info.MaxArgs() < len(actualParams) {
-		err = ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
+		err = kern.ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
 	}
 	return
 }
 
 // ----- Call a function ---
 
-func getAssignVarName(t *term) (name string, ok bool) {
-	if ok = t.symbol() == SymEqual; ok {
-		name = t.children[0].source()
-	}
-	return
-}
+// func getAssignVarName(t *term) (name string, ok bool) {
+// 	if ok = t.symbol() == SymEqual; ok {
+// 		name = t.children[0].source()
+// 	}
+// 	return
+// }
 
-func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm *term) (result any, err error) {
-	var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
-			ctx := info.AllocContext(parentCtx)
-			if err = info.PrepareCall(name, actualParams); err == nil {
-				functor := info.Functor()
-				result, err = functor.InvokeNamed(ctx, name, actualParams)
-				exportObjectsToParent(ctx)
-			}
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
+// func CallFunctionByTerm(parentCtx expr.ExprContext, name string, callTerm *term) (result any, err error) {
+// 	var actualParams map[string]any
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
+// 		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
+// 			ctx := info.AllocContext(parentCtx)
+// 			if err = info.PrepareCall(name, actualParams); err == nil {
+// 				functor := info.Functor()
+// 				result, err = functor.InvokeNamed(ctx, name, actualParams)
+// 				exportObjectsToParent(ctx)
+// 			}
+// 		}
+// 	} else {
+// 		err = fmt.Errorf("unknown function %s()", name)
+// 	}
+// 	return
+// }
 
-func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result any, err error) {
-	var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		functor := info.Functor()
-		actualParams = bindActualParams(functor, args)
-		ctx := info.AllocContext(parentCtx)
-		if err = info.PrepareCall(name, actualParams); err == nil {
-			result, err = functor.InvokeNamed(ctx, name, actualParams)
-			exportObjectsToParent(ctx)
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
+// func CallFunctionByArgs(parentCtx expr.ExprContext, name string, args []any) (result any, err error) {
+// 	var actualParams map[string]any
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
+// 		functor := info.Functor()
+// 		actualParams = bindActualParams(functor, args)
+// 		ctx := info.AllocContext(parentCtx)
+// 		if err = info.PrepareCall(name, actualParams); err == nil {
+// 			result, err = functor.InvokeNamed(ctx, name, actualParams)
+// 			exportObjectsToParent(ctx)
+// 		}
+// 	} else {
+// 		err = fmt.Errorf("unknown function %s()", name)
+// 	}
+// 	return
+// }
 
-func CallFunctionByParams(parentCtx ExprContext, name string, actualParams map[string]any) (result any, err error) {
-	//var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		functor := info.Functor()
-		ctx := info.AllocContext(parentCtx)
-		if err = info.PrepareCall(name, actualParams); err == nil {
-			result, err = functor.InvokeNamed(ctx, name, actualParams)
-			exportObjectsToParent(ctx)
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
+// func CallFunctionByParams(parentCtx expr.ExprContext, name string, actualParams map[string]any) (result any, err error) {
+// 	//var actualParams map[string]any
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
+// 		functor := info.Functor()
+// 		ctx := info.AllocContext(parentCtx)
+// 		if err = info.PrepareCall(name, actualParams); err == nil {
+// 			result, err = functor.InvokeNamed(ctx, name, actualParams)
+// 			exportObjectsToParent(ctx)
+// 		}
+// 	} else {
+// 		err = fmt.Errorf("unknown function %s()", name)
+// 	}
+// 	return
+// }
 
-func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
-	if value, exists = args[paramName]; !exists {
-		if paramNum > 0 && paramNum <= len(args) {
-			value, exists = args["arg"+strconv.Itoa(paramNum)]
-		}
-	}
-	return
-}
+// func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+// 	if value, exists = args[paramName]; !exists {
+// 		if paramNum > 0 && paramNum <= len(args) {
+// 			value, exists = args["arg"+strconv.Itoa(paramNum)]
+// 		}
+// 	}
+// 	return
+// }
 
-func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
-	formalParams := functor.GetParams()
-	actualParams = make(map[string]any, len(args))
-	for i, arg := range args {
-		if i < len(formalParams) {
-			actualParams[formalParams[i].Name()] = arg
-		} else {
-			actualParams["arg"+strconv.Itoa(i+1)] = arg
-		}
-	}
-	return
-}
+// func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+// 	formalParams := functor.GetParams()
+// 	actualParams = make(map[string]any, len(args))
+// 	for i, arg := range args {
+// 		if i < len(formalParams) {
+// 			actualParams[formalParams[i].Name()] = arg
+// 		} else {
+// 			actualParams["arg"+strconv.Itoa(i+1)] = arg
+// 		}
+// 	}
+// 	return
+// }