go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved a subset of source file to the kern package

Browse Source
This commit is contained in:
Celestino Amoroso 2026-04-27 19:43:37 +02:00
parent f100adead3
commit 4d910dd069
107 changed files with 2080 additions and 1380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
ast.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- ast //-------- ast
@ -19,33 +21,33 @@ func NewAst() *ast {
return &ast{} return &ast{}
} }
func (expr *ast) TypeName() string { func (ast *ast) TypeName() string {
return "Expression" return "Expression"
} }
func (expr *ast) ToForest() { func (ast *ast) ToForest() {
if expr.root != nil { if ast.root != nil {
if expr.forest == nil { if ast.forest == nil {
expr.forest = make([]*term, 0) ast.forest = make([]*term, 0)
} }
expr.forest = append(expr.forest, expr.root) ast.forest = append(ast.forest, ast.root)
expr.root = nil ast.root = nil
} }
} }
func (expr *ast) String() string { func (ast *ast) String() string {
var sb strings.Builder var sb strings.Builder
if expr.root == nil { if ast.root == nil {
sb.WriteString("(nil)") sb.WriteString("(nil)")
} else { } else {
expr.root.toString(&sb) ast.root.toString(&sb)
} }
return sb.String() return sb.String()
} }
func (expr *ast) addTokens(tokens ...*Token) (err error) { func (ast *ast) addTokens(tokens ...*Token) (err error) {
for _, tk := range tokens { for _, tk := range tokens {
if _, err = expr.addToken(tk); err != nil { if _, err = ast.addToken(tk); err != nil {
break break
} }
} }
@ -57,31 +59,31 @@ func (expr *ast) addTokens(tokens ...*Token) (err error) {
// return // return
// } // }
func (expr *ast) addToken(tk *Token) (t *term, err error) { func (ast *ast) addToken(tk *Token) (t *term, err error) {
if t = newTerm(tk); t != nil { if t = newTerm(tk); t != nil {
err = expr.addTerm(t) err = ast.addTerm(t)
} else { } else {
err = tk.Errorf("unexpected token %q", tk.String()) err = tk.Errorf("unexpected token %q", tk.String())
} }
return return
} }
func (expr *ast) addTerm(node *term) (err error) { func (ast *ast) addTerm(node *term) (err error) {
if expr.root == nil { if ast.root == nil {
expr.root = node ast.root = node
} else { } else {
expr.root, err = expr.insert(expr.root, node) ast.root, err = ast.insert(ast.root, node)
} }
return return
} }
func (expr *ast) insert(tree, node *term) (root *term, err error) { func (ast *ast) insert(tree, node *term) (root *term, err error) {
if tree.getPriority() < node.getPriority() { if tree.getPriority() < node.getPriority() {
root = tree root = tree
if tree.isComplete() { if tree.isComplete() {
var subRoot *term var subRoot *term
last := tree.removeLastChild() last := tree.removeLastChild()
if subRoot, err = expr.insert(last, node); err == nil { if subRoot, err = ast.insert(last, node); err == nil {
subRoot.setParent(tree) subRoot.setParent(tree)
} }
} else { } else {
@ -96,22 +98,22 @@ func (expr *ast) insert(tree, node *term) (root *term, err error) {
return return
} }
func (expr *ast) Finish() { func (ast *ast) Finish() {
if expr.root == nil && expr.forest != nil && len(expr.forest) >= 1 { if ast.root == nil && ast.forest != nil && len(ast.forest) >= 1 {
expr.root = expr.forest[len(expr.forest)-1] ast.root = ast.forest[len(ast.forest)-1]
expr.forest = expr.forest[0 : len(expr.forest)-1] ast.forest = ast.forest[0 : len(ast.forest)-1]
} }
} }
func (expr *ast) Eval(ctx ExprContext) (result any, err error) { func (ast *ast) Eval(ctx kern.ExprContext) (result any, err error) {
expr.Finish() ast.Finish()
if expr.root != nil { if ast.root != nil {
// initDefaultVars(ctx) // initDefaultVars(ctx)
if expr.forest != nil { if ast.forest != nil {
for _, root := range expr.forest { for _, root := range ast.forest {
if result, err = root.compute(ctx); err == nil { if result, err = root.Compute(ctx); err == nil {
ctx.UnsafeSetVar(ControlLastResult, result) ctx.UnsafeSetVar(kern.ControlLastResult, result)
} else { } else {
//err = fmt.Errorf("error in expression nr %d: %v", i+1, err) //err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
break break
@ -119,8 +121,8 @@ func (expr *ast) Eval(ctx ExprContext) (result any, err error) {
} }
} }
if err == nil { if err == nil {
if result, err = expr.root.compute(ctx); err == nil { if result, err = ast.root.Compute(ctx); err == nil {
ctx.UnsafeSetVar(ControlLastResult, result) ctx.UnsafeSetVar(kern.ControlLastResult, result)
} }
} }
// } else { // } else {

26
bind-expr-functions.go
View File

@ -4,20 +4,24 @@
// function.go // function.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// ---- Linking with Expr functions // ---- Linking with Expr functions
type exprFunctor struct { type exprFunctor struct {
baseFunctor kern.BaseFunctor
params []ExprFuncParam params []kern.ExprFuncParam
expr Expr expr Expr
defCtx ExprContext defCtx kern.ExprContext
} }
func (functor *exprFunctor) GetParams() (params []ExprFuncParam) { func (functor *exprFunctor) GetParams() (params []kern.ExprFuncParam) {
return functor.params return functor.params
} }
func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor { func newExprFunctor(e Expr, params []kern.ExprFuncParam, ctx kern.ExprContext) *exprFunctor {
var defCtx ExprContext var defCtx kern.ExprContext
if ctx != nil { if ctx != nil {
defCtx = ctx defCtx = ctx
} }
@ -28,17 +32,17 @@ func (functor *exprFunctor) TypeName() string {
return "ExprFunctor" return "ExprFunctor"
} }
func (functor *exprFunctor) GetDefinitionContext() ExprContext { func (functor *exprFunctor) GetDefinitionContext() kern.ExprContext {
return functor.defCtx return functor.defCtx
} }
func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) { func (functor *exprFunctor) InvokeNamed(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var missing []string var missing []string
for _, p := range functor.params { for _, p := range functor.params {
if arg, exists := args[p.Name()]; exists { if arg, exists := args[p.Name()]; exists {
if funcArg, ok := arg.(Functor); ok { if funcArg, ok := arg.(kern.Functor); ok {
paramSpecs := funcArg.GetParams() paramSpecs := funcArg.GetParams()
ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs) ctx.RegisterFunc(p.Name(), funcArg, kern.TypeAny, paramSpecs)
} else { } else {
ctx.UnsafeSetVar(p.Name(), arg) ctx.UnsafeSetVar(p.Name(), arg)
} }
@ -51,7 +55,7 @@ func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[s
} }
} }
if missing != nil { if missing != nil {
err = ErrMissingParams(name, missing) err = kern.ErrMissingParams(name, missing)
} else { } else {
result, err = functor.expr.Eval(ctx) result, err = functor.expr.Eval(ctx)
} }

208
builtin-base.go
View File

@ -9,81 +9,83 @@ import (
"math" "math"
"strconv" "strconv"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const ( const (
ParamDenominator = "denominator" ParamDenominator = "denominator"
) )
func isNilFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isNilFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = args[ParamValue] == nil result = args[kern.ParamValue] == nil
return return
} }
func isIntFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isIntFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsInteger(args[ParamValue]) result = kern.IsInteger(args[kern.ParamValue])
return return
} }
func isFloatFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isFloatFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsFloat(args[ParamValue]) result = kern.IsFloat(args[kern.ParamValue])
return return
} }
func isBoolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isBoolFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsBool(args[ParamValue]) result = kern.IsBool(args[kern.ParamValue])
return return
} }
func isStringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isStringFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsString(args[ParamValue]) result = kern.IsString(args[kern.ParamValue])
return return
} }
func isFractionFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isFractionFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsFract(args[ParamValue]) result = kern.IsFract(args[kern.ParamValue])
return return
} }
func isRationalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isRationalFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsRational(args[ParamValue]) result = kern.IsRational(args[kern.ParamValue])
return return
} }
func isListFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isListFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsList(args[ParamValue]) result = kern.IsList(args[kern.ParamValue])
return return
} }
func isDictionaryFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func isDictionaryFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
result = IsDict(args[ParamValue]) result = kern.IsDict(args[kern.ParamValue])
return return
} }
func boolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func boolFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
switch v := args[ParamValue].(type) { switch v := args[kern.ParamValue].(type) {
case int64: case int64:
result = (v != 0) result = (v != 0)
case *FractionType: case *kern.FractionType:
result = v.num != 0 result = v.N() != 0
case float64: case float64:
result = v != 0.0 result = v != 0.0
case bool: case bool:
result = v result = v
case string: case string:
result = len(v) > 0 result = len(v) > 0
case *ListType: case *kern.ListType:
result = len(*v) > 0 result = len(*v) > 0
case *DictType: case *kern.DictType:
result = len(*v) > 0 result = len(*v) > 0
default: default:
err = ErrCantConvert(name, v, "bool") err = kern.ErrCantConvert(name, v, "bool")
} }
return return
} }
func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func intFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
switch v := args[ParamValue].(type) { switch v := args[kern.ParamValue].(type) {
case int64: case int64:
result = v result = v
case float64: case float64:
@ -99,16 +101,16 @@ func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err
if i, err = strconv.Atoi(v); err == nil { if i, err = strconv.Atoi(v); err == nil {
result = int64(i) result = int64(i)
} }
case *FractionType: case *kern.FractionType:
result = int64(v.num / v.den) result = int64(v.N() / v.D())
default: default:
err = ErrCantConvert(name, v, "int") err = kern.ErrCantConvert(name, v, "int")
} }
return return
} }
func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func decFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
switch v := args[ParamValue].(type) { switch v := args[kern.ParamValue].(type) {
case int64: case int64:
result = float64(v) result = float64(v)
case float64: case float64:
@ -124,16 +126,16 @@ func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err
if f, err = strconv.ParseFloat(v, 64); err == nil { if f, err = strconv.ParseFloat(v, 64); err == nil {
result = f result = f
} }
case *FractionType: case *kern.FractionType:
result = v.toFloat() result = v.ToFloat()
default: default:
err = ErrCantConvert(name, v, "float") err = kern.ErrCantConvert(name, v, "float")
} }
return return
} }
func stringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func stringFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
switch v := args[ParamValue].(type) { switch v := args[kern.ParamValue].(type) {
case int64: case int64:
result = strconv.FormatInt(v, 10) result = strconv.FormatInt(v, 10)
case float64: case float64:
@ -146,118 +148,118 @@ func stringFunc(ctx ExprContext, name string, args map[string]any) (result any,
} }
case string: case string:
result = v result = v
case *FractionType: case *kern.FractionType:
result = v.ToString(0) result = v.ToString(0)
case Formatter: case kern.Formatter:
result = v.ToString(0) result = v.ToString(0)
case fmt.Stringer: case fmt.Stringer:
result = v.String() result = v.String()
default: default:
err = ErrCantConvert(name, v, "string") err = kern.ErrCantConvert(name, v, "string")
} }
return return
} }
func fractFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func fractFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
switch v := args[ParamValue].(type) { switch v := args[kern.ParamValue].(type) {
case int64: case int64:
var den int64 = 1 var den int64 = 1
var ok bool var ok bool
if den, ok = args[ParamDenominator].(int64); !ok { if den, ok = args[ParamDenominator].(int64); !ok {
err = ErrExpectedGot(name, "integer", args[ParamDenominator]) err = kern.ErrExpectedGot(name, "integer", args[ParamDenominator])
} else if den == 0 { } else if den == 0 {
err = ErrFuncDivisionByZero(name) err = kern.ErrFuncDivisionByZero(name)
} }
if err == nil { if err == nil {
result = newFraction(v, den) result = kern.NewFraction(v, den)
} }
case float64: case float64:
result, err = float64ToFraction(v) result, err = kern.Float64ToFraction(v)
case bool: case bool:
if v { if v {
result = newFraction(1, 1) result = kern.NewFraction(1, 1)
} else { } else {
result = newFraction(0, 1) result = kern.NewFraction(0, 1)
} }
case string: case string:
result, err = makeGeneratingFraction(v) result, err = kern.MakeGeneratingFraction(v)
case *FractionType: case *kern.FractionType:
result = v result = v
default: default:
err = ErrCantConvert(name, v, "float") err = kern.ErrCantConvert(name, v, "float")
} }
return return
} }
// func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) { // func iteratorFunc(ctx expr.ExprContext, name string, args []any) (result any, err error) {
// return // return
// } // }
func evalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func evalFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if source, ok := args[ParamSource].(string); ok { if source, ok := args[kern.ParamSource].(string); ok {
var expr Expr var ast Expr
parser := NewParser() parser := NewParser()
if ctx == nil { if ctx == nil {
ctx = NewSimpleStore() ctx = NewSimpleStoreWithoutGlobalContext()
} }
r := strings.NewReader(source) r := strings.NewReader(source)
scanner := NewScanner(r, DefaultTranslations()) scanner := NewScanner(r, DefaultTranslations())
if expr, err = parser.Parse(scanner); err == nil { if ast, err = parser.Parse(scanner); err == nil {
CtrlEnable(ctx, control_export_all) CtrlEnable(ctx, kern.ControlExportAll)
result, err = expr.Eval(ctx) result, err = ast.Eval(ctx)
} }
} else { } else {
err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
return return
} }
func varFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func varFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var varName string var varName string
var ok bool var ok bool
if varName, ok = args[ParamName].(string); !ok { if varName, ok = args[kern.ParamName].(string); !ok {
return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName]) return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
} }
if result, ok = args[ParamValue]; ok && result != nil { if result, ok = args[kern.ParamValue]; ok && result != nil {
ctx.GetParent().UnsafeSetVar(varName, result) ctx.GetParent().UnsafeSetVar(varName, result)
// } else { // } else {
// err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) // err = expr.ErrWrongParamType(name, expr.ParamSource, expr.TypeString, args[expr.ParamSource])
// } // }
} else if result, ok = ctx.GetVar(varName); !ok { } else if result, ok = ctx.GetVar(varName); !ok {
err = ErrUnknownVar(name, varName) err = kern.ErrUnknownVar(name, varName)
} }
return return
} }
func setFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func setFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var varName string var varName string
var ok bool var ok bool
if varName, ok = args[ParamName].(string); !ok { if varName, ok = args[kern.ParamName].(string); !ok {
return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName]) return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
} }
if result, ok = args[ParamValue]; ok { if result, ok = args[kern.ParamValue]; ok {
ctx.GetParent().UnsafeSetVar(varName, result) ctx.GetParent().UnsafeSetVar(varName, result)
} else { } else {
err = ErrWrongParamType(name, ParamValue, TypeAny, args[ParamValue]) err = kern.ErrWrongParamType(name, kern.ParamValue, kern.TypeAny, args[kern.ParamValue])
} }
return return
} }
func unsetFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func unsetFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var varName string var varName string
var ok bool var ok bool
if varName, ok = args[ParamName].(string); !ok { if varName, ok = args[kern.ParamName].(string); !ok {
return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName]) return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
} else { } else {
ctx.GetParent().DeleteVar(varName) ctx.GetParent().DeleteVar(varName)
result = nil result = nil
@ -267,47 +269,47 @@ func unsetFunc(ctx ExprContext, name string, args map[string]any) (result any, e
//// import //// import
func ImportBuiltinsFuncs(ctx ExprContext) { func ImportBuiltinsFuncs(ctx kern.ExprContext) {
anyParams := []ExprFuncParam{ anyParams := []kern.ExprFuncParam{
NewFuncParam(ParamValue), NewFuncParam(kern.ParamValue),
} }
ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isNil", kern.NewGolangFunctor(isNilFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isInt", NewGolangFunctor(isIntFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isInt", kern.NewGolangFunctor(isIntFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isFloat", NewGolangFunctor(isFloatFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isFloat", kern.NewGolangFunctor(isFloatFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isBool", NewGolangFunctor(isBoolFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isBool", kern.NewGolangFunctor(isBoolFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isString", NewGolangFunctor(isStringFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isString", kern.NewGolangFunctor(isStringFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isFract", NewGolangFunctor(isFractionFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isFract", kern.NewGolangFunctor(isFractionFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isRational", NewGolangFunctor(isRationalFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isRational", kern.NewGolangFunctor(isRationalFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isList", NewGolangFunctor(isListFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isList", kern.NewGolangFunctor(isListFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("isDict", NewGolangFunctor(isDictionaryFunc), TypeBoolean, anyParams) ctx.RegisterFunc("isDict", kern.NewGolangFunctor(isDictionaryFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("bool", NewGolangFunctor(boolFunc), TypeBoolean, anyParams) ctx.RegisterFunc("bool", kern.NewGolangFunctor(boolFunc), kern.TypeBoolean, anyParams)
ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams) ctx.RegisterFunc("int", kern.NewGolangFunctor(intFunc), kern.TypeInt, anyParams)
ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams) ctx.RegisterFunc("dec", kern.NewGolangFunctor(decFunc), kern.TypeFloat, anyParams)
ctx.RegisterFunc("string", NewGolangFunctor(stringFunc), TypeString, anyParams) ctx.RegisterFunc("string", kern.NewGolangFunctor(stringFunc), kern.TypeString, anyParams)
ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{ ctx.RegisterFunc("fract", kern.NewGolangFunctor(fractFunc), kern.TypeFraction, []kern.ExprFuncParam{
NewFuncParam(ParamValue), NewFuncParam(kern.ParamValue),
NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)), NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)),
}) })
ctx.RegisterFunc("eval", NewGolangFunctor(evalFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("eval", kern.NewGolangFunctor(evalFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
}) })
ctx.RegisterFunc("var", NewGolangFunctor(varFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("var", kern.NewGolangFunctor(varFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParam(ParamName), NewFuncParam(kern.ParamName),
NewFuncParamFlagDef(ParamValue, PfDefault, nil), NewFuncParamFlagDef(kern.ParamValue, PfDefault, nil),
}) })
ctx.RegisterFunc("set", NewGolangFunctor(setFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("set", kern.NewGolangFunctor(setFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParam(ParamName), NewFuncParam(kern.ParamName),
NewFuncParam(ParamValue), NewFuncParam(kern.ParamValue),
}) })
ctx.RegisterFunc("unset", NewGolangFunctor(unsetFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("unset", kern.NewGolangFunctor(unsetFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParam(ParamName), NewFuncParam(kern.ParamName),
NewFuncParam(ParamValue), NewFuncParam(kern.ParamValue),
}) })
} }

24
builtin-fmt.go
View File

@ -8,11 +8,13 @@ import (
"fmt" "fmt"
"io" "io"
"os" "os"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func getStdout(ctx ExprContext) io.Writer { func getStdout(ctx kern.ExprContext) io.Writer {
var w io.Writer var w io.Writer
if wany, exists := ctx.GetVar(ControlStdout); exists && wany != nil { if wany, exists := ctx.GetVar(kern.ControlStdout); exists && wany != nil {
w, _ = wany.(io.Writer) w, _ = wany.(io.Writer)
} }
if w == nil { if w == nil {
@ -21,9 +23,9 @@ func getStdout(ctx ExprContext) io.Writer {
return w return w
} }
func printFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func printFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var n int = 0 var n int = 0
if v, exists := args[ParamItem]; exists && v != nil { if v, exists := args[kern.ParamItem]; exists && v != nil {
argv := v.([]any) argv := v.([]any)
n, err = fmt.Fprint(getStdout(ctx), argv...) n, err = fmt.Fprint(getStdout(ctx), argv...)
} }
@ -31,9 +33,9 @@ func printFunc(ctx ExprContext, name string, args map[string]any) (result any, e
return return
} }
func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func printLnFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var n int = 0 var n int = 0
if v, exists := args[ParamItem]; exists && v != nil { if v, exists := args[kern.ParamItem]; exists && v != nil {
argv := v.([]any) argv := v.([]any)
n, err = fmt.Fprintln(getStdout(ctx), argv...) n, err = fmt.Fprintln(getStdout(ctx), argv...)
} else { } else {
@ -43,12 +45,12 @@ func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any,
return return
} }
func ImportFmtFuncs(ctx ExprContext) { func ImportFmtFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("print", NewGolangFunctor(printFunc), TypeInt, []ExprFuncParam{ ctx.RegisterFunc("print", kern.NewGolangFunctor(printFunc), kern.TypeInt, []kern.ExprFuncParam{
NewFuncParamFlag(ParamItem, PfRepeat), NewFuncParamFlag(kern.ParamItem, PfRepeat),
}) })
ctx.RegisterFunc("println", NewGolangFunctor(printLnFunc), TypeInt, []ExprFuncParam{ ctx.RegisterFunc("println", kern.NewGolangFunctor(printLnFunc), kern.TypeInt, []kern.ExprFuncParam{
NewFuncParamFlag(ParamItem, PfRepeat), NewFuncParamFlag(kern.ParamItem, PfRepeat),
}) })
} }

26
builtin-import.go
View File

@ -7,27 +7,29 @@ package expr
import ( import (
"io" "io"
"os" "os"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func importFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func importFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
return importGeneral(ctx, name, args) return importGeneral(ctx, name, args)
} }
func importAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func importAllFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
CtrlEnable(ctx, control_export_all) CtrlEnable(ctx, kern.ControlExportAll)
return importGeneral(ctx, name, args) return importGeneral(ctx, name, args)
} }
func importGeneral(ctx ExprContext, name string, args map[string]any) (result any, err error) { func importGeneral(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH) dirList := buildSearchDirList(ctx, "sources", ENV_EXPR_SOURCE_PATH)
if v, exists := args[ParamFilepath]; exists && v != nil { if v, exists := args[kern.ParamFilepath]; exists && v != nil {
argv := v.([]any) argv := v.([]any)
result, err = doImport(ctx, name, dirList, NewArrayIterator(argv)) result, err = doImport(ctx, name, dirList, NewArrayIterator(argv))
} }
return return
} }
func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (result any, err error) { func doImport(ctx kern.ExprContext, name string, dirList []string, it kern.Iterator) (result any, err error) {
var v any var v any
var sourceFilepath string var sourceFilepath string
@ -64,12 +66,12 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
return return
} }
func ImportImportFuncs(ctx ExprContext) { func ImportImportFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("import", NewGolangFunctor(importFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("import", kern.NewGolangFunctor(importFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParamFlag(ParamFilepath, PfRepeat), NewFuncParamFlag(kern.ParamFilepath, PfRepeat),
}) })
ctx.RegisterFunc("importAll", NewGolangFunctor(importAllFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("importAll", kern.NewGolangFunctor(importAllFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParamFlag(ParamFilepath, PfRepeat), NewFuncParamFlag(kern.ParamFilepath, PfRepeat),
}) })
} }

43
builtin-iterator.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const ( const (
@ -15,24 +17,24 @@ const (
iterVarStatus = "status" iterVarStatus = "status"
) )
func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Functor, err error) { func parseRunArgs(localCtx kern.ExprContext, args map[string]any) (it kern.Iterator, op kern.Functor, err error) {
var ok bool var ok bool
if it, ok = args[ParamIterator].(Iterator); !ok { if it, ok = args[kern.ParamIterator].(kern.Iterator); !ok {
err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[ParamIterator], TypeName(args[ParamIterator])) err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", kern.ParamIterator, args[kern.ParamIterator], kern.TypeName(args[kern.ParamIterator]))
return return
} }
if args[iterParamOperator] != nil { if args[iterParamOperator] != nil {
if op, ok = args[iterParamOperator].(Functor); !ok || op == nil { if op, ok = args[iterParamOperator].(kern.Functor); !ok || op == nil {
err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], TypeName(args[iterParamOperator])) err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], kern.TypeName(args[iterParamOperator]))
return return
} }
} }
var vars *DictType var vars *kern.DictType
if vars, ok = args[iterParamVars].(*DictType); !ok && args[iterParamVars] != nil { if vars, ok = args[iterParamVars].(*kern.DictType); !ok && args[iterParamVars] != nil {
err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[iterParamVars], TypeName(args[iterParamVars])) err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[iterParamVars], kern.TypeName(args[iterParamVars]))
return return
} }
@ -48,10 +50,10 @@ func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Fu
return return
} }
func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func runFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var it Iterator var it kern.Iterator
var ok bool var ok bool
var op Functor var op kern.Functor
var v any var v any
// var usingDefaultOp = false // var usingDefaultOp = false
var params map[string]any var params map[string]any
@ -62,25 +64,16 @@ func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err
if it, op, err = parseRunArgs(localCtx, args); err != nil { if it, op, err = parseRunArgs(localCtx, args); err != nil {
return return
// } else if op == nil {
// op = NewGolangFunctor(printLnFunc)
// usingDefaultOp = true
} }
for item, err = it.Next(); err == nil; item, err = it.Next() { for item, err = it.Next(); err == nil; item, err = it.Next() {
// if usingDefaultOp {
// params = map[string]any{ParamItem: []any{item}}
// } else {
// params = map[string]any{ParamIndex: it.Index(), ParamItem: item}
// }
if op != nil { if op != nil {
params = map[string]any{ParamIndex: it.Index(), ParamItem: item} params = map[string]any{kern.ParamIndex: it.Index(), kern.ParamItem: item}
if v, err = op.InvokeNamed(localCtx, iterParamOperator, params); err != nil { if v, err = op.InvokeNamed(localCtx, iterParamOperator, params); err != nil {
break break
} else { } else {
var success bool var success bool
if success, ok = ToBool(v); !success || !ok { if success, ok = kern.ToBool(v); !success || !ok {
break break
} }
} }
@ -99,9 +92,9 @@ func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err
return return
} }
func ImportIterFuncs(ctx ExprContext) { func ImportIterFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("run", NewGolangFunctor(runFunc), TypeAny, []ExprFuncParam{ ctx.RegisterFunc("run", kern.NewGolangFunctor(runFunc), kern.TypeAny, []kern.ExprFuncParam{
NewFuncParam(ParamIterator), NewFuncParam(kern.ParamIterator),
NewFuncParamFlag(iterParamOperator, PfOptional), NewFuncParamFlag(iterParamOperator, PfOptional),
NewFuncParamFlag(iterParamVars, PfOptional), NewFuncParamFlag(iterParamVars, PfOptional),
}) })

82
builtin-math-arith.go
View File

@ -7,35 +7,37 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func checkNumberParamExpected(funcName string, paramValue any, paramPos, level, subPos int) (err error) { func checkNumberParamExpected(funcName string, paramValue any, paramPos, level, subPos int) (err error) {
if !(IsNumber(paramValue) || isFraction(paramValue)) /*|| isList(paramValue)*/ { if !(kern.IsNumber(paramValue) || kern.IsFraction(paramValue)) /*|| isList(paramValue)*/ {
err = fmt.Errorf("%s(): param nr %d (%d in %d) has wrong type %T, number expected", err = fmt.Errorf("%s(): param nr %d (%d in %d) has wrong type %T, number expected",
funcName, paramPos+1, subPos+1, level, paramValue) funcName, paramPos+1, subPos+1, level, paramValue)
} }
return return
} }
func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) { func doAdd(ctx kern.ExprContext, name string, it kern.Iterator, count, level int) (result any, err error) {
var sumAsFloat, sumAsFract bool var sumAsFloat, sumAsFract bool
var floatSum float64 = 0.0 var floatSum float64 = 0.0
var intSum int64 = 0 var intSum int64 = 0
var fractSum *FractionType var fractSum *kern.FractionType
var v any var v any
level++ level++
for v, err = it.Next(); err == nil; v, err = it.Next() { for v, err = it.Next(); err == nil; v, err = it.Next() {
if list, ok := v.(*ListType); ok { if list, ok := v.(*kern.ListType); ok {
v = NewListIterator(list, nil) v = NewListIterator(list, nil)
} }
if subIter, ok := v.(Iterator); ok { if subIter, ok := v.(kern.Iterator); ok {
if v, err = doAdd(ctx, name, subIter, count, level); err != nil { if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
break break
} }
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) { if extIter, ok := v.(kern.ExtIterator); ok && extIter.HasOperation(kern.CleanName) {
if _, err = extIter.CallOperation(CleanName, nil); err != nil { if _, err = extIter.CallOperation(kern.CleanName, nil); err != nil {
return return
} }
} }
@ -45,29 +47,29 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
count++ count++
if !sumAsFloat { if !sumAsFloat {
if IsFloat(v) { if kern.IsFloat(v) {
sumAsFloat = true sumAsFloat = true
if sumAsFract { if sumAsFract {
floatSum = fractSum.toFloat() floatSum = fractSum.ToFloat()
} else { } else {
floatSum = float64(intSum) floatSum = float64(intSum)
} }
} else if !sumAsFract && isFraction(v) { } else if !sumAsFract && kern.IsFraction(v) {
fractSum = newFraction(intSum, 1) fractSum = kern.NewFraction(intSum, 1)
sumAsFract = true sumAsFract = true
} }
} }
if sumAsFloat { if sumAsFloat {
floatSum += numAsFloat(v) floatSum += kern.NumAsFloat(v)
} else if sumAsFract { } else if sumAsFract {
var item *FractionType var item *kern.FractionType
var ok bool var ok bool
if item, ok = v.(*FractionType); !ok { if item, ok = v.(*kern.FractionType); !ok {
iv, _ := v.(int64) iv, _ := v.(int64)
item = newFraction(iv, 1) item = kern.NewFraction(iv, 1)
} }
fractSum = sumFract(fractSum, item) fractSum = kern.SumFract(fractSum, item)
} else { } else {
iv, _ := v.(int64) iv, _ := v.(int64)
intSum += iv intSum += iv
@ -86,30 +88,30 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
return return
} }
func addFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func addFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
argv := args[ParamValue].([]any) argv := args[kern.ParamValue].([]any)
result, err = doAdd(ctx, name, NewArrayIterator(argv), 0, -1) result, err = doAdd(ctx, name, NewArrayIterator(argv), 0, -1)
return return
} }
func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) { func doMul(ctx kern.ExprContext, name string, it kern.Iterator, count, level int) (result any, err error) {
var mulAsFloat, mulAsFract bool var mulAsFloat, mulAsFract bool
var floatProd float64 = 1.0 var floatProd float64 = 1.0
var intProd int64 = 1 var intProd int64 = 1
var fractProd *FractionType var fractProd *kern.FractionType
var v any var v any
level++ level++
for v, err = it.Next(); err == nil; v, err = it.Next() { for v, err = it.Next(); err == nil; v, err = it.Next() {
if list, ok := v.(*ListType); ok { if list, ok := v.(*kern.ListType); ok {
v = NewListIterator(list, nil) v = NewListIterator(list, nil)
} }
if subIter, ok := v.(Iterator); ok { if subIter, ok := v.(kern.Iterator); ok {
if v, err = doMul(ctx, name, subIter, count, level); err != nil { if v, err = doMul(ctx, name, subIter, count, level); err != nil {
break break
} }
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) { if extIter, ok := v.(kern.ExtIterator); ok && extIter.HasOperation(kern.CleanName) {
if _, err = extIter.CallOperation(CleanName, nil); err != nil { if _, err = extIter.CallOperation(kern.CleanName, nil); err != nil {
return return
} }
} }
@ -121,29 +123,29 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
count++ count++
if !mulAsFloat { if !mulAsFloat {
if IsFloat(v) { if kern.IsFloat(v) {
mulAsFloat = true mulAsFloat = true
if mulAsFract { if mulAsFract {
floatProd = fractProd.toFloat() floatProd = fractProd.ToFloat()
} else { } else {
floatProd = float64(intProd) floatProd = float64(intProd)
} }
} else if !mulAsFract && isFraction(v) { } else if !mulAsFract && kern.IsFraction(v) {
fractProd = newFraction(intProd, 1) fractProd = kern.NewFraction(intProd, 1)
mulAsFract = true mulAsFract = true
} }
} }
if mulAsFloat { if mulAsFloat {
floatProd *= numAsFloat(v) floatProd *= kern.NumAsFloat(v)
} else if mulAsFract { } else if mulAsFract {
var item *FractionType var item *kern.FractionType
var ok bool var ok bool
if item, ok = v.(*FractionType); !ok { if item, ok = v.(*kern.FractionType); !ok {
iv, _ := v.(int64) iv, _ := v.(int64)
item = newFraction(iv, 1) item = kern.NewFraction(iv, 1)
} }
fractProd = mulFract(fractProd, item) fractProd = kern.MulFract(fractProd, item)
} else { } else {
iv, _ := v.(int64) iv, _ := v.(int64)
intProd *= iv intProd *= iv
@ -162,19 +164,19 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
return return
} }
func mulFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func mulFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
argv := args[ParamValue].([]any) argv := args[kern.ParamValue].([]any)
result, err = doMul(ctx, name, NewArrayIterator(argv), 0, -1) result, err = doMul(ctx, name, NewArrayIterator(argv), 0, -1)
return return
} }
func ImportMathFuncs(ctx ExprContext) { func ImportMathFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("add", NewGolangFunctor(addFunc), TypeNumber, []ExprFuncParam{ ctx.RegisterFunc("add", kern.NewGolangFunctor(addFunc), kern.TypeNumber, []kern.ExprFuncParam{
NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)), NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, int64(0)),
}) })
ctx.RegisterFunc("mul", NewGolangFunctor(mulFunc), TypeNumber, []ExprFuncParam{ ctx.RegisterFunc("mul", kern.NewGolangFunctor(mulFunc), kern.TypeNumber, []kern.ExprFuncParam{
NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)), NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, int64(1)),
}) })
} }

22
builtin-os-file-iter.go
View File

@ -8,6 +8,8 @@ import (
"fmt" "fmt"
"io" "io"
"slices" "slices"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const paramHandleOrPath = "handle-or-path" const paramHandleOrPath = "handle-or-path"
@ -74,7 +76,7 @@ func (it *fileReadTextIterator) Reset() (err error) {
} }
func (it *fileReadTextIterator) HasOperation(name string) bool { func (it *fileReadTextIterator) HasOperation(name string) bool {
return slices.Contains([]string{NextName, ResetName, IndexName, CountName, CurrentName, CleanName}, name) return slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName, kern.CleanName}, name)
} }
func (it *fileReadTextIterator) Clean() (err error) { func (it *fileReadTextIterator) Clean() (err error) {
@ -88,25 +90,25 @@ func (it *fileReadTextIterator) Clean() (err error) {
func (it *fileReadTextIterator) CallOperation(name string, args map[string]any) (v any, err error) { func (it *fileReadTextIterator) CallOperation(name string, args map[string]any) (v any, err error) {
switch name { switch name {
case NextName: case kern.NextName:
v, err = it.Next() v, err = it.Next()
case ResetName: case kern.ResetName:
err = it.Reset() err = it.Reset()
case CleanName: case kern.CleanName:
err = it.Clean() err = it.Clean()
case IndexName: case kern.IndexName:
v = int64(it.Index()) v = int64(it.Index())
case CurrentName: case kern.CurrentName:
v, err = it.Current() v, err = it.Current()
case CountName: case kern.CountName:
v = it.count v = it.count
default: default:
err = errNoOperation(name) err = kern.ErrNoOperation(name)
} }
return return
} }
func fileReadIteratorFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func fileReadIteratorFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var handle *osReader var handle *osReader
var invalidFileHandle any var invalidFileHandle any
var ok, autoClose bool var ok, autoClose bool
@ -115,7 +117,7 @@ func fileReadIteratorFunc(ctx ExprContext, name string, args map[string]any) (re
if handle, ok = args[paramHandleOrPath].(*osReader); !ok { if handle, ok = args[paramHandleOrPath].(*osReader); !ok {
if fileName, ok := args[paramHandleOrPath].(string); ok && len(fileName) > 0 { if fileName, ok := args[paramHandleOrPath].(string); ok && len(fileName) > 0 {
var handleAny any var handleAny any
if handleAny, err = openFileFunc(ctx, name, map[string]any{ParamFilepath: fileName}); err != nil { if handleAny, err = openFileFunc(ctx, name, map[string]any{kern.ParamFilepath: fileName}); err != nil {
return return
} }
if handleAny != nil { if handleAny != nil {

74
builtin-os-file.go
View File

@ -9,6 +9,8 @@ import (
"fmt" "fmt"
"io" "io"
"os" "os"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const ( const (
@ -65,8 +67,8 @@ func errInvalidFileHandle(funcName string, v any) error {
} }
} }
func createFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func createFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 { if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
var fh *os.File var fh *os.File
if fh, err = os.Create(filePath); err == nil { if fh, err = os.Create(filePath); err == nil {
result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)} result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@ -77,8 +79,8 @@ func createFileFunc(ctx ExprContext, name string, args map[string]any) (result a
return return
} }
func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func openFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 { if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
var fh *os.File var fh *os.File
if fh, err = os.Open(filePath); err == nil { if fh, err = os.Open(filePath); err == nil {
result = &osReader{fh: fh, reader: bufio.NewReader(fh)} result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
@ -89,8 +91,8 @@ func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any
return return
} }
func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func appendFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 { if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
var fh *os.File var fh *os.File
if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil { if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)} result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@ -101,13 +103,13 @@ func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result a
return return
} }
func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func closeFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var handle osHandle var handle osHandle
var invalidFileHandle any var invalidFileHandle any
var ok bool var ok bool
if handle, ok = args[ParamHandle].(osHandle); !ok { if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
invalidFileHandle = args[ParamHandle] invalidFileHandle = args[kern.ParamHandle]
} }
if handle != nil { if handle != nil {
@ -128,18 +130,18 @@ func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result an
return return
} }
func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func fileWriteTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var handle osHandle var handle osHandle
var invalidFileHandle any var invalidFileHandle any
var ok bool var ok bool
if handle, ok = args[ParamHandle].(osHandle); !ok { if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
invalidFileHandle = args[ParamHandle] invalidFileHandle = args[kern.ParamHandle]
} }
if handle != nil { if handle != nil {
if w, ok := handle.(*osWriter); ok { if w, ok := handle.(*osWriter); ok {
if v, exists := args[ParamItem]; exists { if v, exists := args[kern.ParamItem]; exists {
argv := v.([]any) argv := v.([]any)
result, err = fmt.Fprint(w.writer, argv...) result, err = fmt.Fprint(w.writer, argv...)
} }
@ -154,14 +156,14 @@ func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (resul
return return
} }
func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func fileReadTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var handle osHandle var handle osHandle
var invalidFileHandle any var invalidFileHandle any
var ok bool var ok bool
result = nil result = nil
if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil { if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
invalidFileHandle = args[ParamHandle] invalidFileHandle = args[kern.ParamHandle]
} }
if handle != nil { if handle != nil {
@ -194,14 +196,14 @@ func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result
return return
} }
func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func fileReadTextAllFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var handle osHandle var handle osHandle
var invalidFileHandle any var invalidFileHandle any
var ok bool var ok bool
result = nil result = nil
if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil { if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
invalidFileHandle = args[ParamHandle] invalidFileHandle = args[kern.ParamHandle]
} }
if handle != nil { if handle != nil {
@ -220,38 +222,38 @@ func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (res
return return
} }
func ImportOsFuncs(ctx ExprContext) { func ImportOsFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeFileHandle, []ExprFuncParam{ ctx.RegisterFunc("fileOpen", kern.NewGolangFunctor(openFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
NewFuncParam(ParamFilepath), NewFuncParam(kern.ParamFilepath),
}) })
ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeFileHandle, []ExprFuncParam{ ctx.RegisterFunc("fileAppend", kern.NewGolangFunctor(appendFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
NewFuncParam(ParamFilepath), NewFuncParam(kern.ParamFilepath),
}) })
ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeFileHandle, []ExprFuncParam{ ctx.RegisterFunc("fileCreate", kern.NewGolangFunctor(createFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
NewFuncParam(ParamFilepath), NewFuncParam(kern.ParamFilepath),
}) })
ctx.RegisterFunc("fileClose", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{ ctx.RegisterFunc("fileClose", kern.NewGolangFunctor(closeFileFunc), kern.TypeBoolean, []kern.ExprFuncParam{
NewFuncParam(ParamHandle), NewFuncParam(kern.ParamHandle),
}) })
ctx.RegisterFunc("fileWriteText", NewGolangFunctor(fileWriteTextFunc), TypeInt, []ExprFuncParam{ ctx.RegisterFunc("fileWriteText", kern.NewGolangFunctor(fileWriteTextFunc), kern.TypeInt, []kern.ExprFuncParam{
NewFuncParam(ParamHandle), NewFuncParam(kern.ParamHandle),
NewFuncParamFlagDef(ParamItem, PfDefault|PfRepeat, ""), NewFuncParamFlagDef(kern.ParamItem, PfDefault|PfRepeat, ""),
}) })
ctx.RegisterFunc("fileReadText", NewGolangFunctor(fileReadTextFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("fileReadText", kern.NewGolangFunctor(fileReadTextFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamHandle), NewFuncParam(kern.ParamHandle),
NewFuncParamFlagDef(osLimitCh, PfDefault, "\n"), NewFuncParamFlagDef(osLimitCh, PfDefault, "\n"),
}) })
ctx.RegisterFunc("fileReadTextAll", NewGolangFunctor(fileReadTextAllFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("fileReadTextAll", kern.NewGolangFunctor(fileReadTextAllFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamHandle), NewFuncParam(kern.ParamHandle),
}) })
ctx.RegisterFunc("fileReadIterator", NewGolangFunctor(fileReadIteratorFunc), TypeIterator, []ExprFuncParam{ ctx.RegisterFunc("fileReadIterator", kern.NewGolangFunctor(fileReadIteratorFunc), kern.TypeIterator, []kern.ExprFuncParam{
NewFuncParam(paramHandleOrPath), NewFuncParam(paramHandleOrPath),
}) })
} }

136
builtin-string.go
View File

@ -8,6 +8,8 @@ import (
"fmt" "fmt"
"io" "io"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const ( const (
@ -15,7 +17,7 @@ const (
) )
// --- Start of function definitions // --- Start of function definitions
func doJoinStr(funcName string, sep string, it Iterator) (result any, err error) { func doJoinStr(funcName string, sep string, it kern.Iterator) (result any, err error) {
var sb strings.Builder var sb strings.Builder
var v any var v any
for v, err = it.Next(); err == nil; v, err = it.Next() { for v, err = it.Next(); err == nil; v, err = it.Next() {
@ -25,7 +27,7 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
if s, ok := v.(string); ok { if s, ok := v.(string); ok {
sb.WriteString(s) sb.WriteString(s)
} else { } else {
err = ErrExpectedGot(funcName, TypeString, v) err = kern.ErrExpectedGot(funcName, kern.TypeString, v)
return return
} }
} }
@ -36,45 +38,45 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
return return
} }
func joinStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func joinStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if sep, ok := args[ParamSeparator].(string); ok { if sep, ok := args[kern.ParamSeparator].(string); ok {
if v, exists := args[ParamItem]; exists { if v, exists := args[kern.ParamItem]; exists {
argv := v.([]any) argv := v.([]any)
if len(argv) == 1 { if len(argv) == 1 {
if ls, ok := argv[0].(*ListType); ok { if ls, ok := argv[0].(*kern.ListType); ok {
result, err = doJoinStr(name, sep, NewListIterator(ls, nil)) result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
} else if it, ok := argv[0].(Iterator); ok { } else if it, ok := argv[0].(kern.Iterator); ok {
result, err = doJoinStr(name, sep, it) result, err = doJoinStr(name, sep, it)
} else if s, ok := argv[0].(string); ok { } else if s, ok := argv[0].(string); ok {
result = s result = s
} else { } else {
err = ErrInvalidParameterValue(name, ParamItem, v) err = kern.ErrInvalidParameterValue(name, kern.ParamItem, v)
} }
} else { } else {
result, err = doJoinStr(name, sep, NewArrayIterator(argv)) result, err = doJoinStr(name, sep, NewArrayIterator(argv))
} }
} }
} else { } else {
err = ErrWrongParamType(name, ParamSeparator, TypeString, args[ParamSeparator]) err = kern.ErrWrongParamType(name, kern.ParamSeparator, kern.TypeString, args[kern.ParamSeparator])
} }
return return
} }
func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func subStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var start = 0 var start = 0
var count = -1 var count = -1
var source string var source string
var ok bool var ok bool
if source, ok = args[ParamSource].(string); !ok { if source, ok = args[kern.ParamSource].(string); !ok {
return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) return nil, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
if start, err = ToGoInt(args[ParamStart], name+"()"); err != nil { if start, err = kern.ToGoInt(args[kern.ParamStart], name+"()"); err != nil {
return return
} }
if count, err = ToGoInt(args[ParamCount], name+"()"); err != nil { if count, err = kern.ToGoInt(args[kern.ParamCount], name+"()"); err != nil {
return return
} }
@ -90,29 +92,29 @@ func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any,
return return
} }
func trimStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func trimStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var source string var source string
var ok bool var ok bool
if source, ok = args[ParamSource].(string); !ok { if source, ok = args[kern.ParamSource].(string); !ok {
return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) return nil, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
result = strings.TrimSpace(source) result = strings.TrimSpace(source)
return return
} }
func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func startsWithStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var source, prefix string var source, prefix string
var ok bool var ok bool
result = false result = false
if source, ok = args[ParamSource].(string); !ok { if source, ok = args[kern.ParamSource].(string); !ok {
return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
if prefix, ok = args[ParamPrefix].(string); !ok { if prefix, ok = args[kern.ParamPrefix].(string); !ok {
return result, ErrWrongParamType(name, ParamPrefix, TypeString, args[ParamPrefix]) return result, kern.ErrWrongParamType(name, kern.ParamPrefix, kern.TypeString, args[kern.ParamPrefix])
} }
if strings.HasPrefix(source, prefix) { if strings.HasPrefix(source, prefix) {
result = true result = true
@ -125,7 +127,7 @@ func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (resul
break break
} }
} else { } else {
err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec)) err = fmt.Errorf("target item nr %d is %s, string expected", i+1, kern.TypeName(targetSpec))
break break
} }
} }
@ -133,18 +135,18 @@ func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (resul
return return
} }
func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func endsWithStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var source, suffix string var source, suffix string
var ok bool var ok bool
result = false result = false
if source, ok = args[ParamSource].(string); !ok { if source, ok = args[kern.ParamSource].(string); !ok {
return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
if suffix, ok = args[ParamSuffix].(string); !ok { if suffix, ok = args[kern.ParamSuffix].(string); !ok {
return result, ErrWrongParamType(name, ParamSuffix, TypeString, args[ParamSuffix]) return result, kern.ErrWrongParamType(name, kern.ParamSuffix, kern.TypeString, args[kern.ParamSuffix])
} }
if strings.HasPrefix(source, suffix) { if strings.HasPrefix(source, suffix) {
result = true result = true
@ -157,7 +159,7 @@ func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result
break break
} }
} else { } else {
err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec)) err = fmt.Errorf("target item nr %d is %s, string expected", i+1, kern.TypeName(targetSpec))
break break
} }
} }
@ -165,24 +167,24 @@ func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result
return return
} }
func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func splitStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var source, sep string var source, sep string
var count int = -1 var count int = -1
var parts []string var parts []string
var ok bool var ok bool
if source, ok = args[ParamSource].(string); !ok { if source, ok = args[kern.ParamSource].(string); !ok {
return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
if sep, ok = args[ParamSeparator].(string); !ok { if sep, ok = args[kern.ParamSeparator].(string); !ok {
return nil, fmt.Errorf("separator param must be string, got %s (%v)", TypeName(args[ParamSeparator]), args[ParamSeparator]) return nil, fmt.Errorf("separator param must be string, got %s (%v)", kern.TypeName(args[kern.ParamSeparator]), args[kern.ParamSeparator])
} }
if count64, ok := args[ParamCount].(int64); ok { // TODO replace type assertion with toInt() if count64, ok := args[kern.ParamCount].(int64); ok { // TODO replace type assertion with toInt()
count = int(count64) count = int(count64)
} else { } else {
return nil, fmt.Errorf("part count must be integer, got %s (%v)", TypeName(args[ParamCount]), args[ParamCount]) return nil, fmt.Errorf("part count must be integer, got %s (%v)", kern.TypeName(args[kern.ParamCount]), args[kern.ParamCount])
} }
if count > 0 { if count > 0 {
@ -192,7 +194,7 @@ func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any
} else { } else {
parts = []string{} parts = []string{}
} }
list := make(ListType, len(parts)) list := make(kern.ListType, len(parts))
for i, part := range parts { for i, part := range parts {
list[i] = part list[i] = part
} }
@ -200,20 +202,20 @@ func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any
return return
} }
func upperStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func upperStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if source, ok := args[ParamSource].(string); ok { if source, ok := args[kern.ParamSource].(string); ok {
result = strings.ToUpper(source) result = strings.ToUpper(source)
} else { } else {
err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
return return
} }
func lowerStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) { func lowerStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
if source, ok := args[ParamSource].(string); ok { if source, ok := args[kern.ParamSource].(string); ok {
result = strings.ToLower(source) result = strings.ToLower(source)
} else { } else {
err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource]) err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
} }
return return
} }
@ -221,46 +223,46 @@ func lowerStrFunc(ctx ExprContext, name string, args map[string]any) (result any
// --- End of function definitions // --- End of function definitions
// Import above functions in the context // Import above functions in the context
func ImportStringFuncs(ctx ExprContext) { func ImportStringFuncs(ctx kern.ExprContext) {
ctx.RegisterFunc("strJoin", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("strJoin", kern.NewGolangFunctor(joinStrFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSeparator), NewFuncParam(kern.ParamSeparator),
NewFuncParamFlag(ParamItem, PfRepeat), NewFuncParamFlag(kern.ParamItem, PfRepeat),
}) })
ctx.RegisterFunc("strSub", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("strSub", kern.NewGolangFunctor(subStrFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
NewFuncParamFlagDef(ParamStart, PfDefault, int64(0)), NewFuncParamFlagDef(kern.ParamStart, PfDefault, int64(0)),
NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)), NewFuncParamFlagDef(kern.ParamCount, PfDefault, int64(-1)),
}) })
ctx.RegisterFunc("strSplit", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{ ctx.RegisterFunc("strSplit", kern.NewGolangFunctor(splitStrFunc), "list of "+kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
NewFuncParamFlagDef(ParamSeparator, PfDefault, ""), NewFuncParamFlagDef(kern.ParamSeparator, PfDefault, ""),
NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)), NewFuncParamFlagDef(kern.ParamCount, PfDefault, int64(-1)),
}) })
ctx.RegisterFunc("strTrim", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("strTrim", kern.NewGolangFunctor(trimStrFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
}) })
ctx.RegisterFunc("strStartsWith", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{ ctx.RegisterFunc("strStartsWith", kern.NewGolangFunctor(startsWithStrFunc), kern.TypeBoolean, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
NewFuncParam(ParamPrefix), NewFuncParam(kern.ParamPrefix),
NewFuncParamFlag(strParamOther, PfRepeat), NewFuncParamFlag(strParamOther, PfRepeat),
}) })
ctx.RegisterFunc("strEndsWith", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{ ctx.RegisterFunc("strEndsWith", kern.NewGolangFunctor(endsWithStrFunc), kern.TypeBoolean, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
NewFuncParam(ParamSuffix), NewFuncParam(kern.ParamSuffix),
NewFuncParamFlag(strParamOther, PfRepeat), NewFuncParamFlag(strParamOther, PfRepeat),
}) })
ctx.RegisterFunc("strUpper", NewGolangFunctor(upperStrFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("strUpper", kern.NewGolangFunctor(upperStrFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
}) })
ctx.RegisterFunc("strLower", NewGolangFunctor(lowerStrFunc), TypeString, []ExprFuncParam{ ctx.RegisterFunc("strLower", kern.NewGolangFunctor(lowerStrFunc), kern.TypeString, []kern.ExprFuncParam{
NewFuncParam(ParamSource), NewFuncParam(kern.ParamSource),
}) })
} }

8
builtins-register.go
View File

@ -6,21 +6,23 @@ package expr
import ( import (
"fmt" "fmt"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type builtinModule struct { type builtinModule struct {
importFunc func(ExprContext) importFunc func(kern.ExprContext)
description string description string
imported bool imported bool
} }
func newBuiltinModule(importFunc func(ExprContext), description string) *builtinModule { func newBuiltinModule(importFunc func(kern.ExprContext), description string) *builtinModule {
return &builtinModule{importFunc, description, false} return &builtinModule{importFunc, description, false}
} }
var builtinModuleRegister map[string]*builtinModule var builtinModuleRegister map[string]*builtinModule
func RegisterBuiltinModule(name string, importFunc func(ExprContext), description string) { func RegisterBuiltinModule(name string, importFunc func(kern.ExprContext), description string) {
if builtinModuleRegister == nil { if builtinModuleRegister == nil {
builtinModuleRegister = make(map[string]*builtinModule) builtinModuleRegister = make(map[string]*builtinModule)
} }

84
data-cursor.go
View File

@ -7,11 +7,13 @@ package expr
import ( import (
"io" "io"
"slices" "slices"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type dataCursor struct { type dataCursor struct {
ds map[string]Functor ds map[string]kern.Functor
ctx ExprContext ctx kern.ExprContext
initState bool // true if no item has produced yet (this replace di initial Next() call in the contructor) initState bool // true if no item has produced yet (this replace di initial Next() call in the contructor)
// cursorValid bool // true if resource is nil or if clean has not yet been called // cursorValid bool // true if resource is nil or if clean has not yet been called
index int index int
@ -19,12 +21,12 @@ type dataCursor struct {
current any current any
lastErr error lastErr error
resource any resource any
nextFunc Functor nextFunc kern.Functor
cleanFunc Functor cleanFunc kern.Functor
resetFunc Functor resetFunc kern.Functor
} }
func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *dataCursor) { func NewDataCursor(ctx kern.ExprContext, ds map[string]kern.Functor, resource any) (dc *dataCursor) {
dc = &dataCursor{ dc = &dataCursor{
ds: ds, ds: ds,
initState: true, initState: true,
@ -35,14 +37,14 @@ func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *da
lastErr: nil, lastErr: nil,
resource: resource, resource: resource,
ctx: ctx.Clone(), ctx: ctx.Clone(),
nextFunc: ds[NextName], nextFunc: ds[kern.NextName],
cleanFunc: ds[CleanName], cleanFunc: ds[kern.CleanName],
resetFunc: ds[ResetName], resetFunc: ds[kern.ResetName],
} }
return return
} }
func (dc *dataCursor) Context() ExprContext { func (dc *dataCursor) Context() kern.ExprContext {
return dc.ctx return dc.ctx
} }
@ -79,27 +81,27 @@ func (dc *dataCursor) String() string {
} }
func (dc *dataCursor) HasOperation(name string) (exists bool) { func (dc *dataCursor) HasOperation(name string) (exists bool) {
exists = slices.Contains([]string{CleanName, ResetName, CurrentName, IndexName}, name) exists = slices.Contains([]string{kern.CleanName, kern.ResetName, kern.CurrentName, kern.IndexName}, name)
if !exists { if !exists {
f, ok := dc.ds[name] f, ok := dc.ds[name]
exists = ok && isFunctor(f) exists = ok && kern.IsFunctor(f)
} }
return return
} }
func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) { func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) {
if name == IndexName { if name == kern.IndexName {
value = int64(dc.Index()) value = int64(dc.Index())
} else if name == CleanName { } else if name == kern.CleanName {
err = dc.Clean() err = dc.Clean()
} else if name == ResetName { } else if name == kern.ResetName {
err = dc.Reset() err = dc.Reset()
} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) { } else if functor, ok := dc.ds[name]; ok && kern.IsFunctor(functor) {
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
value, err = functor.InvokeNamed(ctx, name, args) value, err = functor.InvokeNamed(ctx, name, args)
exportObjects(dc.ctx, ctx) kern.ExportObjects(dc.ctx, ctx)
} else { } else {
err = errNoOperation(name) err = kern.ErrNoOperation(name)
} }
return return
} }
@ -127,10 +129,10 @@ func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any
func (dc *dataCursor) Reset() (err error) { func (dc *dataCursor) Reset() (err error) {
if dc.resetFunc != nil { if dc.resetFunc != nil {
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
actualParams := bindActualParams(dc.resetFunc, []any{dc.resource}) actualParams := kern.BindActualParams(dc.resetFunc, []any{dc.resource})
_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams) _, err = dc.resetFunc.InvokeNamed(ctx, kern.ResetName, actualParams)
exportObjects(dc.ctx, ctx) kern.ExportObjects(dc.ctx, ctx)
} }
dc.index = -1 dc.index = -1
dc.count = 0 dc.count = 0
@ -142,10 +144,10 @@ func (dc *dataCursor) Reset() (err error) {
func (dc *dataCursor) Clean() (err error) { func (dc *dataCursor) Clean() (err error) {
if dc.cleanFunc != nil { if dc.cleanFunc != nil {
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource}) actualParams := kern.BindActualParams(dc.cleanFunc, []any{dc.resource})
_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams) _, err = dc.cleanFunc.InvokeNamed(ctx, kern.CleanName, actualParams)
exportObjects(dc.ctx, ctx) kern.ExportObjects(dc.ctx, ctx)
} }
dc.lastErr = io.EOF dc.lastErr = io.EOF
return return
@ -178,13 +180,13 @@ func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at
return return
} }
func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err error) { func (dc *dataCursor) checkFilter(filter kern.Functor, item any) (accepted bool, err error) {
var v any var v any
var ok bool var ok bool
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
actualParams := bindActualParams(filter, []any{item, dc.index}) actualParams := kern.BindActualParams(filter, []any{item, dc.index})
if v, err = filter.InvokeNamed(ctx, FilterName, actualParams); err == nil && v != nil { if v, err = filter.InvokeNamed(ctx, kern.FilterName, actualParams); err == nil && v != nil {
if accepted, ok = v.(bool); !ok { if accepted, ok = v.(bool); !ok {
accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted
} }
@ -192,10 +194,10 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
return return
} }
func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) { func (dc *dataCursor) mapItem(mapper kern.Functor, item any) (mappedItem any, err error) {
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
actualParams := bindActualParams(mapper, []any{item, dc.index}) actualParams := kern.BindActualParams(mapper, []any{item, dc.index})
mappedItem, err = mapper.InvokeNamed(ctx, MapName, actualParams) mappedItem, err = mapper.InvokeNamed(ctx, kern.MapName, actualParams)
return return
} }
@ -213,15 +215,15 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
return return
} }
current = dc.current current = dc.current
filter := dc.ds[FilterName] filter := dc.ds[kern.FilterName]
mapper := dc.ds[MapName] mapper := dc.ds[kern.MapName]
var item any var item any
for item == nil && dc.lastErr == nil { for item == nil && dc.lastErr == nil {
ctx := cloneContext(dc.ctx) ctx := kern.CloneContext(dc.ctx)
dc.index++ dc.index++
actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index}) actualParams := kern.BindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil { if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, kern.NextName, actualParams); dc.lastErr == nil {
if item == nil { if item == nil {
dc.lastErr = io.EOF dc.lastErr = io.EOF
} else { } else {
@ -239,7 +241,7 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
} }
} }
} }
exportObjects(dc.ctx, ctx) kern.ExportObjects(dc.ctx, ctx)
} }
dc.current = item dc.current = item
if dc.lastErr != nil { if dc.lastErr != nil {

34
dict-iterator.go
View File

@ -9,6 +9,8 @@ import (
"io" "io"
"slices" "slices"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type dictIterMode int type dictIterMode int
@ -20,7 +22,7 @@ const (
) )
type DictIterator struct { type DictIterator struct {
a *DictType a *kern.DictType
count int count int
index int index int
keys []any keys []any
@ -65,7 +67,7 @@ func (it *DictIterator) makeKeys(m map[any]any, sort sortType) {
} }
} }
func NewDictIterator(dict *DictType, args []any) (it *DictIterator, err error) { func NewDictIterator(dict *kern.DictType, args []any) (it *DictIterator, err error) {
var sortType = sortTypeNone var sortType = sortTypeNone
var s string var s string
var argAny any var argAny any
@ -76,7 +78,7 @@ func NewDictIterator(dict *DictType, args []any) (it *DictIterator, err error) {
} else { } else {
argAny = "default" argAny = "default"
} }
if s, err = ToGoString(argAny, "sort type"); err == nil { if s, err = kern.ToGoString(argAny, "sort type"); err == nil {
switch strings.ToLower(s) { switch strings.ToLower(s) {
case "a", "asc": case "a", "asc":
sortType = sortTypeAsc sortType = sortTypeAsc
@ -97,7 +99,7 @@ func NewDictIterator(dict *DictType, args []any) (it *DictIterator, err error) {
argAny = "default" argAny = "default"
} }
if s, err = ToGoString(argAny, "iteration mode"); err == nil { if s, err = kern.ToGoString(argAny, "iteration mode"); err == nil {
switch strings.ToLower(s) { switch strings.ToLower(s) {
case "k", "key", "keys": case "k", "key", "keys":
dictIt.iterMode = dictIterModeKeys dictIt.iterMode = dictIterModeKeys
@ -119,7 +121,7 @@ func NewDictIterator(dict *DictType, args []any) (it *DictIterator, err error) {
} }
func NewMapIterator(m map[any]any) (it *DictIterator) { func NewMapIterator(m map[any]any) (it *DictIterator) {
it = &DictIterator{a: (*DictType)(&m), count: 0, index: -1, keys: nil} it = &DictIterator{a: (*kern.DictType)(&m), count: 0, index: -1, keys: nil}
it.makeKeys(m, sortTypeNone) it.makeKeys(m, sortTypeNone)
return return
} }
@ -138,31 +140,31 @@ func (it *DictIterator) TypeName() string {
func (it *DictIterator) HasOperation(name string) bool { func (it *DictIterator) HasOperation(name string) bool {
// yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName // yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
yes := slices.Contains([]string{NextName, ResetName, IndexName, CountName, CurrentName, CleanName, KeyName, ValueName}, name) yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName, kern.CleanName, kern.KeyName, kern.ValueName}, name)
return yes return yes
} }
func (it *DictIterator) CallOperation(name string, args map[string]any) (v any, err error) { func (it *DictIterator) CallOperation(name string, args map[string]any) (v any, err error) {
switch name { switch name {
case NextName: case kern.NextName:
v, err = it.Next() v, err = it.Next()
case ResetName: case kern.ResetName:
err = it.Reset() err = it.Reset()
case CleanName: case kern.CleanName:
err = it.Clean() err = it.Clean()
case IndexName: case kern.IndexName:
v = int64(it.Index()) v = int64(it.Index())
case CurrentName: case kern.CurrentName:
v, err = it.Current() v, err = it.Current()
case CountName: case kern.CountName:
v = it.count v = it.count
case KeyName: case kern.KeyName:
if it.index >= 0 && it.index < len(it.keys) { if it.index >= 0 && it.index < len(it.keys) {
v = it.keys[it.index] v = it.keys[it.index]
} else { } else {
err = io.EOF err = io.EOF
} }
case ValueName: case kern.ValueName:
if it.index >= 0 && it.index < len(it.keys) { if it.index >= 0 && it.index < len(it.keys) {
a := *(it.a) a := *(it.a)
v = a[it.keys[it.index]] v = a[it.keys[it.index]]
@ -170,7 +172,7 @@ func (it *DictIterator) CallOperation(name string, args map[string]any) (v any,
err = io.EOF err = io.EOF
} }
default: default:
err = errNoOperation(name) err = kern.ErrNoOperation(name)
} }
return return
} }
@ -186,7 +188,7 @@ func (it *DictIterator) Current() (item any, err error) {
case dictIterModeItems: case dictIterModeItems:
a := *(it.a) a := *(it.a)
pair := []any{it.keys[it.index], a[it.keys[it.index]]} pair := []any{it.keys[it.index], a[it.keys[it.index]]}
item = newList(pair) item = kern.NewList(pair)
} }
} else { } else {
err = io.EOF err = io.EOF

44
doc/Expr.adoc
View File

@ -1421,12 +1421,38 @@ Same as <<_add,add()>> but returns the product of the values of the parameters.
[green]`24` [green]`24`
==== Module "os.file" ==== Module "os.file"
The "os.file" module provides functions for working with files.
Activation: +
`{4sp}builtin "os.file"`
Currently available functions:
* <<_fileOpen,fileOpen()>>
* <<_fileAppend,fileAppend()>>
* <<_fileCreate,fileCreate()>>
* <<_fileClose,fileClose()>>
* <<_fileWriteText,fileWriteText()>>
* <<_fileReadText,fileReadText()>>
* <<_fileReadTextAll,fileReadTextAll()>>
More functions will be added in the future.
---
===== fileOpen() ===== fileOpen()
Syntax: +
`{4sp}fileOpen(<file-path>) -> file-handle`
Returns a file handle for the specified file path. The file is opened in read-write mode. If the file does not exist, it is created.
===== fileAppend() ===== fileAppend()
===== fileCreate() ===== fileCreate()
Syntax: +
`{4sp}fileCreate(<file-path>) -> file-handle`
Creates or truncates the named _<file-path>_. If the file already exists, it is truncated. If the file does not exist, it is created with mode 0o666 (before umask). The associated file descriptor has mode [O_RDWR]. The directory containing the file must already exist.
===== fileClose() ===== fileClose()
@ -1438,6 +1464,24 @@ Same as <<_add,add()>> but returns the product of the values of the parameters.
==== Module "string" ==== Module "string"
This module provides functions for working with strings.
Activation: +
`{4sp}builtin "string"`
Currently available functions:
* <<_strJoin,strJoin()>>
* <<_strSub,strSub()>>
* <<_strSplit,strSplit()>>
* <<_strTrim,strTrim()>>
* <<_strStartsWith,strStartsWith()>>
* <<_strEndsWith,strEndsWith()>>
* <<_strUpper,strUpper()>>
* <<_strLower,strLower()>>
---
===== strJoin() ===== strJoin()
Syntax: + Syntax: +

8
expr.go
View File

@ -4,9 +4,13 @@
// expr.go // expr.go
package expr package expr
import (
kern "git.portale-stac.it/go-pkg/expr/kern"
)
// ----Expression interface // ----Expression interface
type Expr interface { type Expr interface {
Typer kern.Typer
Eval(ctx ExprContext) (result any, err error) Eval(ctx kern.ExprContext) (result any, err error)
String() string String() string
} }

201
function.go
View File

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

116
global-context.go
View File

@ -7,20 +7,25 @@ package expr
import ( import (
"path/filepath" "path/filepath"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
var globalCtx *SimpleStore //var globalCtx *SimpleStore
func ImportInContext(name string) (exists bool) { func ImportInContext(ctx kern.ExprContext, name string) (exists bool) {
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
var mod *builtinModule var mod *builtinModule
if mod, exists = builtinModuleRegister[name]; exists { if mod, exists = builtinModuleRegister[name]; exists {
mod.importFunc(globalCtx) mod.importFunc(globalCtx)
mod.imported = true mod.imported = true
} }
}
return return
} }
func ImportInContextByGlobPattern(pattern string) (count int, err error) { func ImportInContextByGlobPattern(ctx kern.ExprContext, pattern string) (count int, err error) {
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
var matched bool var matched bool
for name, mod := range builtinModuleRegister { for name, mod := range builtinModuleRegister {
if matched, err = filepath.Match(pattern, name); err == nil { if matched, err = filepath.Match(pattern, name); err == nil {
@ -33,75 +38,37 @@ func ImportInContextByGlobPattern(pattern string) (count int, err error) {
break break
} }
} }
return
}
func GetVar(ctx ExprContext, name string) (value any, exists bool) {
if value, exists = ctx.GetVar(name); !exists {
value, exists = globalCtx.GetVar(name)
} }
return return
} }
func GetLocalFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) { func GlobalCtrlSet(ctx kern.ExprContext, name string, newValue any) (currentValue any) {
var v any if globalCtx := ctx.GetGlobal(); globalCtx != nil {
if len(name) > 0 {
if v, exists = ctx.GetVar(name); exists && isFunctor(v) {
f, _ := v.(Functor)
item = f.GetFunc()
} else {
item, exists = ctx.GetFuncInfo(name)
}
}
return
}
func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
// if len(name) > 0 {
// if item, exists = GetLocalFuncInfo(ctx, name); exists {
// ownerCtx = ctx
// } else if item, exists = globalCtx.GetFuncInfo(name); exists {
// ownerCtx = globalCtx
// }
// }
item, exists, _ = GetFuncInfoAndOwner(ctx, name)
return
}
func GetFuncInfoAndOwner(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
if len(name) > 0 {
if item, exists = GetLocalFuncInfo(ctx, name); exists {
ownerCtx = ctx
} else if item, exists = globalCtx.GetFuncInfo(name); exists {
ownerCtx = globalCtx
}
}
return
}
func GlobalCtrlSet(name string, newValue any) (currentValue any) {
if !strings.HasPrefix(name, "_") { if !strings.HasPrefix(name, "_") {
name = "_" + name name = "_" + name
} }
currentValue, _ = globalCtx.GetVar(name)
currentValue, _ = globalCtx.GetVar(name)
globalCtx.SetVar(name, newValue) globalCtx.SetVar(name, newValue)
}
return currentValue return currentValue
} }
func GlobalCtrlGet(name string) (currentValue any) { func GlobalCtrlGet(ctx kern.ExprContext, name string) (currentValue any) {
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
if !strings.HasPrefix(name, "_") { if !strings.HasPrefix(name, "_") {
name = "_" + name name = "_" + name
} }
currentValue, _ = globalCtx.GetVar(name) currentValue, _ = globalCtx.GetVar(name)
}
return currentValue return currentValue
} }
func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) { func CtrlEnable(ctx kern.ExprContext, name string) (currentStatus bool) {
if !strings.HasPrefix(name, "_") { if !strings.HasPrefix(name, "_") {
name = "_" + name name = "_" + name
} }
if v, exists := ctx.GetVar(name); exists && IsBool(v) { if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
currentStatus, _ = v.(bool) currentStatus, _ = v.(bool)
} }
@ -109,11 +76,11 @@ func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) {
return currentStatus return currentStatus
} }
func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) { func CtrlDisable(ctx kern.ExprContext, name string) (currentStatus bool) {
if !strings.HasPrefix(name, "_") { if !strings.HasPrefix(name, "_") {
name = "_" + name name = "_" + name
} }
if v, exists := ctx.GetVar(name); exists && IsBool(v) { if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
currentStatus, _ = v.(bool) currentStatus, _ = v.(bool)
} }
@ -121,36 +88,39 @@ func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) {
return currentStatus return currentStatus
} }
func CtrlIsEnabled(ctx ExprContext, name string) (status bool) { // func CtrlIsEnabled(ctx ExprContext, name string) (status bool) {
var v any // var v any
var exists bool // var exists bool
if !strings.HasPrefix(name, "_") { // if !strings.HasPrefix(name, "_") {
name = "_" + name // name = "_" + name
} // }
if v, exists = ctx.GetVar(name); !exists { // if v, exists = ctx.GetVar(name); !exists {
v, exists = globalCtx.GetVar(name) // v, exists = globalCtx.GetVar(name)
} // }
if exists { // if exists {
if b, ok := v.(bool); ok { // if b, ok := v.(bool); ok {
status = b // status = b
} // }
} // }
return // return
} // }
func getControlString(name string) (s string, exists bool) { func getControlString(ctx kern.ExprContext, name string) (s string, exists bool) {
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
var v any var v any
if v, exists = globalCtx.GetVar(name); exists { if v, exists = globalCtx.GetVar(name); exists {
s, exists = v.(string) s, exists = v.(string)
} }
}
return return
} }
func init() { func InitGlobal() (ctx kern.ExprContext) {
globalCtx = NewSimpleStore() ctx = NewSimpleStoreWithoutGlobalContext()
initDefaultVars(globalCtx) kern.InitDefaultVars(ctx)
ImportBuiltinsFuncs(globalCtx) ImportBuiltinsFuncs(ctx)
return
} }

2
graph.go
View File

@ -53,7 +53,7 @@ func (r *Reticle) computeCharWidth() {
if v := ref.node.value(); v != nil { if v := ref.node.value(); v != nil {
ref.label = fmt.Sprintf("%v", v) ref.label = fmt.Sprintf("%v", v)
} else { } else {
ref.label = ref.node.source() ref.label = ref.node.Source()
} }
r.colsWidth[c] = max(r.colsWidth[c], len(ref.label)+2) // +2 to make room for brakets r.colsWidth[c] = max(r.colsWidth[c], len(ref.label)+2) // +2 to make room for brakets
} }

24
helpers.go
View File

@ -9,9 +9,11 @@ import (
"io" "io"
"os" "os"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func EvalString(ctx ExprContext, source string) (result any, err error) { func EvalString(ctx kern.ExprContext, source string) (result any, err error) {
var tree *ast var tree *ast
r := strings.NewReader(source) r := strings.NewReader(source)
@ -34,21 +36,21 @@ func EvalStringA(source string, args ...Arg) (result any, err error) {
} }
func EvalStringV(source string, args []Arg) (result any, err error) { func EvalStringV(source string, args []Arg) (result any, err error) {
ctx := NewSimpleStore() ctx := NewSimpleStoreWithoutGlobalContext()
for _, arg := range args { for _, arg := range args {
if isFunc(arg.Value) { if kern.IsFunc(arg.Value) {
if f, ok := arg.Value.(FuncTemplate); ok { if f, ok := arg.Value.(kern.FuncTemplate); ok {
functor := NewGolangFunctor(f) functor := kern.NewGolangFunctor(f)
// ctx.RegisterFunc(arg.Name, functor, 0, -1) // ctx.RegisterFunc(arg.Name, functor, 0, -1)
ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{ ctx.RegisterFunc(arg.Name, functor, kern.TypeAny, []kern.ExprFuncParam{
NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, 0), NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, 0),
}) })
} else { } else {
err = fmt.Errorf("invalid function specification: %q", arg.Name) err = fmt.Errorf("invalid function specification: %q", arg.Name)
} }
} else if integer, ok := anyInteger(arg.Value); ok { } else if integer, ok := kern.AnyInteger(arg.Value); ok {
ctx.SetVar(arg.Name, integer) ctx.SetVar(arg.Name, integer)
} else if float, ok := anyFloat(arg.Value); ok { } else if float, ok := kern.AnyFloat(arg.Value); ok {
ctx.SetVar(arg.Name, float) ctx.SetVar(arg.Name, float)
} else if _, ok := arg.Value.(string); ok { } else if _, ok := arg.Value.(string); ok {
ctx.SetVar(arg.Name, arg.Value) ctx.SetVar(arg.Name, arg.Value)
@ -65,7 +67,7 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
return return
} }
func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) { func EvalStream(ctx kern.ExprContext, r io.Reader) (result any, err error) {
var tree *ast var tree *ast
scanner := NewScanner(r, DefaultTranslations()) scanner := NewScanner(r, DefaultTranslations())
parser := NewParser() parser := NewParser()
@ -76,7 +78,7 @@ func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
return return
} }
func EvalFile(ctx ExprContext, filePath string) (result any, err error) { func EvalFile(ctx kern.ExprContext, filePath string) (result any, err error) {
var fh *os.File var fh *os.File
if fh, err = os.Open(filePath); err != nil { if fh, err = os.Open(filePath); err != nil {
return nil, err return nil, err

18
import-utils.go
View File

@ -11,6 +11,8 @@ import (
"path" "path"
"path/filepath" "path/filepath"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
const ( const (
@ -19,8 +21,8 @@ const (
) )
func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) { func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
if !(IsString(paramValue) /*|| isList(paramValue)*/) { if !(kern.IsString(paramValue) /*|| isList(paramValue)*/) {
err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, TypeName(paramValue)) err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, kern.TypeName(paramValue))
} }
return return
} }
@ -45,8 +47,8 @@ func addEnvImportDirs(envVarName string, dirList []string) []string {
return dirList return dirList
} }
func addSearchDirs(endingPath string, dirList []string) []string { func addSearchDirs(ctx kern.ExprContext, endingPath string, dirList []string) []string {
if dirSpec, exists := getControlString(ControlSearchPath); exists { if dirSpec, exists := getControlString(ctx, kern.ControlSearchPath); exists {
dirs := strings.Split(dirSpec, ":") dirs := strings.Split(dirSpec, ":")
if dirList == nil { if dirList == nil {
dirList = dirs dirList = dirs
@ -63,9 +65,9 @@ func addSearchDirs(endingPath string, dirList []string) []string {
return dirList return dirList
} }
func buildSearchDirList(endingPath, envVarName string) (dirList []string) { func buildSearchDirList(ctx kern.ExprContext, endingPath, envVarName string) (dirList []string) {
dirList = addEnvImportDirs(envVarName, dirList) dirList = addEnvImportDirs(envVarName, dirList)
dirList = addSearchDirs(endingPath, dirList) dirList = addSearchDirs(ctx, endingPath, dirList)
return return
} }
@ -83,7 +85,7 @@ func searchAmongPath(filename string, dirList []string) (filePath string) {
} }
for _, dir := range dirList { for _, dir := range dirList {
if dir, err = ExpandPath(dir); err != nil { if dir, err = kern.ExpandPath(dir); err != nil {
continue continue
} }
if fullPath := path.Join(dir, filename); isFile(fullPath) { if fullPath := path.Join(dir, filename); isFile(fullPath) {
@ -106,7 +108,7 @@ func isPathRelative(filePath string) bool {
} }
func makeFilepath(filename string, dirList []string) (filePath string, err error) { func makeFilepath(filename string, dirList []string) (filePath string, err error) {
if filename, err = ExpandPath(filename); err != nil { if filename, err = kern.ExpandPath(filename); err != nil {
return return
} }

12
iter-factory.go
View File

@ -4,19 +4,23 @@
// iter-factory.go // iter-factory.go
package expr package expr
func NewIterator(value any) (it Iterator, err error) { import (
"git.portale-stac.it/go-pkg/expr/kern"
)
func NewIterator(value any) (it kern.Iterator, err error) {
if value == nil { if value == nil {
return NewArrayIterator([]any{}), nil return NewArrayIterator([]any{}), nil
} }
switch v := value.(type) { switch v := value.(type) {
case *ListType: case *kern.ListType:
it = NewListIterator(v, nil) it = NewListIterator(v, nil)
case *DictType: case *kern.DictType:
it, err = NewDictIterator(v, nil) it, err = NewDictIterator(v, nil)
case []any: case []any:
it = NewArrayIterator(v) it = NewArrayIterator(v)
case Iterator: case kern.Iterator:
it = v it = v
default: default:
it = NewArrayIterator([]any{value}) it = NewArrayIterator([]any{value})

4
bind-go-functions.go → kern/bind-go-functions.go
View File

@ -2,11 +2,11 @@
// All rights reserved. // All rights reserved.
// bind-go-function.go // bind-go-function.go
package expr package kern
// ---- Linking with Go functions // ---- Linking with Go functions
type golangFunctor struct { type golangFunctor struct {
baseFunctor BaseFunctor
f FuncTemplate f FuncTemplate
} }

6
common-errors.go → kern/common-errors.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// common-errors.go // common-errors.go
package expr package kern
import ( import (
"fmt" "fmt"
@ -86,6 +86,6 @@ func ErrUnknownVar(funcName, varName string) error {
// --- Operator errors // --- Operator errors
func ErrLeftOperandMustBeVariable(leftTerm, opTerm *term) error { func ErrLeftOperandMustBeVariable(leftTerm, opTerm Term) error {
return leftTerm.Errorf("left operand of %q must be a variable", opTerm.source()) return leftTerm.Errorf("left operand of %q must be a variable", opTerm.Source())
} }

2
common-params.go → kern/common-params.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// common-params.go // common-params.go
package expr package kern
const ( const (
ParamArgs = "args" ParamArgs = "args"

2
common-type-names.go → kern/common-type-names.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// common-type-names.go // common-type-names.go
package expr package kern
const ( const (
TypeAny = "any" TypeAny = "any"

10
context-helpers.go → kern/context-helpers.go
View File

@ -2,9 +2,9 @@
// All rights reserved. // All rights reserved.
// context-helpers.go // context-helpers.go
package expr package kern
func cloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) { func CloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) {
if sourceCtx != nil { if sourceCtx != nil {
clonedCtx = sourceCtx.Clone() clonedCtx = sourceCtx.Clone()
} }
@ -25,8 +25,8 @@ func exportFunc(ctx ExprContext, name string, info ExprFunc) {
ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params()) ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
} }
func exportObjects(destCtx, sourceCtx ExprContext) { func ExportObjects(destCtx, sourceCtx ExprContext) {
exportAll := CtrlIsEnabled(sourceCtx, control_export_all) exportAll := CtrlIsEnabled(sourceCtx, ControlExportAll)
// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll) // fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
// Export variables // Export variables
for _, refName := range sourceCtx.EnumVars(func(name string) bool { return (exportAll || name[0] == '@') && !(name[0] == '_') }) { for _, refName := range sourceCtx.EnumVars(func(name string) bool { return (exportAll || name[0] == '@') && !(name[0] == '_') }) {
@ -44,6 +44,6 @@ func exportObjects(destCtx, sourceCtx ExprContext) {
func exportObjectsToParent(sourceCtx ExprContext) { func exportObjectsToParent(sourceCtx ExprContext) {
if parentCtx := sourceCtx.GetParent(); parentCtx != nil { if parentCtx := sourceCtx.GetParent(); parentCtx != nil {
exportObjects(parentCtx, sourceCtx) ExportObjects(parentCtx, sourceCtx)
} }
} }

29
control.go → kern/control.go
View File

@ -2,7 +2,9 @@
// All rights reserved. // All rights reserved.
// control.go // control.go
package expr package kern
import "strings"
// Preset control variables // Preset control variables
const ( const (
@ -16,7 +18,7 @@ const (
// Other control variables // Other control variables
const ( const (
control_export_all = "_export_all" ControlExportAll = "_export_all"
) )
// Initial values // Initial values
@ -24,13 +26,34 @@ const (
init_search_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr" init_search_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
) )
func CtrlIsEnabled(ctx ExprContext, name string) (status bool) {
var v any
var exists bool
if !strings.HasPrefix(name, "_") {
name = "_" + name
}
if v, exists = ctx.GetVar(name); !exists {
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
v, exists = globalCtx.GetVar(name)
}
}
if exists {
if b, ok := v.(bool); ok {
status = b
}
}
return
}
func SetCtrl(ctx ExprContext, name string, value any) (current any) { func SetCtrl(ctx ExprContext, name string, value any) (current any) {
current, _ = ctx.GetVar(name) current, _ = ctx.GetVar(name)
ctx.UnsafeSetVar(name, value) ctx.UnsafeSetVar(name, value)
return return
} }
func initDefaultVars(ctx ExprContext) { func InitDefaultVars(ctx ExprContext) {
if _, exists := ctx.GetVar(ControlPreset); exists { if _, exists := ctx.GetVar(ControlPreset); exists {
return return
} }

14
dict-type.go → kern/dict-type.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// dict-type.go // dict-type.go
package expr package kern
import ( import (
"fmt" "fmt"
@ -32,7 +32,7 @@ func NewDict(dictAny map[any]any) (dict *DictType) {
return return
} }
func newDict(dictAny map[any]*term) (dict *DictType) { func newDict(dictAny map[any]Term) (dict *DictType) {
// TODO Change with a call to NewDict() // TODO Change with a call to NewDict()
var d DictType var d DictType
if dictAny != nil { if dictAny != nil {
@ -110,7 +110,7 @@ func (dict *DictType) ToString(opt FmtOpt) string {
sb.WriteString(": ") sb.WriteString(": ")
if formatter, ok := value.(Formatter); ok { if formatter, ok := value.(Formatter); ok {
sb.WriteString(formatter.ToString(opt)) sb.WriteString(formatter.ToString(opt))
} else if t, ok := value.(*term); ok { } else if t, ok := value.(Term); ok {
sb.WriteString(t.String()) sb.WriteString(t.String())
} else { } else {
sb.WriteString(fmt.Sprintf("%#v", value)) sb.WriteString(fmt.Sprintf("%#v", value))
@ -129,7 +129,7 @@ func (dict *DictType) TypeName() string {
return "dict" return "dict"
} }
func (dict *DictType) hasKey(target any) (ok bool) { func (dict *DictType) HasKey(target any) (ok bool) {
for key := range *dict { for key := range *dict {
if ok = reflect.DeepEqual(key, target); ok { if ok = reflect.DeepEqual(key, target); ok {
break break
@ -138,7 +138,7 @@ func (dict *DictType) hasKey(target any) (ok bool) {
return return
} }
func (dict *DictType) clone() (c *DictType) { func (dict *DictType) Clone() (c *DictType) {
c = newDict(nil) c = newDict(nil)
for k, v := range *dict { for k, v := range *dict {
(*c)[k] = v (*c)[k] = v
@ -146,7 +146,7 @@ func (dict *DictType) clone() (c *DictType) {
return return
} }
func (dict *DictType) merge(second *DictType) { func (dict *DictType) Merge(second *DictType) {
if second != nil { if second != nil {
for k, v := range *second { for k, v := range *second {
(*dict)[k] = v (*dict)[k] = v
@ -154,7 +154,7 @@ func (dict *DictType) merge(second *DictType) {
} }
} }
func (dict *DictType) setItem(key any, value any) (err error) { func (dict *DictType) SetItem(key any, value any) (err error) {
(*dict)[key] = value (*dict)[key] = value
return return
} }

4
expr-context.go → kern/expr-context.go
View File

@ -2,13 +2,14 @@
// All rights reserved. // All rights reserved.
// expr-context.go // expr-context.go
package expr package kern
// ----Expression Context // ----Expression Context
type ExprContext interface { type ExprContext interface {
Clone() ExprContext Clone() ExprContext
SetParent(ctx ExprContext) SetParent(ctx ExprContext)
GetParent() (ctx ExprContext) GetParent() (ctx ExprContext)
GetGlobal() (ctx ExprContext)
GetVar(varName string) (value any, exists bool) GetVar(varName string) (value any, exists bool)
GetLast() any GetLast() any
SetVar(varName string, value any) SetVar(varName string, value any)
@ -22,6 +23,7 @@ type ExprContext interface {
FuncCount() int FuncCount() int
DeleteFunc(funcName string) DeleteFunc(funcName string)
GetLocalFuncInfo(name string) (info ExprFunc, exists bool)
GetFuncInfo(name string) (item ExprFunc, exists bool) GetFuncInfo(name string) (item ExprFunc, exists bool)
Call(name string, args map[string]any) (result any, err error) Call(name string, args map[string]any) (result any, err error)
RegisterFuncInfo(info ExprFunc) RegisterFuncInfo(info ExprFunc)

2
expr-function.go → kern/expr-function.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// expr-function.go // expr-function.go
package expr package kern
// ---- Functor interface // ---- Functor interface
type Functor interface { type Functor interface {

4
formatter.go → kern/formatter.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// formatter.go // formatter.go
package expr package kern
import "fmt" import "fmt"
@ -46,7 +46,7 @@ type Formatter interface {
ToString(options FmtOpt) string ToString(options FmtOpt) string
} }
func getFormatted(v any, opt FmtOpt) (text string) { func GetFormatted(v any, opt FmtOpt) (text string) {
if v == nil { if v == nil {
text = "(nil)" text = "(nil)"
} else if s, ok := v.(string); ok { } else if s, ok := v.(string); ok {

58
fraction-type.go → kern/fraction-type.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// fraction-type.go // fraction-type.go
package expr package kern
//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html //https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
@ -18,12 +18,12 @@ type FractionType struct {
num, den int64 num, den int64
} }
func newFraction(num, den int64) *FractionType { func NewFraction(num, den int64) *FractionType {
num, den = simplifyIntegers(num, den) num, den = simplifyIntegers(num, den)
return &FractionType{num, den} return &FractionType{num, den}
} }
func float64ToFraction(f float64) (fract *FractionType, err error) { func Float64ToFraction(f float64) (fract *FractionType, err error) {
var sign string var sign string
intPart, decPart := math.Modf(f) intPart, decPart := math.Modf(f)
if decPart < 0.0 { if decPart < 0.0 {
@ -33,11 +33,11 @@ func float64ToFraction(f float64) (fract *FractionType, err error) {
} }
dec := fmt.Sprintf("%.12f", decPart) dec := fmt.Sprintf("%.12f", decPart)
s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:]) s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
return makeGeneratingFraction(s) return MakeGeneratingFraction(s)
} }
// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39 // Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
func makeGeneratingFraction(s string) (f *FractionType, err error) { func MakeGeneratingFraction(s string) (f *FractionType, err error) {
var num, den int64 var num, den int64
var sign int64 = 1 var sign int64 = 1
var parts []string var parts []string
@ -59,7 +59,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
return return
} }
if len(parts) == 1 { if len(parts) == 1 {
f = newFraction(sign*num, 1) f = NewFraction(sign*num, 1)
} else if len(parts) == 2 { } else if len(parts) == 2 {
subParts := strings.SplitN(parts[1], "(", 2) subParts := strings.SplitN(parts[1], "(", 2)
if len(subParts) == 1 { if len(subParts) == 1 {
@ -76,7 +76,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
num = num*10 + int64(c-'0') num = num*10 + int64(c-'0')
den = den * 10 den = den * 10
} }
f = newFraction(sign*num, den) f = NewFraction(sign*num, den)
} else if len(subParts) == 2 { } else if len(subParts) == 2 {
sub := num sub := num
mul := int64(1) mul := int64(1)
@ -103,7 +103,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
den *= mul den *= mul
} }
num -= sub num -= sub
f = newFraction(sign*num, den) f = NewFraction(sign*num, den)
} }
} }
exit: exit:
@ -113,7 +113,15 @@ exit:
return return
} }
func (f *FractionType) toFloat() float64 { func (f *FractionType) N() int64 {
return f.num
}
func (f *FractionType) D() int64 {
return f.den
}
func (f *FractionType) ToFloat() float64 {
return float64(f.num) / float64(f.den) return float64(f.num) / float64(f.den)
} }
@ -168,7 +176,7 @@ func (f *FractionType) TypeName() string {
// -------- fraction utility functions // -------- fraction utility functions
// greatest common divider // greatest common divider
func gcd(a, b int64) (g int64) { func Gcd(a, b int64) (g int64) {
if a < 0 { if a < 0 {
a = -a a = -a
} }
@ -189,21 +197,21 @@ func gcd(a, b int64) (g int64) {
// lower common multiple // lower common multiple
func lcm(a, b int64) (l int64) { func lcm(a, b int64) (l int64) {
g := gcd(a, b) g := Gcd(a, b)
l = a * b / g l = a * b / g
return return
} }
// Sum two fractions // Sum two fractions
func sumFract(f1, f2 *FractionType) (sum *FractionType) { func SumFract(f1, f2 *FractionType) (sum *FractionType) {
m := lcm(f1.den, f2.den) m := lcm(f1.den, f2.den)
sum = newFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m) sum = NewFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
return return
} }
// Multiply two fractions // Multiply two fractions
func mulFract(f1, f2 *FractionType) (prod *FractionType) { func MulFract(f1, f2 *FractionType) (prod *FractionType) {
prod = newFraction(f1.num*f2.num, f1.den*f2.den) prod = NewFraction(f1.num*f2.num, f1.den*f2.den)
return return
} }
@ -230,12 +238,12 @@ func anyPairToFract(v1, v2 any) (f1, f2 *FractionType, err error) {
return return
} }
func sumAnyFract(af1, af2 any) (sum any, err error) { func SumAnyFract(af1, af2 any) (sum any, err error) {
var f1, f2 *FractionType var f1, f2 *FractionType
if f1, f2, err = anyPairToFract(af1, af2); err != nil { if f1, f2, err = anyPairToFract(af1, af2); err != nil {
return return
} }
f := sumFract(f1, f2) f := SumFract(f1, f2)
if f.num == 0 { if f.num == 0 {
sum = 0 sum = 0
} else { } else {
@ -250,7 +258,7 @@ func sumAnyFract(af1, af2 any) (sum any, err error) {
// =0 if af1 == af2 // =0 if af1 == af2
// >0 if af1 > af2 // >0 if af1 > af2
// err if af1 or af2 is not convertible to fraction // err if af1 or af2 is not convertible to fraction
func cmpAnyFract(af1, af2 any) (result int, err error) { func CmpAnyFract(af1, af2 any) (result int, err error) {
var f1, f2 *FractionType var f1, f2 *FractionType
if f1, f2, err = anyPairToFract(af1, af2); err != nil { if f1, f2, err = anyPairToFract(af1, af2); err != nil {
return return
@ -266,7 +274,7 @@ func cmpAnyFract(af1, af2 any) (result int, err error) {
// >0 if af1 > af2 // >0 if af1 > af2
func cmpFract(f1, f2 *FractionType) (result int) { func cmpFract(f1, f2 *FractionType) (result int) {
f2.num = -f2.num f2.num = -f2.num
f := sumFract(f1, f2) f := SumFract(f1, f2)
if f.num < 0 { if f.num < 0 {
result = -1 result = -1
} else if f.num > 0 { } else if f.num > 0 {
@ -277,13 +285,13 @@ func cmpFract(f1, f2 *FractionType) (result int) {
return return
} }
func subAnyFract(af1, af2 any) (sum any, err error) { func SubAnyFract(af1, af2 any) (sum any, err error) {
var f1, f2 *FractionType var f1, f2 *FractionType
if f1, f2, err = anyPairToFract(af1, af2); err != nil { if f1, f2, err = anyPairToFract(af1, af2); err != nil {
return return
} }
f2.num = -f2.num f2.num = -f2.num
f := sumFract(f1, f2) f := SumFract(f1, f2)
if f.num == 0 { if f.num == 0 {
sum = 0 sum = 0
} else { } else {
@ -292,7 +300,7 @@ func subAnyFract(af1, af2 any) (sum any, err error) {
return return
} }
func mulAnyFract(af1, af2 any) (prod any, err error) { func MulAnyFract(af1, af2 any) (prod any, err error) {
var f1, f2 *FractionType var f1, f2 *FractionType
if f1, f2, err = anyPairToFract(af1, af2); err != nil { if f1, f2, err = anyPairToFract(af1, af2); err != nil {
return return
@ -306,7 +314,7 @@ func mulAnyFract(af1, af2 any) (prod any, err error) {
return return
} }
func divAnyFract(af1, af2 any) (quot any, err error) { func DivAnyFract(af1, af2 any) (quot any, err error) {
var f1, f2 *FractionType var f1, f2 *FractionType
if f1, f2, err = anyPairToFract(af1, af2); err != nil { if f1, f2, err = anyPairToFract(af1, af2); err != nil {
return return
@ -345,7 +353,7 @@ func simplifyIntegers(num, den int64) (a, b int64) {
den = -den den = -den
num = -num num = -num
} }
g := gcd(num, den) g := Gcd(num, den)
a = num / g a = num / g
b = den / g b = den / g
return return
@ -355,7 +363,7 @@ func intToFraction(n int64) *FractionType {
return &FractionType{n, 1} return &FractionType{n, 1}
} }
func isFraction(v any) (ok bool) { func IsFraction(v any) (ok bool) {
_, ok = v.(*FractionType) _, ok = v.(*FractionType)
return ok return ok
} }

273
kern/function.go Normal file
View File

@ -0,0 +1,273 @@
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.
// function.go
package kern
import (
"fmt"
"strconv"
)
// ---- Function templates
type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
type DeepFuncTemplate func(a, b any) (eq bool, err error)
// ---- Common functor definition
type BaseFunctor struct {
info ExprFunc
}
func (functor *BaseFunctor) ToString(opt FmtOpt) (s string) {
if functor.info != nil {
s = functor.info.ToString(opt)
} else {
s = "func(){}"
}
return s
}
func (functor *BaseFunctor) GetParams() (params []ExprFuncParam) {
if functor.info != nil {
return functor.info.Params()
} else {
return []ExprFuncParam{}
}
}
func (functor *BaseFunctor) SetFunc(info ExprFunc) {
functor.info = info
}
func (functor *BaseFunctor) GetFunc() ExprFunc {
return functor.info
}
func (functor *BaseFunctor) GetDefinitionContext() ExprContext {
return nil
}
// ---- Function Parameters
type paramFlags uint16
const (
PfDefault paramFlags = 1 << iota
PfOptional
PfRepeat
)
type funcParamInfo struct {
name string
flags paramFlags
defaultValue any
}
func NewFuncParam(name string) ExprFuncParam {
return &funcParamInfo{name: name}
}
func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
return &funcParamInfo{name: name, flags: flags}
}
func NewFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
}
func (param *funcParamInfo) Name() string {
return param.name
}
func (param *funcParamInfo) Type() string {
return TypeAny
}
func (param *funcParamInfo) IsDefault() bool {
return (param.flags & PfDefault) != 0
}
func (param *funcParamInfo) IsOptional() bool {
return (param.flags & PfOptional) != 0
}
func (param *funcParamInfo) IsRepeat() bool {
return (param.flags & PfRepeat) != 0
}
func (param *funcParamInfo) DefaultValue() any {
return param.defaultValue
}
func initActualParams(ctx ExprContext, info ExprFunc, callTerm Term) (actualParams map[string]any, err error) {
var varArgs []any
var varName string
namedParamsStarted := false
formalParams := info.Params()
actualParams = make(map[string]any, len(formalParams))
if callTerm == nil {
return
}
childCount := callTerm.GetChildCount()
for i := range childCount {
tree := callTerm.GetChild(i)
// for i, tree := range callTerm.Children() {
var paramValue any
paramCtx := ctx.Clone()
if paramValue, err = tree.Compute(paramCtx); err != nil {
break
}
if paramName, namedParam := GetAssignVarName(tree); namedParam {
if info.ParamSpec(paramName) == nil {
err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
break
}
actualParams[paramName] = paramValue
namedParamsStarted = true
} else if !namedParamsStarted {
if varArgs != nil {
varArgs = append(varArgs, paramValue)
} else if i < len(formalParams) {
spec := formalParams[i]
if spec.IsRepeat() {
varArgs = make([]any, 0, childCount-i)
varArgs = append(varArgs, paramValue)
varName = spec.Name()
} else {
actualParams[spec.Name()] = paramValue
}
} else {
err = ErrTooManyParams(info.Name(), len(formalParams), childCount)
break
}
} else {
err = fmt.Errorf("%s(): positional param nr %d not allowed after named params", info.Name(), i+1)
break
}
}
if err == nil {
if varArgs != nil {
actualParams[varName] = varArgs
}
}
return
}
// 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)
// return
// }
// if passedCount < len(info.formalParams) {
// for _, p := range info.formalParams {
// if _, exists := actualParams[p.Name()]; !exists {
// if !p.IsDefault() {
// break
// }
// if p.IsRepeat() {
// varArgs := make([]any, 1)
// varArgs[0] = p.DefaultValue()
// actualParams[p.Name()] = varArgs
// } else {
// actualParams[p.Name()] = p.DefaultValue()
// }
// }
// }
// }
// if info.MaxArgs() >= 0 && info.MaxArgs() < len(actualParams) {
// err = 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.IsAssign(); ok {
name = t.GetChildSource(0)
}
return
}
func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm Term) (result any, err error) {
var actualParams map[string]any
if info, exists := parentCtx.GetFuncInfo(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 := parentCtx.GetFuncInfo(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 := parentCtx.GetFuncInfo(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 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
}

8
iterator.go → kern/iterator.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// iterator.go // iterator.go
package expr package kern
import ( import (
// "errors" // "errors"
@ -42,10 +42,6 @@ type ExtIterator interface {
Clean() error Clean() error
} }
func errNoOperation(name string) error { func ErrNoOperation(name string) error {
return fmt.Errorf("no %s() function defined in the data-source", name) return fmt.Errorf("no %s() function defined in the data-source", name)
} }
// func errInvalidDataSource() error {
// return errors.New("invalid data-source")
// }

46
list-type.go → kern/list-type.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// list-type.go // list-type.go
package expr package kern
import ( import (
"fmt" "fmt"
@ -12,23 +12,16 @@ import (
type ListType []any type ListType []any
func newListA(listAny ...any) (list *ListType) { func NewListA(listAny ...any) (list *ListType) {
if listAny == nil { if listAny == nil {
listAny = []any{} listAny = []any{}
} }
return newList(listAny)
}
func newList(listAny []any) (list *ListType) {
return NewList(listAny) return NewList(listAny)
} }
func NewList(listAny []any) (list *ListType) { func NewList(listAny []any) (list *ListType) {
if listAny != nil { if listAny != nil {
ls := make(ListType, len(listAny)) ls := make(ListType, len(listAny))
// for i, item := range listAny {
// ls[i] = item
// }
copy(ls, listAny) copy(ls, listAny)
list = &ls list = &ls
} }
@ -106,22 +99,11 @@ func (ls *ListType) TypeName() string {
return "list" return "list"
} }
// func (list *ListType) indexDeepCmp(target any) (index int) { func (ls *ListType) Contains(t *ListType) (answer bool) {
// index = -1
// for i, item := range *list {
// if reflect.DeepEqual(item, target) {
// index = i
// break
// }
// }
// return
// }
func (ls *ListType) contains(t *ListType) (answer bool) {
if len(*ls) >= len(*t) { if len(*ls) >= len(*t) {
answer = true answer = true
for _, item := range *t { for _, item := range *t {
if answer = ls.indexDeepSameCmp(item) >= 0; !answer { if answer = ls.IndexDeepSameCmp(item) >= 0; !answer {
break break
} }
} }
@ -143,12 +125,12 @@ func (ls1 *ListType) Equals(ls2 ListType) (answer bool) {
return return
} }
func (list *ListType) indexDeepSameCmp(target any) (index int) { func (list *ListType) IndexDeepSameCmp(target any) (index int) {
var eq bool var eq bool
var err error var err error
index = -1 index = -1
for i, item := range *list { for i, item := range *list {
if eq, err = deepSame(item, target, sameContent); err != nil { if eq, err = deepSame(item, target, SameContent); err != nil {
break break
} else if eq { } else if eq {
index = i index = i
@ -158,13 +140,13 @@ func (list *ListType) indexDeepSameCmp(target any) (index int) {
return return
} }
func sameContent(a, b any) (same bool, err error) { func SameContent(a, b any) (same bool, err error) {
la, _ := a.(*ListType) la, _ := a.(*ListType)
lb, _ := b.(*ListType) lb, _ := b.(*ListType)
if len(*la) == len(*lb) { if len(*la) == len(*lb) {
same = true same = true
for _, item := range *la { for _, item := range *la {
if pos := lb.indexDeepSameCmp(item); pos < 0 { if pos := lb.IndexDeepSameCmp(item); pos < 0 {
same = false same = false
break break
} }
@ -173,19 +155,19 @@ func sameContent(a, b any) (same bool, err error) {
return return
} }
func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) { func deepSame(a, b any, deepCmp DeepFuncTemplate) (eq bool, err error) {
if isNumOrFract(a) && isNumOrFract(b) { if IsNumOrFract(a) && IsNumOrFract(b) {
if IsNumber(a) && IsNumber(b) { if IsNumber(a) && IsNumber(b) {
if IsInteger(a) && IsInteger(b) { if IsInteger(a) && IsInteger(b) {
li, _ := a.(int64) li, _ := a.(int64)
ri, _ := b.(int64) ri, _ := b.(int64)
eq = li == ri eq = li == ri
} else { } else {
eq = numAsFloat(a) == numAsFloat(b) eq = NumAsFloat(a) == NumAsFloat(b)
} }
} else { } else {
var cmp int var cmp int
if cmp, err = cmpAnyFract(a, b); err == nil { if cmp, err = CmpAnyFract(a, b); err == nil {
eq = cmp == 0 eq = cmp == 0
} }
} }
@ -198,7 +180,7 @@ func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
return return
} }
func (list *ListType) setItem(index int64, value any) (err error) { func (list *ListType) SetItem(index int64, value any) (err error) {
if index >= 0 && index < int64(len(*list)) { if index >= 0 && index < int64(len(*list)) {
(*list)[index] = value (*list)[index] = value
} else { } else {
@ -207,6 +189,6 @@ func (list *ListType) setItem(index int64, value any) (err error) {
return return
} }
func (list *ListType) appendItem(value any) { func (list *ListType) AppendItem(value any) {
*list = append(*list, value) *list = append(*list, value)
} }

21
kern/term.go Normal file
View File

@ -0,0 +1,21 @@
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.
// term.go
package kern
import (
"fmt"
)
type Term interface {
fmt.Stringer
// Children() []Term
Source() string
GetChildCount() (count int)
GetChild(index int) Term
GetChildSource(index int) string
Compute(ctx ExprContext) (result any, err error)
IsAssign() bool
Errorf(template string, args ...any) (err error)
}

2
utils-unix.go → kern/utils-unix.go
View File

@ -4,7 +4,7 @@
// All rights reserved. // All rights reserved.
// utils-unix.go // utils-unix.go
package expr package kern
import ( import (
"os" "os"

2
utils-windows.go → kern/utils-windows.go
View File

@ -4,7 +4,7 @@
// All rights reserved. // All rights reserved.
// utils-unix.go // utils-unix.go
package expr package kern
import ( import (
"os" "os"

28
utils.go → kern/utils.go
View File

@ -2,7 +2,7 @@
// All rights reserved. // All rights reserved.
// utils.go // utils.go
package expr package kern
import ( import (
"fmt" "fmt"
@ -55,29 +55,29 @@ func IsNumber(v any) (ok bool) {
return IsFloat(v) || IsInteger(v) return IsFloat(v) || IsInteger(v)
} }
func isNumOrFract(v any) (ok bool) { func IsNumOrFract(v any) (ok bool) {
return IsFloat(v) || IsInteger(v) || isFraction(v) return IsFloat(v) || IsInteger(v) || IsFraction(v)
} }
func isNumberString(v any) (ok bool) { func IsNumberString(v any) (ok bool) {
return IsString(v) || IsNumber(v) return IsString(v) || IsNumber(v)
} }
func isFunctor(v any) (ok bool) { func IsFunctor(v any) (ok bool) {
_, ok = v.(Functor) _, ok = v.(Functor)
return return
} }
func isIterator(v any) (ok bool) { func IsIterator(v any) (ok bool) {
_, ok = v.(Iterator) _, ok = v.(Iterator)
return return
} }
func numAsFloat(v any) (f float64) { func NumAsFloat(v any) (f float64) {
var ok bool var ok bool
if f, ok = v.(float64); !ok { if f, ok = v.(float64); !ok {
if fract, ok := v.(*FractionType); ok { if fract, ok := v.(*FractionType); ok {
f = fract.toFloat() f = fract.ToFloat()
} else { } else {
i, _ := v.(int64) i, _ := v.(int64)
f = float64(i) f = float64(i)
@ -103,11 +103,11 @@ func ToBool(v any) (b bool, ok bool) {
return return
} }
func isFunc(v any) bool { func IsFunc(v any) bool {
return reflect.TypeOf(v).Kind() == reflect.Func return reflect.TypeOf(v).Kind() == reflect.Func
} }
func anyInteger(v any) (i int64, ok bool) { func AnyInteger(v any) (i int64, ok bool) {
ok = true ok = true
switch intval := v.(type) { switch intval := v.(type) {
case int: case int:
@ -134,7 +134,7 @@ func anyInteger(v any) (i int64, ok bool) {
return return
} }
func fromGenericAny(v any) (exprAny any, ok bool) { func FromGenericAny(v any) (exprAny any, ok bool) {
if v != nil { if v != nil {
if exprAny, ok = v.(bool); ok { if exprAny, ok = v.(bool); ok {
return return
@ -142,10 +142,10 @@ func fromGenericAny(v any) (exprAny any, ok bool) {
if exprAny, ok = v.(string); ok { if exprAny, ok = v.(string); ok {
return return
} }
if exprAny, ok = anyInteger(v); ok { if exprAny, ok = AnyInteger(v); ok {
return return
} }
if exprAny, ok = anyFloat(v); ok { if exprAny, ok = AnyFloat(v); ok {
return return
} }
if exprAny, ok = v.(*DictType); ok { if exprAny, ok = v.(*DictType); ok {
@ -158,7 +158,7 @@ func fromGenericAny(v any) (exprAny any, ok bool) {
return return
} }
func anyFloat(v any) (float float64, ok bool) { func AnyFloat(v any) (float float64, ok bool) {
ok = true ok = true
switch floatval := v.(type) { switch floatval := v.(type) {
case float32: case float32:

32
list-iterator.go
View File

@ -7,10 +7,13 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"slices"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type ListIterator struct { type ListIterator struct {
a *ListType a *kern.ListType
count int count int
index int index int
start int start int
@ -18,7 +21,7 @@ type ListIterator struct {
step int step int
} }
func NewListIterator(list *ListType, args []any) (it *ListIterator) { func NewListIterator(list *kern.ListType, args []any) (it *ListIterator) {
var argc int = 0 var argc int = 0
listLen := len(([]any)(*list)) listLen := len(([]any)(*list))
if args != nil { if args != nil {
@ -26,21 +29,21 @@ func NewListIterator(list *ListType, args []any) (it *ListIterator) {
} }
it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1} it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
if argc >= 1 { if argc >= 1 {
if i, err := ToGoInt(args[0], "start index"); err == nil { if i, err := kern.ToGoInt(args[0], "start index"); err == nil {
if i < 0 { if i < 0 {
i = listLen + i i = listLen + i
} }
it.start = i it.start = i
} }
if argc >= 2 { if argc >= 2 {
if i, err := ToGoInt(args[1], "stop index"); err == nil { if i, err := kern.ToGoInt(args[1], "stop index"); err == nil {
if i < 0 { if i < 0 {
i = listLen + i i = listLen + i
} }
it.stop = i it.stop = i
} }
if argc >= 3 { if argc >= 3 {
if i, err := ToGoInt(args[2], "step"); err == nil { if i, err := kern.ToGoInt(args[2], "step"); err == nil {
if i < 0 { if i < 0 {
i = -i i = -i
} }
@ -58,7 +61,7 @@ func NewListIterator(list *ListType, args []any) (it *ListIterator) {
} }
func NewArrayIterator(array []any) (it *ListIterator) { func NewArrayIterator(array []any) (it *ListIterator) {
it = &ListIterator{a: (*ListType)(&array), count: 0, index: -1, start: 0, stop: len(array) - 1, step: 1} it = &ListIterator{a: (*kern.ListType)(&array), count: 0, index: -1, start: 0, stop: len(array) - 1, step: 1}
return return
} }
@ -75,26 +78,27 @@ func (it *ListIterator) TypeName() string {
} }
func (it *ListIterator) HasOperation(name string) bool { func (it *ListIterator) HasOperation(name string) bool {
yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName //yes := name == expr.NextName || name == expr.ResetName || name == expr.IndexName || name == expr.CountName || name == expr.CurrentName
yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
return yes return yes
} }
func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) { func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
switch name { switch name {
case NextName: case kern.NextName:
v, err = it.Next() v, err = it.Next()
case ResetName: case kern.ResetName:
err = it.Reset() err = it.Reset()
case CleanName: case kern.CleanName:
err = it.Clean() err = it.Clean()
case IndexName: case kern.IndexName:
v = int64(it.Index()) v = int64(it.Index())
case CurrentName: case kern.CurrentName:
v, err = it.Current() v, err = it.Current()
case CountName: case kern.CountName:
v = it.count v = it.count
default: default:
err = errNoOperation(name) err = kern.ErrNoOperation(name)
} }
return return
} }

9
operand-dict.go
View File

@ -4,6 +4,9 @@
// operand-dict.go // operand-dict.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- dict term // -------- dict term
func newDictTerm(args map[any]*term) *term { func newDictTerm(args map[any]*term) *term {
@ -18,12 +21,12 @@ func newDictTerm(args map[any]*term) *term {
} }
// -------- dict func // -------- dict func
func evalDict(ctx ExprContext, opTerm *term) (v any, err error) { func evalDict(ctx kern.ExprContext, opTerm *term) (v any, err error) {
dict, _ := opTerm.value().(map[any]*term) dict, _ := opTerm.value().(map[any]*term)
items := make(DictType, len(dict)) items := make(kern.DictType, len(dict))
for key, tree := range dict { for key, tree := range dict {
var param any var param any
if param, err = tree.compute(ctx); err != nil { if param, err = tree.Compute(ctx); err != nil {
break break
} }
items[key] = param items[key] = param

14
operand-expr.go
View File

@ -4,11 +4,15 @@
// operand-expr.go // operand-expr.go
package expr package expr
import "fmt" import (
"fmt"
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- expr term // -------- expr term
func newExprTerm(root *term) *term { func newExprTerm(root *term) *term {
tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.source(), root) tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.Source(), root)
return &term{ return &term{
tk: *tk, tk: *tk,
parent: nil, parent: nil,
@ -20,9 +24,9 @@ func newExprTerm(root *term) *term {
} }
// -------- eval expr // -------- eval expr
func evalExpr(ctx ExprContext, opTerm *term) (v any, err error) { func evalExpr(ctx kern.ExprContext, opTerm *term) (v any, err error) {
if expr, ok := opTerm.value().(*term); ok { if ast, ok := opTerm.value().(*term); ok {
v, err = expr.compute(ctx) v, err = ast.Compute(ctx)
} else { } else {
err = fmt.Errorf("expression expected, got %T", opTerm.value()) err = fmt.Errorf("expression expected, got %T", opTerm.value())
} }

24
operand-func.go
View File

@ -6,15 +6,21 @@ package expr
import ( import (
"errors" "errors"
"git.portale-stac.it/go-pkg/expr/kern"
) )
// -------- function call term // -------- function call term
func newFuncCallTerm(tk *Token, args []*term) *term { func newFuncCallTerm(tk *Token, args []*term) *term {
var pos termPosition = posLeaf
if len(args) > 0 {
pos = posMultifix
}
return &term{ return &term{
tk: *tk, tk: *tk,
parent: nil, parent: nil,
children: args, children: args,
position: posLeaf, position: pos,
priority: priValue, priority: priValue,
evalFunc: evalFuncCall, evalFunc: evalFuncCall,
} }
@ -38,9 +44,9 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
// return // return
// } // }
func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) { func evalFuncCall(ctx kern.ExprContext, opTerm *term) (v any, err error) {
name, _ := opTerm.tk.Value.(string) name, _ := opTerm.tk.Value.(string)
v, err = CallFunctionByTerm(ctx, name, opTerm) v, err = kern.CallFunctionByTerm(ctx, name, opTerm)
return return
} }
@ -57,23 +63,23 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
} }
// -------- eval func def // -------- eval func def
func evalFuncDef(ctx ExprContext, opTerm *term) (v any, err error) { func evalFuncDef(ctx kern.ExprContext, opTerm *term) (v any, err error) {
bodySpec := opTerm.value() bodySpec := opTerm.value()
if expr, ok := bodySpec.(*ast); ok { if ast, ok := bodySpec.(*ast); ok {
paramList := make([]ExprFuncParam, 0, len(opTerm.children)) paramList := make([]kern.ExprFuncParam, 0, len(opTerm.children))
for _, param := range opTerm.children { for _, param := range opTerm.children {
var defValue any var defValue any
flags := paramFlags(0) flags := paramFlags(0)
if len(param.children) > 0 { if len(param.children) > 0 {
flags |= PfDefault flags |= PfDefault
if defValue, err = param.children[0].compute(ctx); err != nil { if defValue, err = param.children[0].Compute(ctx); err != nil {
return return
} }
} }
info := NewFuncParamFlagDef(param.source(), flags, defValue) info := NewFuncParamFlagDef(param.Source(), flags, defValue)
paramList = append(paramList, info) paramList = append(paramList, info)
} }
v = newExprFunctor(expr, paramList, ctx) v = newExprFunctor(ast, paramList, ctx)
} else { } else {
err = errors.New("invalid function definition: the body specification must be an expression") err = errors.New("invalid function definition: the body specification must be an expression")
} }

40
operand-iterator.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"slices" "slices"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
// -------- iterator term // -------- iterator term
@ -25,11 +27,11 @@ func newIteratorTerm(tk *Token, args []*term) *term {
// -------- eval iterator // -------- eval iterator
func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) { func evalTermArray(ctx kern.ExprContext, terms []*term) (values []any, err error) {
values = make([]any, len(terms)) values = make([]any, len(terms))
for i, t := range terms { for i, t := range terms {
var value any var value any
if value, err = t.compute(ctx); err == nil { if value, err = t.Compute(ctx); err == nil {
values[i] = value values[i] = value
} else { } else {
break break
@ -38,25 +40,25 @@ func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) {
return return
} }
func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error) { func evalFirstChild(ctx kern.ExprContext, iteratorTerm *term) (value any, err error) {
if len(iteratorTerm.children) < 1 || iteratorTerm.children[0] == nil { if len(iteratorTerm.children) < 1 || iteratorTerm.children[0] == nil {
err = iteratorTerm.Errorf("missing the data-source parameter") err = iteratorTerm.Errorf("missing the data-source parameter")
return return
} }
value, err = iteratorTerm.children[0].compute(ctx) value, err = iteratorTerm.children[0].Compute(ctx)
return return
} }
func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) { func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]kern.Functor, err error) {
if dictAny, ok := firstChildValue.(*DictType); ok { if dictAny, ok := firstChildValue.(*kern.DictType); ok {
requiredFields := []string{NextName} requiredFields := []string{kern.NextName}
fieldsMask := 0b1 fieldsMask := 0b1
foundFields := 0 foundFields := 0
ds = make(map[string]Functor) ds = make(map[string]kern.Functor)
for keyAny, item := range *dictAny { for keyAny, item := range *dictAny {
if key, ok := keyAny.(string); ok { if key, ok := keyAny.(string); ok {
if functor, ok := item.(Functor); ok { if functor, ok := item.(kern.Functor); ok {
ds[key] = functor ds[key] = functor
if index := slices.Index(requiredFields, key); index >= 0 { if index := slices.Index(requiredFields, key); index >= 0 {
foundFields |= 1 << index foundFields |= 1 << index
@ -78,9 +80,9 @@ func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]F
return return
} }
func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) { func evalIterator(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var firstChildValue any var firstChildValue any
var ds map[string]Functor var ds map[string]kern.Functor
if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil { if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil {
return return
@ -95,7 +97,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
if len(ds) > 0 { if len(ds) > 0 {
var dc *dataCursor var dc *dataCursor
dcCtx := ctx.Clone() dcCtx := ctx.Clone()
if initFunc, exists := ds[InitName]; exists && initFunc != nil { if initFunc, exists := ds[kern.InitName]; exists && initFunc != nil {
var args []any var args []any
var resource any var resource any
if len(opTerm.children) > 1 { if len(opTerm.children) > 1 {
@ -106,13 +108,13 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
args = []any{} args = []any{}
} }
actualParams := bindActualParams(initFunc, args) actualParams := kern.BindActualParams(initFunc, args)
initCtx := ctx.Clone() initCtx := ctx.Clone()
if resource, err = initFunc.InvokeNamed(initCtx, InitName, actualParams); err != nil { if resource, err = initFunc.InvokeNamed(initCtx, kern.InitName, actualParams); err != nil {
return return
} }
exportObjects(dcCtx, initCtx) kern.ExportObjects(dcCtx, initCtx)
dc = NewDataCursor(dcCtx, ds, resource) dc = NewDataCursor(dcCtx, ds, resource)
} else { } else {
dc = NewDataCursor(dcCtx, ds, nil) dc = NewDataCursor(dcCtx, ds, nil)
@ -120,7 +122,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
v = dc v = dc
} else { } else {
if dictIt, ok := firstChildValue.(*DictType); ok { if dictIt, ok := firstChildValue.(*kern.DictType); ok {
var args []any var args []any
if args, err = evalSibling(ctx, opTerm.children, nil); err == nil { if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
v, err = NewDictIterator(dictIt, args) v, err = NewDictIterator(dictIt, args)
@ -129,7 +131,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
err = opTerm.children[0].Errorf("the data-source must be a dictionary") err = opTerm.children[0].Errorf("the data-source must be a dictionary")
} }
} }
} else if list, ok := firstChildValue.(*ListType); ok { } else if list, ok := firstChildValue.(*kern.ListType); ok {
var args []any var args []any
if args, err = evalSibling(ctx, opTerm.children, nil); err == nil { if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
v = NewListIterator(list, args) v = NewListIterator(list, args)
@ -143,7 +145,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []any, err error) { func evalSibling(ctx kern.ExprContext, terms []*term, firstChildValue any) (list []any, err error) {
items := make([]any, 0, len(terms)) items := make([]any, 0, len(terms))
for i, tree := range terms { for i, tree := range terms {
var param any var param any
@ -152,7 +154,7 @@ func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []an
continue continue
} }
param = firstChildValue param = firstChildValue
} else if param, err = tree.compute(ctx); err != nil { } else if param, err = tree.Compute(ctx); err != nil {
break break
} }
items = append(items, param) items = append(items, param)

10
operand-list.go
View File

@ -4,6 +4,10 @@
// operand-list.go // operand-list.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- list term // -------- list term
func newListTermA(args ...*term) *term { func newListTermA(args ...*term) *term {
return newListTerm(0, 0, args) return newListTerm(0, 0, args)
@ -21,12 +25,12 @@ func newListTerm(row, col int, args []*term) *term {
} }
// -------- list func // -------- list func
func evalList(ctx ExprContext, opTerm *term) (v any, err error) { func evalList(ctx kern.ExprContext, opTerm *term) (v any, err error) {
list, _ := opTerm.value().([]*term) list, _ := opTerm.value().([]*term)
items := make(ListType, len(list)) items := make(kern.ListType, len(list))
for i, tree := range list { for i, tree := range list {
var param any var param any
if param, err = tree.compute(ctx); err != nil { if param, err = tree.Compute(ctx); err != nil {
break break
} }
items[i] = param items[i] = param

6
operand-literal.go
View File

@ -4,6 +4,10 @@
// operand-literal.go // operand-literal.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- literal term // -------- literal term
func newLiteralTerm(tk *Token) *term { func newLiteralTerm(tk *Token) *term {
return &term{ return &term{
@ -17,7 +21,7 @@ func newLiteralTerm(tk *Token) *term {
} }
// -------- eval func // -------- eval func
func evalLiteral(ctx ExprContext, opTerm *term) (v any, err error) { func evalLiteral(ctx kern.ExprContext, opTerm *term) (v any, err error) {
v = opTerm.tk.Value v = opTerm.tk.Value
return return
} }

4
operand-selector-case.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
// -------- selector case term // -------- selector case term
@ -41,7 +43,7 @@ func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
} }
// -------- eval selector case // -------- eval selector case
func evalSelectorCase(ctx ExprContext, opTerm *term) (v any, err error) { func evalSelectorCase(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var ok bool var ok bool
if v, ok = opTerm.value().(*selectorCase); !ok { if v, ok = opTerm.value().(*selectorCase); !ok {
err = fmt.Errorf("selector-case expected, got %T", opTerm.value()) err = fmt.Errorf("selector-case expected, got %T", opTerm.value())

14
operand-var.go
View File

@ -4,7 +4,11 @@
// operand-var.go // operand-var.go
package expr package expr
import "fmt" import (
"fmt"
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- variable term // -------- variable term
func newVarTerm(tk *Token) *term { func newVarTerm(tk *Token) *term {
@ -21,11 +25,11 @@ func newVarTerm(tk *Token) *term {
} }
// -------- eval func // -------- eval func
func evalVar(ctx ExprContext, opTerm *term) (v any, err error) { func evalVar(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var exists bool var exists bool
name := opTerm.source() name := opTerm.Source()
if v, exists = GetVar(ctx, name); !exists { if v, exists = ctx.GetVar(name); !exists {
if info, exists := GetFuncInfo(ctx, name); exists { if info, exists := ctx.GetFuncInfo(name); exists {
v = info.Functor() v = info.Functor()
} else { } else {
err = fmt.Errorf("undefined variable or function %q", name) err = fmt.Errorf("undefined variable or function %q", name)

72
operator-assign.go
View File

@ -4,6 +4,10 @@
// operator-assign.go // operator-assign.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- assign term //-------- assign term
func newAssignTerm(tk *Token) (inst *term) { func newAssignTerm(tk *Token) (inst *term) {
@ -16,19 +20,19 @@ func newAssignTerm(tk *Token) (inst *term) {
} }
} }
func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) { func assignCollectionItem(ctx kern.ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
var collectionValue, keyListValue, keyValue any var collectionValue, keyListValue, keyValue any
var keyList *ListType var keyList *kern.ListType
var ok bool var ok bool
if collectionValue, err = collectionTerm.compute(ctx); err != nil { if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
return return
} }
if keyListValue, err = keyListTerm.compute(ctx); err != nil { if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
return return
} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 { } else if keyList, ok = keyListValue.(*kern.ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue)) err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, kern.TypeName(keyListValue))
return return
} }
if keyValue = (*keyList)[0]; keyValue == nil { if keyValue = (*keyList)[0]; keyValue == nil {
@ -37,30 +41,30 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
} }
switch collection := collectionValue.(type) { switch collection := collectionValue.(type) {
case *ListType: case *kern.ListType:
if index, ok := keyValue.(int64); ok { if index, ok := keyValue.(int64); ok {
err = collection.setItem(index, value) err = collection.SetItem(index, value)
} else { } else {
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue)) err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, kern.TypeName(keyValue))
} }
case *DictType: case *kern.DictType:
err = collection.setItem(keyValue, value) err = collection.SetItem(keyValue, value)
default: default:
err = collectionTerm.Errorf("collection expected") err = collectionTerm.Errorf("collection expected")
} }
return return
} }
func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) { func assignValue(ctx kern.ExprContext, leftTerm *term, v any) (err error) {
if leftTerm.symbol() == SymIndex { if leftTerm.symbol() == SymIndex {
err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v) err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v)
} else { } else {
ctx.UnsafeSetVar(leftTerm.source(), v) ctx.UnsafeSetVar(leftTerm.Source(), v)
} }
return return
} }
func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) { func evalAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
@ -74,17 +78,17 @@ func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
rightChild := opTerm.children[1] rightChild := opTerm.children[1]
if v, err = rightChild.compute(ctx); err == nil { if v, err = rightChild.Compute(ctx); err == nil {
if functor, ok := v.(Functor); ok { if functor, ok := v.(kern.Functor); ok {
if leftSym == SymVariable { if leftSym == SymVariable {
if info := functor.GetFunc(); info != nil { if info := functor.GetFunc(); info != nil {
ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params()) ctx.RegisterFunc(leftTerm.Source(), info.Functor(), info.ReturnType(), info.Params())
} else if funcDef, ok := functor.(*exprFunctor); ok { } else if funcDef, ok := functor.(*exprFunctor); ok {
paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p }) paramSpecs := kern.ForAll(funcDef.params, func(p kern.ExprFuncParam) kern.ExprFuncParam { return p })
ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs) ctx.RegisterFunc(leftTerm.Source(), functor, kern.TypeAny, paramSpecs)
} else { } else {
err = opTerm.Errorf("unknown function %s()", rightChild.source()) err = opTerm.Errorf("unknown function %s()", rightChild.Source())
} }
} else { } else {
err = assignValue(ctx, leftTerm, v) err = assignValue(ctx, leftTerm, v)
@ -111,19 +115,19 @@ func newOpAssignTerm(tk *Token) (inst *term) {
} }
} }
func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term) (value any, err error) { func getCollectionItemValue(ctx kern.ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
var collectionValue, keyListValue, keyValue any var collectionValue, keyListValue, keyValue any
var keyList *ListType var keyList *kern.ListType
var ok bool var ok bool
if collectionValue, err = collectionTerm.compute(ctx); err != nil { if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
return return
} }
if keyListValue, err = keyListTerm.compute(ctx); err != nil { if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
return return
} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 { } else if keyList, ok = keyListValue.(*kern.ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue)) err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, kern.TypeName(keyListValue))
return return
} }
if keyValue = (*keyList)[0]; keyValue == nil { if keyValue = (*keyList)[0]; keyValue == nil {
@ -132,13 +136,13 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
} }
switch collection := collectionValue.(type) { switch collection := collectionValue.(type) {
case *ListType: case *kern.ListType:
if index, ok := keyValue.(int64); ok { if index, ok := keyValue.(int64); ok {
value = (*collection)[index] value = (*collection)[index]
} else { } else {
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue)) err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, kern.TypeName(keyValue))
} }
case *DictType: case *kern.DictType:
value = (*collection)[keyValue] value = (*collection)[keyValue]
default: default:
err = collectionTerm.Errorf("collection expected") err = collectionTerm.Errorf("collection expected")
@ -146,16 +150,16 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
return return
} }
func getAssignValue(ctx ExprContext, leftTerm *term) (value any, err error) { func getAssignValue(ctx kern.ExprContext, leftTerm *term) (value any, err error) {
if leftTerm.symbol() == SymIndex { if leftTerm.symbol() == SymIndex {
value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1]) value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1])
} else { } else {
value, _ = ctx.GetVar(leftTerm.source()) value, _ = ctx.GetVar(leftTerm.Source())
} }
return return
} }
func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) { func evalOpAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue, leftValue any var rightValue, leftValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
@ -170,7 +174,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
rightChild := opTerm.children[1] rightChild := opTerm.children[1]
if rightValue, err = rightChild.compute(ctx); err == nil { if rightValue, err = rightChild.Compute(ctx); err == nil {
if leftValue, err = getAssignValue(ctx, leftTerm); err == nil { if leftValue, err = getAssignValue(ctx, leftTerm); err == nil {
switch opTerm.symbol() { switch opTerm.symbol() {
case SymPlusEqual: case SymPlusEqual:
@ -194,7 +198,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
case SymDoubleGreaterEqual: case SymDoubleGreaterEqual:
v, err = bitRightShift(opTerm, leftValue, rightValue) v, err = bitRightShift(opTerm, leftValue, rightValue)
default: default:
err = opTerm.Errorf("unsupported assign operator %q", opTerm.source()) err = opTerm.Errorf("unsupported assign operator %q", opTerm.Source())
} }
if err == nil { if err == nil {
err = assignValue(ctx, leftTerm, v) err = assignValue(ctx, leftTerm, v)

16
operator-bitwise.go
View File

@ -4,6 +4,10 @@
// operator-bitwise.go // operator-bitwise.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- Bitwise NOT term //-------- Bitwise NOT term
func newBitwiseNotTerm(tk *Token) (inst *term) { func newBitwiseNotTerm(tk *Token) (inst *term) {
@ -16,18 +20,18 @@ func newBitwiseNotTerm(tk *Token) (inst *term) {
} }
} }
func evalBitwiseNot(ctx ExprContext, opTerm *term) (v any, err error) { func evalBitwiseNot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var value any var value any
if value, err = opTerm.evalPrefix(ctx); err != nil { if value, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsInteger(value) { if kern.IsInteger(value) {
i, _ := value.(int64) i, _ := value.(int64)
v = ^i v = ^i
} else { } else {
err = opTerm.errIncompatibleType(value) err = opTerm.errIncompatiblePrefixPostfixType(value)
} }
return return
} }
@ -59,7 +63,7 @@ func bitwiseAnd(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalBitwiseAnd(ctx ExprContext, opTerm *term) (v any, err error) { func evalBitwiseAnd(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -96,7 +100,7 @@ func bitwiseOr(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalBitwiseOr(ctx ExprContext, opTerm *term) (v any, err error) { func evalBitwiseOr(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -134,7 +138,7 @@ func bitwiseXor(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalBitwiseXor(ctx ExprContext, opTerm *term) (v any, err error) { func evalBitwiseXor(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

59
operator-bool.go
View File

@ -4,7 +4,11 @@
// operator-bool.go // operator-bool.go
package expr package expr
import "fmt" import (
"fmt"
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- NOT term //-------- NOT term
@ -18,17 +22,17 @@ func newNotTerm(tk *Token) (inst *term) {
} }
} }
func evalNot(ctx ExprContext, opTerm *term) (v any, err error) { func evalNot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue any var rightValue any
if rightValue, err = opTerm.evalPrefix(ctx); err != nil { if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if b, ok := ToBool(rightValue); ok { if b, ok := kern.ToBool(rightValue); ok {
v = !b v = !b
} else { } else {
err = opTerm.errIncompatibleType(rightValue) err = opTerm.errIncompatiblePrefixPostfixType(rightValue)
} }
return return
} }
@ -45,8 +49,8 @@ func newAndTerm(tk *Token) (inst *term) {
} }
} }
func evalAnd(ctx ExprContext, self *term) (v any, err error) { func evalAnd(ctx kern.ExprContext, self *term) (v any, err error) {
if CtrlIsEnabled(ctx, ControlBoolShortcut) { if kern.CtrlIsEnabled(ctx, kern.ControlBoolShortcut) {
v, err = evalAndWithShortcut(ctx, self) v, err = evalAndWithShortcut(ctx, self)
} else { } else {
v, err = evalAndWithoutShortcut(ctx, self) v, err = evalAndWithoutShortcut(ctx, self)
@ -54,7 +58,7 @@ func evalAnd(ctx ExprContext, self *term) (v any, err error) {
return return
} }
func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) { func evalAndWithoutShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var leftBool, rightBool bool var leftBool, rightBool bool
var lok, rok bool var lok, rok bool
@ -63,8 +67,8 @@ func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
return return
} }
leftBool, lok = ToBool(leftValue) leftBool, lok = kern.ToBool(leftValue)
rightBool, rok = ToBool(rightValue) rightBool, rok = kern.ToBool(rightValue)
if lok && rok { if lok && rok {
v = leftBool && rightBool v = leftBool && rightBool
@ -74,24 +78,25 @@ func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
return return
} }
func evalAndWithShortcut(ctx ExprContext, self *term) (v any, err error) { func evalAndWithShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if err = self.checkOperands(); err != nil { if err = self.checkOperands(); err != nil {
return return
} }
if leftValue, err = self.children[0].compute(ctx); err != nil { if leftValue, err = self.children[0].Compute(ctx); err != nil {
return return
} }
if leftBool, lok := ToBool(leftValue); !lok { if leftBool, lok := kern.ToBool(leftValue); !lok {
err = fmt.Errorf("got %s as left operand type of 'AND' operator, it must be bool", TypeName(leftValue)) // err = fmt.Errorf("got %s as left operand type of 'AND' operator, it must be bool", expr.TypeName(leftValue))
return // return
err = self.errIncompatibleType(leftValue, "left")
} else if !leftBool { } else if !leftBool {
v = false v = false
} else if rightValue, err = self.children[1].compute(ctx); err == nil { } else if rightValue, err = self.children[1].Compute(ctx); err == nil {
if rightBool, rok := ToBool(rightValue); rok { if rightBool, rok := kern.ToBool(rightValue); rok {
v = rightBool v = rightBool
} else { } else {
err = self.errIncompatibleTypes(leftValue, rightValue) err = self.errIncompatibleTypes(leftValue, rightValue)
@ -112,8 +117,8 @@ func newOrTerm(tk *Token) (inst *term) {
} }
} }
func evalOr(ctx ExprContext, self *term) (v any, err error) { func evalOr(ctx kern.ExprContext, self *term) (v any, err error) {
if CtrlIsEnabled(ctx, ControlBoolShortcut) { if kern.CtrlIsEnabled(ctx, kern.ControlBoolShortcut) {
v, err = evalOrWithShortcut(ctx, self) v, err = evalOrWithShortcut(ctx, self)
} else { } else {
v, err = evalOrWithoutShortcut(ctx, self) v, err = evalOrWithoutShortcut(ctx, self)
@ -121,7 +126,7 @@ func evalOr(ctx ExprContext, self *term) (v any, err error) {
return return
} }
func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) { func evalOrWithoutShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var leftBool, rightBool bool var leftBool, rightBool bool
var lok, rok bool var lok, rok bool
@ -130,8 +135,8 @@ func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
return return
} }
leftBool, lok = ToBool(leftValue) leftBool, lok = kern.ToBool(leftValue)
rightBool, rok = ToBool(rightValue) rightBool, rok = kern.ToBool(rightValue)
if lok && rok { if lok && rok {
v = leftBool || rightBool v = leftBool || rightBool
@ -141,24 +146,24 @@ func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
return return
} }
func evalOrWithShortcut(ctx ExprContext, self *term) (v any, err error) { func evalOrWithShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if err = self.checkOperands(); err != nil { if err = self.checkOperands(); err != nil {
return return
} }
if leftValue, err = self.children[0].compute(ctx); err != nil { if leftValue, err = self.children[0].Compute(ctx); err != nil {
return return
} }
if leftBool, lok := ToBool(leftValue); !lok { if leftBool, lok := kern.ToBool(leftValue); !lok {
err = fmt.Errorf("got %s as left operand type of 'OR' operator, it must be bool", TypeName(leftValue)) err = fmt.Errorf("got %s as left operand type of 'OR' operator, it must be bool", kern.TypeName(leftValue))
return return
} else if leftBool { } else if leftBool {
v = true v = true
} else if rightValue, err = self.children[1].compute(ctx); err == nil { } else if rightValue, err = self.children[1].Compute(ctx); err == nil {
if rightBool, rok := ToBool(rightValue); rok { if rightBool, rok := kern.ToBool(rightValue); rok {
v = rightBool v = rightBool
} else { } else {
err = self.errIncompatibleTypes(leftValue, rightValue) err = self.errIncompatibleTypes(leftValue, rightValue)

18
operator-builtin.go
View File

@ -4,7 +4,11 @@
// operator-builtin.go // operator-builtin.go
package expr package expr
import "io" import (
"io"
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- builtin term //-------- builtin term
@ -18,7 +22,7 @@ func newBuiltinTerm(tk *Token) (inst *term) {
} }
} }
func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) { func evalBuiltin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
@ -26,25 +30,25 @@ func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
} }
count := 0 count := 0
if IsString(childValue) { if kern.IsString(childValue) {
module, _ := childValue.(string) module, _ := childValue.(string)
count, err = ImportInContextByGlobPattern(module) count, err = ImportInContextByGlobPattern(ctx, module)
} else { } else {
var moduleSpec any var moduleSpec any
var it Iterator var it kern.Iterator
if it, err = NewIterator(childValue); err != nil { if it, err = NewIterator(childValue); err != nil {
return return
} }
for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() { for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
if module, ok := moduleSpec.(string); ok { if module, ok := moduleSpec.(string); ok {
if ImportInContext(module) { if ImportInContext(ctx, module) {
count++ count++
} else { } else {
err = opTerm.Errorf("unknown builtin module %q", module) err = opTerm.Errorf("unknown builtin module %q", module)
break break
} }
} else { } else {
err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec)) err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, kern.TypeName(moduleSpec))
break break
} }
} }

6
operator-but.go
View File

@ -4,6 +4,10 @@
// operator-but.go // operator-but.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- but term //-------- but term
func newButTerm(tk *Token) (inst *term) { func newButTerm(tk *Token) (inst *term) {
@ -16,7 +20,7 @@ func newButTerm(tk *Token) (inst *term) {
} }
} }
func evalBut(ctx ExprContext, opTerm *term) (v any, err error) { func evalBut(ctx kern.ExprContext, opTerm *term) (v any, err error) {
_, v, err = opTerm.evalInfix(ctx) _, v, err = opTerm.evalInfix(ctx)
return return
} }

18
operator-context.go
View File

@ -4,6 +4,10 @@
// operator-context-value.go // operator-context-value.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- context term //-------- context term
func newContextTerm(tk *Token) (inst *term) { func newContextTerm(tk *Token) (inst *term) {
@ -16,14 +20,14 @@ func newContextTerm(tk *Token) (inst *term) {
} }
} }
func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) { func evalContextValue(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
var sourceCtx ExprContext var sourceCtx kern.ExprContext
if len(opTerm.children) == 0 { if len(opTerm.children) == 0 {
sourceCtx = ctx sourceCtx = ctx
} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" { } else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].Source() == "global" {
sourceCtx = globalCtx sourceCtx = ctx.GetGlobal()
} else if childValue, err = opTerm.evalPrefix(ctx); err == nil { } else if childValue, err = opTerm.evalPrefix(ctx); err == nil {
if dc, ok := childValue.(*dataCursor); ok { if dc, ok := childValue.(*dataCursor); ok {
sourceCtx = dc.ctx sourceCtx = dc.ctx
@ -31,9 +35,9 @@ func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
} }
if sourceCtx != nil { if sourceCtx != nil {
if formatter, ok := sourceCtx.(DictFormat); ok { if formatter, ok := sourceCtx.(kern.DictFormat); ok {
v = formatter.ToDict() v = formatter.ToDict()
} else if formatter, ok := sourceCtx.(Formatter); ok { } else if formatter, ok := sourceCtx.(kern.Formatter); ok {
v = formatter.ToString(0) v = formatter.ToString(0)
} else { } else {
// keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' }) // keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
@ -49,7 +53,7 @@ func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
v = d v = d
} }
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }

8
operator-ctrl.go
View File

@ -4,6 +4,10 @@
// operator-ctrl.go // operator-ctrl.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- export all term //-------- export all term
func newExportAllTerm(tk *Token) (inst *term) { func newExportAllTerm(tk *Token) (inst *term) {
@ -16,8 +20,8 @@ func newExportAllTerm(tk *Token) (inst *term) {
} }
} }
func evalExportAll(ctx ExprContext, opTerm *term) (v any, err error) { func evalExportAll(ctx kern.ExprContext, opTerm *term) (v any, err error) {
CtrlEnable(ctx, control_export_all) CtrlEnable(ctx, kern.ControlExportAll)
return return
} }

36
operator-default.go
View File

@ -4,6 +4,10 @@
// operator-default.go // operator-default.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- default term //-------- default term
func newDefaultTerm(tk *Token) (inst *term) { func newDefaultTerm(tk *Token) (inst *term) {
@ -16,7 +20,7 @@ func newDefaultTerm(tk *Token) (inst *term) {
} }
} }
func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) { func evalDefault(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue any var rightValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
@ -26,13 +30,13 @@ func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) {
leftTerm := opTerm.children[0] leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable { if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source) // err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm) err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return return
} }
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists { if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists {
v = leftValue v = leftValue
} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil { } else if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
v = rightValue v = rightValue
} }
return return
@ -50,7 +54,7 @@ func newAlternateTerm(tk *Token) (inst *term) {
} }
} }
func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) { func evalAlternate(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue any var rightValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
@ -60,12 +64,12 @@ func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) {
leftTerm := opTerm.children[0] leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable { if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source) // err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm) err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return return
} }
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists && leftValue != nil { if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists && leftValue != nil {
if rightValue, err = opTerm.children[1].compute(ctx); err == nil { if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
v = rightValue v = rightValue
} }
} else { } else {
@ -86,7 +90,7 @@ func newDefaultAssignTerm(tk *Token) (inst *term) {
} }
} }
func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) { func evalAssignDefault(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue any var rightValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
@ -96,21 +100,21 @@ func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) {
leftTerm := opTerm.children[0] leftTerm := opTerm.children[0]
if leftTerm.tk.Sym != SymVariable { if leftTerm.tk.Sym != SymVariable {
// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source) // err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
err = ErrLeftOperandMustBeVariable(leftTerm, opTerm) err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
return return
} }
if leftValue, exists := ctx.GetVar(leftTerm.source()); exists { if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists {
v = leftValue v = leftValue
} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil { } else if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
if functor, ok := rightValue.(Functor); ok { if functor, ok := rightValue.(kern.Functor); ok {
//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1) //ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{ ctx.RegisterFunc(leftTerm.Source(), functor, kern.TypeAny, []kern.ExprFuncParam{
NewFuncParamFlag(ParamValue, PfDefault|PfRepeat), NewFuncParamFlag(kern.ParamValue, PfDefault|PfRepeat),
}) })
} else { } else {
v = rightValue v = rightValue
ctx.UnsafeSetVar(leftTerm.source(), rightValue) ctx.UnsafeSetVar(leftTerm.Source(), rightValue)
} }
} }
return return

12
operator-digest.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- digest term //-------- digest term
@ -21,21 +23,21 @@ func newDigestTerm(tk *Token) (inst *term) {
} }
} }
func evalDigest(ctx ExprContext, opTerm *term) (v any, err error) { func evalDigest(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var it Iterator var it kern.Iterator
var item, lastValue any var item, lastValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
if it, err = NewIterator(leftValue); err != nil { if it, err = NewIterator(leftValue); err != nil {
return nil, fmt.Errorf("left operand of DIGEST must be an iterable data-source; got %s", TypeName(leftValue)) return nil, fmt.Errorf("left operand of DIGEST must be an iterable data-source; got %s", kern.TypeName(leftValue))
} }
lastValue = nil lastValue = nil
@ -43,7 +45,7 @@ func evalDigest(ctx ExprContext, opTerm *term) (v any, err error) {
ctx.SetVar("_", item) ctx.SetVar("_", item)
ctx.SetVar("_index", it.Index()) ctx.SetVar("_index", it.Index())
ctx.SetVar("_count", it.Count()) ctx.SetVar("_count", it.Count())
if rightValue, err = opTerm.children[1].compute(ctx); err == nil { if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
if rightValue == nil { if rightValue == nil {
break break
} else { } else {

14
operator-dot.go
View File

@ -4,6 +4,10 @@
// operator-dot.go // operator-dot.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- dot term // -------- dot term
func newDotTerm(tk *Token) (inst *term) { func newDotTerm(tk *Token) (inst *term) {
return &term{ return &term{
@ -15,22 +19,22 @@ func newDotTerm(tk *Token) (inst *term) {
} }
} }
func evalDot(ctx ExprContext, opTerm *term) (v any, err error) { func evalDot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
indexTerm := opTerm.children[1] indexTerm := opTerm.children[1]
switch unboxedValue := leftValue.(type) { switch unboxedValue := leftValue.(type) {
case ExtIterator: case kern.ExtIterator:
if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ { if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ {
opName := indexTerm.source() opName := indexTerm.Source()
if unboxedValue.HasOperation(opName) { if unboxedValue.HasOperation(opName) {
v, err = unboxedValue.CallOperation(opName, map[string]any{}) v, err = unboxedValue.CallOperation(opName, map[string]any{})
} else { } else {
@ -41,7 +45,7 @@ func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
err = indexTerm.tk.ErrorExpectedGot("identifier") err = indexTerm.tk.ErrorExpectedGot("identifier")
} }
default: default:
if rightValue, err = opTerm.children[1].compute(ctx); err == nil { if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
} }
} }

12
operator-fact.go
View File

@ -4,7 +4,11 @@
// operator-fact.go // operator-fact.go
package expr package expr
import "fmt" import (
"fmt"
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- fact term //-------- fact term
@ -18,14 +22,14 @@ func newFactTerm(tk *Token) (inst *term) {
} }
} }
func evalFact(ctx ExprContext, opTerm *term) (v any, err error) { func evalFact(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue any var leftValue any
if leftValue, err = opTerm.evalPrefix(ctx); err != nil { if leftValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsInteger(leftValue) { if kern.IsInteger(leftValue) {
if i, _ := leftValue.(int64); i >= 0 { if i, _ := leftValue.(int64); i >= 0 {
f := int64(1) f := int64(1)
for k := int64(1); k <= i; k++ { for k := int64(1); k <= i; k++ {
@ -36,7 +40,7 @@ func evalFact(ctx ExprContext, opTerm *term) (v any, err error) {
err = fmt.Errorf("factorial of a negative integer (%d) is not allowed", i) err = fmt.Errorf("factorial of a negative integer (%d) is not allowed", i)
} }
} else { } else {
err = opTerm.errIncompatibleType(leftValue) err = opTerm.errIncompatiblePrefixPostfixType(leftValue)
} }
return return
} }

18
operator-filter.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- map term //-------- map term
@ -21,32 +23,32 @@ func newFilterTerm(tk *Token) (inst *term) {
} }
} }
func evalFilter(ctx ExprContext, opTerm *term) (v any, err error) { func evalFilter(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var it Iterator var it kern.Iterator
var item any var item any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
if it, err = NewIterator(leftValue); err != nil { if it, err = NewIterator(leftValue); err != nil {
return nil, fmt.Errorf("left operand of FILTER must be an iterable data-source; got %s", TypeName(leftValue)) return nil, fmt.Errorf("left operand of FILTER must be an iterable data-source; got %s", kern.TypeName(leftValue))
} }
values := newListA() values := kern.NewListA()
for item, err = it.Next(); err == nil; item, err = it.Next() { for item, err = it.Next(); err == nil; item, err = it.Next() {
ctx.SetVar("_", item) ctx.SetVar("_", item)
ctx.SetVar("_index", it.Index()) ctx.SetVar("_index", it.Index())
ctx.SetVar("_count", it.Count()) ctx.SetVar("_count", it.Count())
if rightValue, err = opTerm.children[1].compute(ctx); err == nil { if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
if success, valid := ToBool(rightValue); valid { if success, valid := kern.ToBool(rightValue); valid {
if success { if success {
values.appendItem(item) values.AppendItem(item)
} }
} else { } else {
err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue) err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue)

13
operator-fraction.go
View File

@ -8,6 +8,8 @@ package expr
import ( import (
"fmt" "fmt"
"git.portale-stac.it/go-pkg/expr/kern"
) )
// -------- fraction term // -------- fraction term
@ -23,7 +25,7 @@ func newFractionTerm(tk *Token) *term {
} }
// -------- eval func // -------- eval func
func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) { func evalFraction(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var numValue, denValue any var numValue, denValue any
var num, den int64 var num, den int64
var ok bool var ok bool
@ -49,16 +51,19 @@ func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
num = -num num = -num
} }
if num != 0 { if num != 0 {
g := gcd(num, den) if g := kern.Gcd(num, den); g != 1 {
num = num / g num = num / g
den = den / g den = den / g
}
if den == 1 { if den == 1 {
v = num v = num
} else { } else {
v = &FractionType{num, den} // v = &expr.FractionType{num, den}
v = kern.NewFraction(num, den)
} }
} else { } else {
v = &FractionType{0, den} // v = &FractionType{0, den}
v = kern.NewFraction(0, den)
} }
return return
} }

18
operator-in.go
View File

@ -4,6 +4,10 @@
// operator-in.go // operator-in.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- in term //-------- in term
func newInTerm(tk *Token) (inst *term) { func newInTerm(tk *Token) (inst *term) {
@ -21,19 +25,19 @@ func newInTerm(tk *Token) (inst *term) {
// return // return
// } // }
func evalIn(ctx ExprContext, opTerm *term) (v any, err error) { func evalIn(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return return
} }
if IsList(rightValue) { if kern.IsList(rightValue) {
list, _ := rightValue.(*ListType) list, _ := rightValue.(*kern.ListType)
v = list.indexDeepSameCmp(leftValue) >= 0 v = list.IndexDeepSameCmp(leftValue) >= 0
} else if IsDict(rightValue) { } else if kern.IsDict(rightValue) {
dict, _ := rightValue.(*DictType) dict, _ := rightValue.(*kern.DictType)
v = dict.hasKey(leftValue) v = dict.HasKey(leftValue)
} else { } else {
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
} }

14
operator-include.go
View File

@ -4,6 +4,10 @@
// operator-include.go // operator-include.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- include term //-------- include term
func newIncludeTerm(tk *Token) (inst *term) { func newIncludeTerm(tk *Token) (inst *term) {
@ -16,7 +20,7 @@ func newIncludeTerm(tk *Token) (inst *term) {
} }
} }
func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) { func evalInclude(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
@ -24,8 +28,8 @@ func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
} }
count := 0 count := 0
if IsList(childValue) { if kern.IsList(childValue) {
list, _ := childValue.(*ListType) list, _ := childValue.(*kern.ListType)
for i, filePathSpec := range *list { for i, filePathSpec := range *list {
if filePath, ok := filePathSpec.(string); ok { if filePath, ok := filePathSpec.(string); ok {
if v, err = EvalFile(ctx, filePath); err == nil { if v, err = EvalFile(ctx, filePath); err == nil {
@ -39,13 +43,13 @@ func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
break break
} }
} }
} else if IsString(childValue) { } else if kern.IsString(childValue) {
filePath, _ := childValue.(string) filePath, _ := childValue.(string)
if v, err = EvalFile(ctx, filePath); err == nil { if v, err = EvalFile(ctx, filePath); err == nil {
count++ count++
} }
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
if err != nil { if err != nil {
//v = count //v = count

36
operator-index.go
View File

@ -4,6 +4,10 @@
// operator-index.go // operator-index.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- index term // -------- index term
func newIndexTerm(tk *Token) (inst *term) { func newIndexTerm(tk *Token) (inst *term) {
return &term{ return &term{
@ -15,15 +19,15 @@ func newIndexTerm(tk *Token) (inst *term) {
} }
} }
func verifyKey(indexList *ListType) (index any, err error) { func verifyKey(indexList *kern.ListType) (index any, err error) {
index = (*indexList)[0] index = (*indexList)[0]
return return
} }
func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int, err error) { func verifyIndex(indexTerm *term, indexList *kern.ListType, maxValue int) (index int, err error) {
var v int var v int
if v, err = ToGoInt((*indexList)[0], "index expression"); err == nil { if v, err = kern.ToGoInt((*indexList)[0], "index expression"); err == nil {
if v < 0 && v >= -maxValue { if v < 0 && v >= -maxValue {
v = maxValue + v v = maxValue + v
} }
@ -36,11 +40,11 @@ func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int,
return return
} }
func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex, endIndex int, err error) { func verifyRange(indexTerm *term, indexList *kern.ListType, maxValue int) (startIndex, endIndex int, err error) {
v, _ := ((*indexList)[0]).(*intPair) v, _ := ((*indexList)[0]).(*intPair)
startIndex = v.a startIndex = v.a
endIndex = v.b endIndex = v.b
if endIndex == ConstLastIndex { if endIndex == kern.ConstLastIndex {
endIndex = maxValue endIndex = maxValue
} }
if startIndex < 0 && startIndex >= -maxValue { if startIndex < 0 && startIndex >= -maxValue {
@ -59,9 +63,9 @@ func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex
return return
} }
func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) { func evalIndex(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var indexList *ListType var indexList *kern.ListType
var ok bool var ok bool
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -69,7 +73,7 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
} }
indexTerm := opTerm.children[1] indexTerm := opTerm.children[1]
if indexList, ok = rightValue.(*ListType); !ok { if indexList, ok = rightValue.(*kern.ListType); !ok {
err = opTerm.Errorf("invalid index expression") err = opTerm.Errorf("invalid index expression")
return return
} else if len(*indexList) != 1 { } else if len(*indexList) != 1 {
@ -77,9 +81,9 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
if IsInteger((*indexList)[0]) { if kern.IsInteger((*indexList)[0]) {
switch unboxedValue := leftValue.(type) { switch unboxedValue := leftValue.(type) {
case *ListType: case *kern.ListType:
var index int var index int
if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil { if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil {
v = (*unboxedValue)[index] v = (*unboxedValue)[index]
@ -89,17 +93,17 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil { if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil {
v = string(unboxedValue[index]) v = string(unboxedValue[index])
} }
case *DictType: case *kern.DictType:
v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue) v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue)
default: default:
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
} }
} else if isIntPair((*indexList)[0]) { } else if isIntPair((*indexList)[0]) {
switch unboxedValue := leftValue.(type) { switch unboxedValue := leftValue.(type) {
case *ListType: case *kern.ListType:
var start, end int var start, end int
if start, end, err = verifyRange(indexTerm, indexList, len(*unboxedValue)); err == nil { if start, end, err = verifyRange(indexTerm, indexList, len(*unboxedValue)); err == nil {
sublist := ListType((*unboxedValue)[start:end]) sublist := kern.ListType((*unboxedValue)[start:end])
v = &sublist v = &sublist
} }
case string: case string:
@ -110,8 +114,8 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
default: default:
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
} }
} else if IsDict(leftValue) { } else if kern.IsDict(leftValue) {
d := leftValue.(*DictType) d := leftValue.(*kern.DictType)
v, err = getDictItem(d, indexTerm, indexList, rightValue) v, err = getDictItem(d, indexTerm, indexList, rightValue)
} else { } else {
rightChild := opTerm.children[1] rightChild := opTerm.children[1]
@ -120,7 +124,7 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
func getDictItem(d *DictType, indexTerm *term, indexList *ListType, rightValue any) (v any, err error) { func getDictItem(d *kern.DictType, indexTerm *term, indexList *kern.ListType, rightValue any) (v any, err error) {
var ok bool var ok bool
var indexValue any var indexValue any

22
operator-insert.go
View File

@ -4,6 +4,10 @@
// operator-insert.go // operator-insert.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- prepend term //-------- prepend term
func newPrependTerm(tk *Token) (inst *term) { func newPrependTerm(tk *Token) (inst *term) {
@ -26,19 +30,19 @@ func newAppendTerm(tk *Token) (inst *term) {
} }
} }
func evalPrepend(ctx ExprContext, opTerm *term) (v any, err error) { func evalPrepend(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return return
} }
if IsList(rightValue) { if kern.IsList(rightValue) {
list, _ := rightValue.(*ListType) list, _ := rightValue.(*kern.ListType)
newList := append(ListType{leftValue}, *list...) newList := append(kern.ListType{leftValue}, *list...)
v = &newList v = &newList
if opTerm.children[1].symbol() == SymVariable { if opTerm.children[1].symbol() == SymVariable {
ctx.UnsafeSetVar(opTerm.children[1].source(), v) ctx.UnsafeSetVar(opTerm.children[1].Source(), v)
} }
} else { } else {
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
@ -46,19 +50,19 @@ func evalPrepend(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
func evalAppend(ctx ExprContext, opTerm *term) (v any, err error) { func evalAppend(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return return
} }
if IsList(leftValue) { if kern.IsList(leftValue) {
list, _ := leftValue.(*ListType) list, _ := leftValue.(*kern.ListType)
newList := append(*list, rightValue) newList := append(*list, rightValue)
v = &newList v = &newList
if opTerm.children[0].symbol() == SymVariable { if opTerm.children[0].symbol() == SymVariable {
ctx.UnsafeSetVar(opTerm.children[0].source(), v) ctx.UnsafeSetVar(opTerm.children[0].Source(), v)
} }
} else { } else {
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)

10
operator-iter-value.go
View File

@ -4,6 +4,10 @@
// operator-iter-value.go // operator-iter-value.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- iter value term //-------- iter value term
func newIterValueTerm(tk *Token) (inst *term) { func newIterValueTerm(tk *Token) (inst *term) {
@ -16,17 +20,17 @@ func newIterValueTerm(tk *Token) (inst *term) {
} }
} }
func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) { func evalIterValue(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if it, ok := childValue.(Iterator); ok { if it, ok := childValue.(kern.Iterator); ok {
v, err = it.Current() v, err = it.Current()
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }

20
operator-join.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- join term //-------- join term
@ -21,35 +23,35 @@ func newJoinTerm(tk *Token) (inst *term) {
} }
} }
func evalJoin(ctx ExprContext, opTerm *term) (v any, err error) { func evalJoin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var itLeft, itRight Iterator var itLeft, itRight kern.Iterator
var item any var item any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
if rightValue, err = opTerm.children[1].compute(ctx); err != nil { if rightValue, err = opTerm.children[1].Compute(ctx); err != nil {
return return
} }
if itLeft, err = NewIterator(leftValue); err != nil { if itLeft, err = NewIterator(leftValue); err != nil {
return nil, fmt.Errorf("left operand of JOIN must be an iterable data-source; got %s", TypeName(leftValue)) return nil, fmt.Errorf("left operand of JOIN must be an iterable data-source; got %s", kern.TypeName(leftValue))
} }
if itRight, err = NewIterator(rightValue); err != nil { if itRight, err = NewIterator(rightValue); err != nil {
return nil, fmt.Errorf("right operand of JOIN must be an iterable data-source; got %s", TypeName(rightValue)) return nil, fmt.Errorf("right operand of JOIN must be an iterable data-source; got %s", kern.TypeName(rightValue))
} }
values := newListA() values := kern.NewListA()
for _, it := range []Iterator{itLeft, itRight} { for _, it := range []kern.Iterator{itLeft, itRight} {
for item, err = it.Next(); err == nil; item, err = it.Next() { for item, err = it.Next(); err == nil; item, err = it.Next() {
values.appendItem(item) values.AppendItem(item)
} }
} }
if err == io.EOF { if err == io.EOF {

20
operator-length.go
View File

@ -4,6 +4,10 @@
// operator-length.go // operator-length.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- length term //-------- length term
func newLengthTerm(tk *Token) (inst *term) { func newLengthTerm(tk *Token) (inst *term) {
@ -16,23 +20,23 @@ func newLengthTerm(tk *Token) (inst *term) {
} }
} }
func evalLength(ctx ExprContext, opTerm *term) (v any, err error) { func evalLength(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsList(childValue) { if kern.IsList(childValue) {
ls, _ := childValue.(*ListType) ls, _ := childValue.(*kern.ListType)
v = int64(len(*ls)) v = int64(len(*ls))
} else if IsString(childValue) { } else if kern.IsString(childValue) {
s, _ := childValue.(string) s, _ := childValue.(string)
v = int64(len(s)) v = int64(len(s))
} else if IsDict(childValue) { } else if kern.IsDict(childValue) {
m, _ := childValue.(*DictType) m, _ := childValue.(*kern.DictType)
v = int64(len(*m)) v = int64(len(*m))
} else if it, ok := childValue.(Iterator); ok { } else if it, ok := childValue.(kern.Iterator); ok {
v = int64(it.Count()) v = int64(it.Count())
// if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) { // if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
// count, _ := extIt.CallOperation(CountName, nil) // count, _ := extIt.CallOperation(CountName, nil)
@ -41,7 +45,7 @@ func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
// v = int64(it.Index() + 1) // v = int64(it.Index() + 1)
// } // }
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }

16
operator-map.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"io" "io"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- map term //-------- map term
@ -21,30 +23,30 @@ func newMapTerm(tk *Token) (inst *term) {
} }
} }
func evalMap(ctx ExprContext, opTerm *term) (v any, err error) { func evalMap(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
var it Iterator var it kern.Iterator
var item any var item any
if err = opTerm.checkOperands(); err != nil { if err = opTerm.checkOperands(); err != nil {
return return
} }
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
if it, err = NewIterator(leftValue); err != nil { if it, err = NewIterator(leftValue); err != nil {
return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", TypeName(leftValue)) return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue))
} }
values := newListA() values := kern.NewListA()
for item, err = it.Next(); err == nil; item, err = it.Next() { for item, err = it.Next(); err == nil; item, err = it.Next() {
ctx.SetVar("_", item) ctx.SetVar("_", item)
ctx.SetVar("_index", it.Index()) ctx.SetVar("_index", it.Index())
ctx.SetVar("_count", it.Count()) ctx.SetVar("_count", it.Count())
if rightValue, err = opTerm.children[1].compute(ctx); err == nil { if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
values.appendItem(rightValue) values.AppendItem(rightValue)
} }
ctx.DeleteVar("_count") ctx.DeleteVar("_count")
ctx.DeleteVar("_index") ctx.DeleteVar("_index")

8
operator-plugin.go
View File

@ -4,6 +4,10 @@
// operator-plugin.go // operator-plugin.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- plugin term //-------- plugin term
func newPluginTerm(tk *Token) (inst *term) { func newPluginTerm(tk *Token) (inst *term) {
@ -16,7 +20,7 @@ func newPluginTerm(tk *Token) (inst *term) {
} }
} }
func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) { func evalPlugin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
var count int var count int
@ -24,7 +28,7 @@ func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
if count, err = importPluginFromSearchPath(childValue); err == nil { if count, err = importPluginFromSearchPath(ctx, childValue); err == nil {
v = int64(count) v = int64(count)
} }
return return

32
operator-post-inc-dec.go
View File

@ -4,6 +4,10 @@
// operator-post-inc-dec.go // operator-post-inc-dec.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- post increment term // -------- post increment term
func newPostIncTerm(tk *Token) *term { func newPostIncTerm(tk *Token) *term {
@ -17,40 +21,40 @@ func newPostIncTerm(tk *Token) *term {
} }
} }
func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) { func evalPostInc(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if it, ok := childValue.(Iterator); ok { if it, ok := childValue.(kern.Iterator); ok {
var namePrefix string var namePrefix string
v, err = it.Next() v, err = it.Next()
if opTerm.children[0].symbol() == SymVariable { if opTerm.children[0].symbol() == SymVariable {
namePrefix = opTerm.children[0].source() namePrefix = opTerm.children[0].Source()
} }
ctx.UnsafeSetVar(namePrefix+"_index", it.Index()) ctx.UnsafeSetVar(namePrefix+"_index", it.Index())
if c, err1 := it.Current(); err1 == nil { if c, err1 := it.Current(); err1 == nil {
ctx.UnsafeSetVar(namePrefix+"_current", c) ctx.UnsafeSetVar(namePrefix+"_current", c)
} }
if it.HasOperation(KeyName) { if it.HasOperation(kern.KeyName) {
if k, err1 := it.CallOperation(KeyName, nil); err1 == nil { if k, err1 := it.CallOperation(kern.KeyName, nil); err1 == nil {
ctx.UnsafeSetVar(namePrefix+"_key", k) ctx.UnsafeSetVar(namePrefix+"_key", k)
} }
} }
if it.HasOperation(ValueName) { if it.HasOperation(kern.ValueName) {
if v1, err1 := it.CallOperation(ValueName, nil); err1 == nil { if v1, err1 := it.CallOperation(kern.ValueName, nil); err1 == nil {
ctx.UnsafeSetVar(namePrefix+"_value", v1) ctx.UnsafeSetVar(namePrefix+"_value", v1)
} }
} }
} else if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable { } else if kern.IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
v = childValue v = childValue
i, _ := childValue.(int64) i, _ := childValue.(int64)
ctx.SetVar(opTerm.children[0].source(), i+1) ctx.SetVar(opTerm.children[0].Source(), i+1)
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }
@ -68,7 +72,7 @@ func newPostDecTerm(tk *Token) *term {
} }
} }
func evalPostDec(ctx ExprContext, opTerm *term) (v any, err error) { func evalPostDec(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
@ -76,12 +80,12 @@ func evalPostDec(ctx ExprContext, opTerm *term) (v any, err error) {
/* if it, ok := childValue.(Iterator); ok { /* if it, ok := childValue.(Iterator); ok {
v, err = it.Next() v, err = it.Next()
} else */if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable { } else */if kern.IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
v = childValue v = childValue
i, _ := childValue.(int64) i, _ := childValue.(int64)
ctx.SetVar(opTerm.children[0].source(), i-1) ctx.SetVar(opTerm.children[0].Source(), i-1)
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }

20
operator-pre-inc-dec.go
View File

@ -4,6 +4,10 @@
// operator-pre-inc-dec.go // operator-pre-inc-dec.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- pre increment term // -------- pre increment term
func newPreIncTerm(tk *Token) *term { func newPreIncTerm(tk *Token) *term {
@ -17,18 +21,18 @@ func newPreIncTerm(tk *Token) *term {
} }
} }
func evalPreInc(ctx ExprContext, opTerm *term) (v any, err error) { func evalPreInc(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable { if kern.IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
i := childValue.(int64) + 1 i := childValue.(int64) + 1
ctx.SetVar(opTerm.children[0].source(), i) ctx.SetVar(opTerm.children[0].Source(), i)
v = i v = i
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }
@ -46,18 +50,18 @@ func newPreDecTerm(tk *Token) *term {
} }
} }
func evalPreDec(ctx ExprContext, opTerm *term) (v any, err error) { func evalPreDec(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
if childValue, err = opTerm.evalPrefix(ctx); err != nil { if childValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable { if kern.IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
i := childValue.(int64) - 1 i := childValue.(int64) - 1
ctx.SetVar(opTerm.children[0].source(), i) ctx.SetVar(opTerm.children[0].Source(), i)
v = i v = i
} else { } else {
err = opTerm.errIncompatibleType(childValue) err = opTerm.errIncompatiblePrefixPostfixType(childValue)
} }
return return
} }

50
operator-prod.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- multiply term //-------- multiply term
@ -21,15 +23,15 @@ func newMultiplyTerm(tk *Token) (inst *term) {
} }
func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) { func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
if IsString(leftValue) && IsInteger(rightValue) { if kern.IsString(leftValue) && kern.IsInteger(rightValue) {
s, _ := leftValue.(string) s, _ := leftValue.(string)
n, _ := rightValue.(int64) n, _ := rightValue.(int64)
v = strings.Repeat(s, int(n)) v = strings.Repeat(s, int(n))
} else if isNumOrFract(leftValue) && isNumOrFract(rightValue) { } else if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
if IsFloat(leftValue) || IsFloat(rightValue) { if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
v = numAsFloat(leftValue) * numAsFloat(rightValue) v = kern.NumAsFloat(leftValue) * kern.NumAsFloat(rightValue)
} else if isFraction(leftValue) || isFraction(rightValue) { } else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
v, err = mulAnyFract(leftValue, rightValue) v, err = kern.MulAnyFract(leftValue, rightValue)
} else { } else {
leftInt, _ := leftValue.(int64) leftInt, _ := leftValue.(int64)
rightInt, _ := rightValue.(int64) rightInt, _ := rightValue.(int64)
@ -41,7 +43,7 @@ func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) { func evalMultiply(ctx kern.ExprContext, prodTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
@ -64,16 +66,16 @@ func newDivideTerm(tk *Token) (inst *term) {
} }
func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) { func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
if isNumOrFract(leftValue) && isNumOrFract(rightValue) { if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
if IsFloat(leftValue) || IsFloat(rightValue) { if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
d := numAsFloat(rightValue) d := kern.NumAsFloat(rightValue)
if d == 0.0 { if d == 0.0 {
err = opTerm.errDivisionByZero() err = opTerm.errDivisionByZero()
} else { } else {
v = numAsFloat(leftValue) / d v = kern.NumAsFloat(leftValue) / d
} }
} else if isFraction(leftValue) || isFraction(rightValue) { } else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
v, err = divAnyFract(leftValue, rightValue) v, err = kern.DivAnyFract(leftValue, rightValue)
} else { } else {
leftInt, _ := leftValue.(int64) leftInt, _ := leftValue.(int64)
if rightInt, _ := rightValue.(int64); rightInt == 0 { if rightInt, _ := rightValue.(int64); rightInt == 0 {
@ -82,11 +84,11 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
v = leftInt / rightInt v = leftInt / rightInt
} }
} }
} else if IsString(leftValue) && IsString(rightValue) { } else if kern.IsString(leftValue) && kern.IsString(rightValue) {
source := leftValue.(string) source := leftValue.(string)
sep := rightValue.(string) sep := rightValue.(string)
v = ListFromStrings(strings.Split(source, sep)) v = kern.ListFromStrings(strings.Split(source, sep))
} else if IsString(leftValue) && IsInteger(rightValue) { } else if kern.IsString(leftValue) && kern.IsInteger(rightValue) {
source := leftValue.(string) source := leftValue.(string)
partSize := int(rightValue.(int64)) partSize := int(rightValue.(int64))
if partSize == 0 { if partSize == 0 {
@ -105,7 +107,7 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
if remainder > 0 { if remainder > 0 {
parts = append(parts, source[len(source)-remainder:]) parts = append(parts, source[len(source)-remainder:])
} }
v = newList(parts) v = kern.NewList(parts)
} }
} else { } else {
err = opTerm.errIncompatibleTypes(leftValue, rightValue) err = opTerm.errIncompatibleTypes(leftValue, rightValue)
@ -113,7 +115,7 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) { func evalDivide(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -135,19 +137,19 @@ func newDivideAsFloatTerm(tk *Token) (inst *term) {
} }
} }
func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) { func evalDivideAsFloat(ctx kern.ExprContext, floatDivTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil {
return return
} }
if isNumOrFract(leftValue) && isNumOrFract(rightValue) { if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
d := numAsFloat(rightValue) d := kern.NumAsFloat(rightValue)
if d == 0.0 { if d == 0.0 {
err = floatDivTerm.errDivisionByZero() err = floatDivTerm.errDivisionByZero()
} else { } else {
v = numAsFloat(leftValue) / d v = kern.NumAsFloat(leftValue) / d
} }
} else { } else {
err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue) err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue)
@ -167,7 +169,7 @@ func newRemainderTerm(tk *Token) (inst *term) {
} }
} }
func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) { func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
if IsInteger(leftValue) && IsInteger(rightValue) { if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
rightInt, _ := rightValue.(int64) rightInt, _ := rightValue.(int64)
if rightInt == 0 { if rightInt == 0 {
err = opTerm.errDivisionByZero() err = opTerm.errDivisionByZero()
@ -181,7 +183,7 @@ func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error)
return return
} }
func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) { func evalRemainder(ctx kern.ExprContext, remainderTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {

18
operator-range.go
View File

@ -4,7 +4,11 @@
// operator-range.go // operator-range.go
package expr package expr
import "fmt" import (
"fmt"
"git.portale-stac.it/go-pkg/expr/kern"
)
// -------- range term // -------- range term
type intPair struct { type intPair struct {
@ -12,10 +16,10 @@ type intPair struct {
} }
func (p *intPair) TypeName() string { func (p *intPair) TypeName() string {
return TypePair return kern.TypePair
} }
func (p *intPair) ToString(opt FmtOpt) string { func (p *intPair) ToString(opt kern.FmtOpt) string {
return fmt.Sprintf("(%d, %d)", p.a, p.b) return fmt.Sprintf("(%d, %d)", p.a, p.b)
} }
@ -41,21 +45,21 @@ func changeColonToRange(t *term) {
} }
} }
func evalRange(ctx ExprContext, opTerm *term) (v any, err error) { func evalRange(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if len(opTerm.children) == 0 { if len(opTerm.children) == 0 {
leftValue = int64(0) leftValue = int64(0)
rightValue = int64(-1) rightValue = int64(-1)
} else if len(opTerm.children) == 1 { } else if len(opTerm.children) == 1 {
if leftValue, err = opTerm.children[0].compute(ctx); err != nil { if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
return return
} }
rightValue = int64(ConstLastIndex) rightValue = int64(kern.ConstLastIndex)
} else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { } else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
return return
} }
if !(IsInteger(leftValue) && IsInteger(rightValue)) { if !(kern.IsInteger(leftValue) && kern.IsInteger(rightValue)) {
// err = opTerm.errIncompatibleTypes(leftValue, rightValue) // err = opTerm.errIncompatibleTypes(leftValue, rightValue)
err = errRangeInvalidSpecification(opTerm) err = errRangeInvalidSpecification(opTerm)
return return

60
operator-rel.go
View File

@ -4,7 +4,11 @@
// operator-rel.go // operator-rel.go
package expr package expr
import "reflect" import (
"reflect"
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- equal term //-------- equal term
@ -18,25 +22,25 @@ func newEqualTerm(tk *Token) (inst *term) {
} }
} }
type deepFuncTemplate func(a, b any) (eq bool, err error) // type deepFuncTemplate func(a, b any) (eq bool, err error)
func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) { func equals(a, b any, deepCmp kern.DeepFuncTemplate) (eq bool, err error) {
if isNumOrFract(a) && isNumOrFract(b) { if kern.IsNumOrFract(a) && kern.IsNumOrFract(b) {
if IsNumber(a) && IsNumber(b) { if kern.IsNumber(a) && kern.IsNumber(b) {
if IsInteger(a) && IsInteger(b) { if kern.IsInteger(a) && kern.IsInteger(b) {
li, _ := a.(int64) li, _ := a.(int64)
ri, _ := b.(int64) ri, _ := b.(int64)
eq = li == ri eq = li == ri
} else { } else {
eq = numAsFloat(a) == numAsFloat(b) eq = kern.NumAsFloat(a) == kern.NumAsFloat(b)
} }
} else { } else {
var cmp int var cmp int
if cmp, err = cmpAnyFract(a, b); err == nil { if cmp, err = kern.CmpAnyFract(a, b); err == nil {
eq = cmp == 0 eq = cmp == 0
} }
} }
} else if deepCmp != nil && IsList(a) && IsList(b) { } else if deepCmp != nil && kern.IsList(a) && kern.IsList(b) {
eq, err = deepCmp(a, b) eq, err = deepCmp(a, b)
} else { } else {
eq = reflect.DeepEqual(a, b) eq = reflect.DeepEqual(a, b)
@ -45,7 +49,7 @@ func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
return return
} }
func evalEqual(ctx ExprContext, opTerm *term) (v any, err error) { func evalEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -68,9 +72,9 @@ func newNotEqualTerm(tk *Token) (inst *term) {
} }
} }
func evalNotEqual(ctx ExprContext, opTerm *term) (v any, err error) { func evalNotEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
if v, err = evalEqual(ctx, opTerm); err == nil { if v, err = evalEqual(ctx, opTerm); err == nil {
b, _ := ToBool(v) b, _ := kern.ToBool(v)
v = !b v = !b
} }
return return
@ -89,37 +93,37 @@ func newLessTerm(tk *Token) (inst *term) {
} }
func lessThan(self *term, a, b any) (isLess bool, err error) { func lessThan(self *term, a, b any) (isLess bool, err error) {
if isNumOrFract(a) && isNumOrFract(b) { if kern.IsNumOrFract(a) && kern.IsNumOrFract(b) {
if IsNumber(a) && IsNumber(b) { if kern.IsNumber(a) && kern.IsNumber(b) {
if IsInteger(a) && IsInteger(b) { if kern.IsInteger(a) && kern.IsInteger(b) {
li, _ := a.(int64) li, _ := a.(int64)
ri, _ := b.(int64) ri, _ := b.(int64)
isLess = li < ri isLess = li < ri
} else { } else {
isLess = numAsFloat(a) < numAsFloat(b) isLess = kern.NumAsFloat(a) < kern.NumAsFloat(b)
} }
} else { } else {
var cmp int var cmp int
if cmp, err = cmpAnyFract(a, b); err == nil { if cmp, err = kern.CmpAnyFract(a, b); err == nil {
isLess = cmp < 0 isLess = cmp < 0
} }
} }
} else if IsString(a) && IsString(b) { } else if kern.IsString(a) && kern.IsString(b) {
ls, _ := a.(string) ls, _ := a.(string)
rs, _ := b.(string) rs, _ := b.(string)
isLess = ls < rs isLess = ls < rs
// Inclusion test // Inclusion test
} else if IsList(a) && IsList(b) { } else if kern.IsList(a) && kern.IsList(b) {
aList, _ := a.(*ListType) aList, _ := a.(*kern.ListType)
bList, _ := b.(*ListType) bList, _ := b.(*kern.ListType)
isLess = len(*aList) < len(*bList) && bList.contains(aList) isLess = len(*aList) < len(*bList) && bList.Contains(aList)
} else { } else {
err = self.errIncompatibleTypes(a, b) err = self.errIncompatibleTypes(a, b)
} }
return return
} }
func evalLess(ctx ExprContext, opTerm *term) (v any, err error) { func evalLess(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -144,8 +148,8 @@ func newLessEqualTerm(tk *Token) (inst *term) {
func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) { func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
if isLessEq, err = lessThan(self, a, b); err == nil { if isLessEq, err = lessThan(self, a, b); err == nil {
if !isLessEq { if !isLessEq {
if IsList(a) && IsList(b) { if kern.IsList(a) && kern.IsList(b) {
isLessEq, err = sameContent(a, b) isLessEq, err = kern.SameContent(a, b)
} else { } else {
isLessEq, err = equals(a, b, nil) isLessEq, err = equals(a, b, nil)
} }
@ -154,7 +158,7 @@ func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
return return
} }
func evalLessEqual(ctx ExprContext, opTerm *term) (v any, err error) { func evalLessEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -178,7 +182,7 @@ func newGreaterTerm(tk *Token) (inst *term) {
} }
} }
func evalGreater(ctx ExprContext, opTerm *term) (v any, err error) { func evalGreater(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -201,7 +205,7 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
} }
} }
func evalGreaterEqual(ctx ExprContext, opTerm *term) (v any, err error) { func evalGreaterEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

12
operator-selector.go
View File

@ -4,6 +4,10 @@
// operator-selector.go // operator-selector.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- selector term //-------- selector term
func newSelectorTerm(tk *Token) (inst *term) { func newSelectorTerm(tk *Token) (inst *term) {
@ -16,7 +20,7 @@ func newSelectorTerm(tk *Token) (inst *term) {
} }
} }
func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) { func trySelectorCase(ctx kern.ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
caseData, _ := caseSel.(*selectorCase) caseData, _ := caseSel.(*selectorCase)
if caseData.filterList == nil { if caseData.filterList == nil {
selectedValue, err = caseData.caseExpr.Eval(ctx) selectedValue, err = caseData.caseExpr.Eval(ctx)
@ -38,7 +42,7 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
} else { } else {
var caseValue any var caseValue any
for _, caseTerm := range filterList { for _, caseTerm := range filterList {
if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue { if caseValue, err = caseTerm.Compute(ctx); err != nil || caseValue == exprValue {
selectedValue, err = caseData.caseExpr.Eval(ctx) selectedValue, err = caseData.caseExpr.Eval(ctx)
match = true match = true
break break
@ -49,7 +53,7 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
return return
} }
func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) { func evalSelector(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var exprValue any var exprValue any
var match bool var match bool
@ -57,7 +61,7 @@ func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
return return
} }
exprTerm := opTerm.children[0] exprTerm := opTerm.children[0]
if exprValue, err = exprTerm.compute(ctx); err != nil { if exprValue, err = exprTerm.Compute(ctx); err != nil {
return return
} }

12
operator-shift.go
View File

@ -4,6 +4,10 @@
// operator-shift.go // operator-shift.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- bit right shift term //-------- bit right shift term
func newRightShiftTerm(tk *Token) (inst *term) { func newRightShiftTerm(tk *Token) (inst *term) {
@ -17,7 +21,7 @@ func newRightShiftTerm(tk *Token) (inst *term) {
} }
func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) { func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
if IsInteger(leftValue) && IsInteger(rightValue) { if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
leftInt := leftValue.(int64) leftInt := leftValue.(int64)
rightInt := rightValue.(int64) rightInt := rightValue.(int64)
v = leftInt >> rightInt v = leftInt >> rightInt
@ -27,7 +31,7 @@ func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) { func evalRightShift(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@ -49,7 +53,7 @@ func newLeftShiftTerm(tk *Token) (inst *term) {
} }
func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) { func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
if IsInteger(leftValue) && IsInteger(rightValue) { if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
leftInt := leftValue.(int64) leftInt := leftValue.(int64)
rightInt := rightValue.(int64) rightInt := rightValue.(int64)
v = leftInt << rightInt v = leftInt << rightInt
@ -59,7 +63,7 @@ func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) { func evalLeftShift(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

12
operator-sign.go
View File

@ -4,6 +4,10 @@
// operator-sign.go // operator-sign.go
package expr package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- plus sign term //-------- plus sign term
func newPlusSignTerm(tk *Token) (inst *term) { func newPlusSignTerm(tk *Token) (inst *term) {
@ -28,21 +32,21 @@ func newMinusSignTerm(tk *Token) (inst *term) {
} }
} }
func evalSign(ctx ExprContext, opTerm *term) (v any, err error) { func evalSign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue any var rightValue any
if rightValue, err = opTerm.evalPrefix(ctx); err != nil { if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
return return
} }
if IsFloat(rightValue) { if kern.IsFloat(rightValue) {
if opTerm.tk.Sym == SymChangeSign { if opTerm.tk.Sym == SymChangeSign {
f, _ := rightValue.(float64) f, _ := rightValue.(float64)
v = -f v = -f
} else { } else {
v = rightValue v = rightValue
} }
} else if IsInteger(rightValue) { } else if kern.IsInteger(rightValue) {
if opTerm.tk.Sym == SymChangeSign { if opTerm.tk.Sym == SymChangeSign {
i, _ := rightValue.(int64) i, _ := rightValue.(int64)
v = -i v = -i
@ -50,7 +54,7 @@ func evalSign(ctx ExprContext, opTerm *term) (v any, err error) {
v = rightValue v = rightValue
} }
} else { } else {
err = opTerm.errIncompatibleType(rightValue) err = opTerm.errIncompatiblePrefixPostfixType(rightValue)
} }
return return
} }

64
operator-sum.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"fmt" "fmt"
"slices" "slices"
"git.portale-stac.it/go-pkg/expr/kern"
) )
//-------- plus term //-------- plus term
@ -22,46 +24,46 @@ func newPlusTerm(tk *Token) (inst *term) {
} }
func sumValues(plusTerm *term, leftValue, rightValue any) (v any, err error) { func sumValues(plusTerm *term, leftValue, rightValue any) (v any, err error) {
if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) { if (kern.IsString(leftValue) && kern.IsNumberString(rightValue)) || (kern.IsString(rightValue) && kern.IsNumberString(leftValue)) {
v = fmt.Sprintf("%v%v", leftValue, rightValue) v = fmt.Sprintf("%v%v", leftValue, rightValue)
} else if IsNumber(leftValue) && IsNumber(rightValue) { } else if kern.IsNumber(leftValue) && kern.IsNumber(rightValue) {
if IsFloat(leftValue) || IsFloat(rightValue) { if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
v = numAsFloat(leftValue) + numAsFloat(rightValue) v = kern.NumAsFloat(leftValue) + kern.NumAsFloat(rightValue)
} else { } else {
leftInt, _ := leftValue.(int64) leftInt, _ := leftValue.(int64)
rightInt, _ := rightValue.(int64) rightInt, _ := rightValue.(int64)
v = leftInt + rightInt v = leftInt + rightInt
} }
} else if IsList(leftValue) && IsList(rightValue) { } else if kern.IsList(leftValue) && kern.IsList(rightValue) {
var leftList, rightList *ListType var leftList, rightList *kern.ListType
leftList, _ = leftValue.(*ListType) leftList, _ = leftValue.(*kern.ListType)
rightList, _ = rightValue.(*ListType) rightList, _ = rightValue.(*kern.ListType)
sumList := make(ListType, 0, len(*leftList)+len(*rightList)) sumList := make(kern.ListType, 0, len(*leftList)+len(*rightList))
sumList = append(sumList, *leftList...) sumList = append(sumList, *leftList...)
sumList = append(sumList, *rightList...) sumList = append(sumList, *rightList...)
v = &sumList v = &sumList
} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) { } else if (kern.IsFraction(leftValue) && kern.IsNumber(rightValue)) || (kern.IsFraction(rightValue) && kern.IsNumber(leftValue)) {
if IsFloat(leftValue) || IsFloat(rightValue) { if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
v = numAsFloat(leftValue) + numAsFloat(rightValue) v = kern.NumAsFloat(leftValue) + kern.NumAsFloat(rightValue)
} else { } else {
v, err = sumAnyFract(leftValue, rightValue) v, err = kern.SumAnyFract(leftValue, rightValue)
} }
} else if IsDict(leftValue) && IsDict(rightValue) { } else if kern.IsDict(leftValue) && kern.IsDict(rightValue) {
leftDict, _ := leftValue.(*DictType) leftDict, _ := leftValue.(*kern.DictType)
rightDict, _ := rightValue.(*DictType) rightDict, _ := rightValue.(*kern.DictType)
c := leftDict.clone() c := leftDict.Clone()
c.merge(rightDict) c.Merge(rightDict)
v = c v = c
} else if isFraction(leftValue) && isFraction(rightValue) { } else if kern.IsFraction(leftValue) && kern.IsFraction(rightValue) {
v, err = sumAnyFract(leftValue, rightValue) v, err = kern.SumAnyFract(leftValue, rightValue)
} else { } else {
err = plusTerm.errIncompatibleTypes(leftValue, rightValue) err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
} }
return v, err return v, err
} }
func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) { func evalPlus(ctx kern.ExprContext, plusTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
@ -84,20 +86,20 @@ func newMinusTerm(tk *Token) (inst *term) {
} }
func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) { func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
if isNumOrFract(leftValue) && isNumOrFract(rightValue) { if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
if IsFloat(leftValue) || IsFloat(rightValue) { if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
v = numAsFloat(leftValue) - numAsFloat(rightValue) v = kern.NumAsFloat(leftValue) - kern.NumAsFloat(rightValue)
} else if isFraction(leftValue) || isFraction(rightValue) { } else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
v, err = subAnyFract(leftValue, rightValue) v, err = kern.SubAnyFract(leftValue, rightValue)
} else { } else {
leftInt, _ := leftValue.(int64) leftInt, _ := leftValue.(int64)
rightInt, _ := rightValue.(int64) rightInt, _ := rightValue.(int64)
v = leftInt - rightInt v = leftInt - rightInt
} }
} else if IsList(leftValue) && IsList(rightValue) { } else if kern.IsList(leftValue) && kern.IsList(rightValue) {
leftList, _ := leftValue.(*ListType) leftList, _ := leftValue.(*kern.ListType)
rightList, _ := rightValue.(*ListType) rightList, _ := rightValue.(*kern.ListType)
diffList := make(ListType, 0, len(*leftList)-len(*rightList)) diffList := make(kern.ListType, 0, len(*leftList)-len(*rightList))
for _, item := range *leftList { for _, item := range *leftList {
if slices.Index(*rightList, item) < 0 { if slices.Index(*rightList, item) < 0 {
diffList = append(diffList, item) diffList = append(diffList, item)
@ -110,7 +112,7 @@ func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
return return
} }
func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) { func evalMinus(ctx kern.ExprContext, minusTerm *term) (v any, err error) {
var leftValue, rightValue any var leftValue, rightValue any
if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil { if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {

16
operator-unset.go
View File

@ -4,7 +4,11 @@
// operator-unset.go // operator-unset.go
package expr package expr
import "strings" import (
"strings"
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- unset term //-------- unset term
@ -18,7 +22,7 @@ func newUnsetTerm(tk *Token) (inst *term) {
} }
} }
func deleteContextItem(ctx ExprContext, opTerm *term, item any) (deleted bool, err error) { func deleteContextItem(ctx kern.ExprContext, opTerm *term, item any) (deleted bool, err error) {
if name, ok := item.(string); ok { if name, ok := item.(string); ok {
var size int var size int
if strings.HasSuffix(name, "()") { if strings.HasSuffix(name, "()") {
@ -31,12 +35,12 @@ func deleteContextItem(ctx ExprContext, opTerm *term, item any) (deleted bool, e
deleted = ctx.VarCount() < size deleted = ctx.VarCount() < size
} }
} else { } else {
err = opTerm.errIncompatibleType(item) err = opTerm.errIncompatiblePrefixPostfixType(item)
} }
return return
} }
func evalUnset(ctx ExprContext, opTerm *term) (v any, err error) { func evalUnset(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var childValue any var childValue any
var deleted bool var deleted bool
@ -45,8 +49,8 @@ func evalUnset(ctx ExprContext, opTerm *term) (v any, err error) {
} }
count := 0 count := 0
if IsList(childValue) { if kern.IsList(childValue) {
list, _ := childValue.(*ListType) list, _ := childValue.(*kern.ListType)
for _, item := range *list { for _, item := range *list {
if deleted, err = deleteContextItem(ctx, opTerm, item); err != nil { if deleted, err = deleteContextItem(ctx, opTerm, item); err != nil {
break break

6
parser.go
View File

@ -104,7 +104,7 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
param := newTerm(tk) param := newTerm(tk)
if len(args) > 0 { if len(args) > 0 {
if pos := paramAlreadyDefined(args, param); pos > 0 { if pos := paramAlreadyDefined(args, param); pos > 0 {
err = tk.Errorf("parameter %q at position %d already defined at position %d", param.source(), len(args)+1, pos) err = tk.Errorf("parameter %q at position %d already defined at position %d", param.Source(), len(args)+1, pos)
break break
} }
} }
@ -155,7 +155,7 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
func paramAlreadyDefined(args []*term, param *term) (position int) { func paramAlreadyDefined(args []*term, param *term) (position int) {
position = 0 position = 0
for i, arg := range args { for i, arg := range args {
if arg.source() == param.source() { if arg.Source() == param.Source() {
position = i + 1 position = i + 1
} }
} }
@ -397,7 +397,7 @@ func couldBeACollection(t *term) bool {
func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err error) { func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err error) {
var tk *Token var tk *Token
if allowIndeces { if allowIndeces {
tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source()) tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.Source())
root = newTerm(tk) root = newTerm(tk)
if err = tree.addTerm(root); err == nil { if err = tree.addTerm(root); err == nil {
err = tree.addTerm(listTerm) err = tree.addTerm(listTerm)

28
plugins.go
View File

@ -10,6 +10,8 @@ import (
"os" "os"
"plugin" "plugin"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
var pluginRegister map[string]*plugin.Plugin var pluginRegister map[string]*plugin.Plugin
@ -39,12 +41,12 @@ func makePluginName(name string) (decorated string) {
return return
} }
func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err error) { func importPlugin(ctx kern.ExprContext, dirList []string, name string) (err error) {
var filePath string var filePath string
var p *plugin.Plugin var p *plugin.Plugin
var sym plugin.Symbol var sym plugin.Symbol
var moduleName string var moduleName string
var importFunc func(ExprContext) var importFunc func(kern.ExprContext)
var ok bool var ok bool
decoratedName := makePluginName(name) decoratedName := makePluginName(name)
@ -71,7 +73,7 @@ func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err erro
} }
if deps := *sym.(*[]string); len(deps) > 0 { if deps := *sym.(*[]string); len(deps) > 0 {
// var count int // var count int
if err = loadModules(dirList, deps); err != nil { if err = loadModules(ctx, dirList, deps); err != nil {
return return
} }
} }
@ -80,33 +82,35 @@ func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err erro
return return
} }
if importFunc, ok = sym.(func(ExprContext)); !ok { if importFunc, ok = sym.(func(kern.ExprContext)); !ok {
err = fmt.Errorf("plugin %q does not provide a valid import function", decoratedName) err = fmt.Errorf("plugin %q does not provide a valid import function", decoratedName)
return return
} }
registerPlugin(moduleName, p) registerPlugin(moduleName, p)
if globalCtx := ctx.GetGlobal(); globalCtx != nil {
importFunc(globalCtx) importFunc(globalCtx)
}
return return
} }
func importPluginFromSearchPath(name any) (count int, err error) { func importPluginFromSearchPath(ctx kern.ExprContext, name any) (count int, err error) {
var moduleSpec any var moduleSpec any
var it Iterator var it kern.Iterator
dirList := buildSearchDirList("plugin", ENV_EXPR_PLUGIN_PATH) dirList := buildSearchDirList(ctx, "plugin", ENV_EXPR_PLUGIN_PATH)
count = 0 count = 0
if it, err = NewIterator(name); err != nil { if it, err = NewIterator(name); err != nil {
return return
} }
for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() { for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
if module, ok := moduleSpec.(string); ok { if module, ok := moduleSpec.(string); ok {
if err = importPlugin(dirList, module); err != nil { if err = importPlugin(ctx, dirList, module); err != nil {
break break
} }
count++ count++
} else { } else {
err = fmt.Errorf("expected string as item nr %d, got %s", it.Index()+1, TypeName(moduleSpec)) err = fmt.Errorf("expected string as item nr %d, got %s", it.Index()+1, kern.TypeName(moduleSpec))
break break
} }
} }
@ -116,10 +120,10 @@ func importPluginFromSearchPath(name any) (count int, err error) {
return return
} }
func loadModules(dirList []string, moduleNames []string) (err error) { func loadModules(ctx kern.ExprContext, dirList []string, moduleNames []string) (err error) {
for _, name := range moduleNames { for _, name := range moduleNames {
if err1 := importPlugin(dirList, name); err1 != nil { if err1 := importPlugin(ctx, dirList, name); err1 != nil {
if !ImportInContext(name) { if !ImportInContext(ctx, name) {
err = err1 err = err1
break break
} }

4
scanner.go
View File

@ -11,6 +11,8 @@ import (
"io" "io"
"strconv" "strconv"
"strings" "strings"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type scanner struct { type scanner struct {
@ -503,7 +505,7 @@ func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
if sym == SymFloat { if sym == SymFloat {
value, err = strconv.ParseFloat(txt, 64) value, err = strconv.ParseFloat(txt, 64)
} else if sym == SymFraction { } else if sym == SymFraction {
value, err = makeGeneratingFraction(txt) value, err = kern.MakeGeneratingFraction(txt)
} else { } else {
value, err = strconv.ParseInt(txt, numBase, 64) value, err = strconv.ParseInt(txt, numBase, 64)
} }

104
simple-store.go
View File

@ -7,43 +7,62 @@ package expr
import ( import (
"fmt" "fmt"
"slices" "slices"
"git.portale-stac.it/go-pkg/expr/kern"
// "strings" // "strings"
) )
type SimpleStore struct { type SimpleStore struct {
parent ExprContext global kern.ExprContext
parent kern.ExprContext
varStore map[string]any varStore map[string]any
funcStore map[string]ExprFunc funcStore map[string]kern.ExprFunc
} }
func NewSimpleStore() *SimpleStore { func NewSimpleStore() *SimpleStore {
global := InitGlobal()
ctx := &SimpleStore{
global: global,
varStore: make(map[string]any),
funcStore: make(map[string]kern.ExprFunc),
}
return ctx
}
func NewSimpleStoreWithoutGlobalContext() *SimpleStore {
ctx := &SimpleStore{ ctx := &SimpleStore{
varStore: make(map[string]any), varStore: make(map[string]any),
funcStore: make(map[string]ExprFunc), funcStore: make(map[string]kern.ExprFunc),
} }
return ctx return ctx
} }
func (ss *SimpleStore) Init() { func (ss *SimpleStore) Init() {
ss.varStore = make(map[string]any) ss.varStore = make(map[string]any)
ss.funcStore = make(map[string]ExprFunc) ss.funcStore = make(map[string]kern.ExprFunc)
} }
func filterRefName(name string) bool { return name[0] != '@' } func filterRefName(name string) bool { return name[0] != '@' }
//func filterPrivName(name string) bool { return name[0] != '_' } //func filterPrivName(name string) bool { return name[0] != '_' }
func (ctx *SimpleStore) SetParent(parentCtx ExprContext) { func (ctx *SimpleStore) SetParent(parentCtx kern.ExprContext) {
ctx.parent = parentCtx ctx.parent = parentCtx
} }
func (ctx *SimpleStore) GetParent() ExprContext { func (ctx *SimpleStore) GetParent() kern.ExprContext {
return ctx.parent return ctx.parent
} }
func (ctx *SimpleStore) Clone() ExprContext { func (ctx *SimpleStore) GetGlobal() (globalCtx kern.ExprContext) {
return ctx.global
}
func (ctx *SimpleStore) Clone() kern.ExprContext {
clone := &SimpleStore{ clone := &SimpleStore{
varStore: CloneFilteredMap(ctx.varStore, filterRefName), global: ctx.global,
funcStore: CloneFilteredMap(ctx.funcStore, filterRefName), varStore: kern.CloneFilteredMap(ctx.varStore, filterRefName),
funcStore: kern.CloneFilteredMap(ctx.funcStore, filterRefName),
} }
return clone return clone
} }
@ -57,19 +76,19 @@ func (ctx *SimpleStore) Clone() ExprContext {
// } // }
// } // }
func (ctx *SimpleStore) ToString(opt FmtOpt) string { func (ctx *SimpleStore) ToString(opt kern.FmtOpt) string {
dict := ctx.ToDict() dict := ctx.ToDict()
return dict.ToString(opt) return dict.ToString(opt)
} }
func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType { func (ctx *SimpleStore) varsToDict(dict *kern.DictType) *kern.DictType {
names := ctx.EnumVars(nil) names := ctx.EnumVars(nil)
slices.Sort(names) slices.Sort(names)
for _, name := range ctx.EnumVars(nil) { for _, name := range ctx.EnumVars(nil) {
value, _ := ctx.GetVar(name) value, _ := ctx.GetVar(name)
if f, ok := value.(Formatter); ok { if f, ok := value.(kern.Formatter); ok {
(*dict)[name] = f.ToString(0) (*dict)[name] = f.ToString(0)
} else if _, ok = value.(Functor); ok { } else if _, ok = value.(kern.Functor); ok {
(*dict)[name] = "func(){}" (*dict)[name] = "func(){}"
} else { } else {
(*dict)[name] = fmt.Sprintf("%v", value) (*dict)[name] = fmt.Sprintf("%v", value)
@ -78,12 +97,12 @@ func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType {
return dict return dict
} }
func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType { func (ctx *SimpleStore) funcsToDict(dict *kern.DictType) *kern.DictType {
names := ctx.EnumFuncs(func(name string) bool { return true }) names := ctx.EnumFuncs(func(name string) bool { return true })
slices.Sort(names) slices.Sort(names)
for _, name := range names { for _, name := range names {
value, _ := ctx.GetFuncInfo(name) value, _ := ctx.GetFuncInfo(name)
if formatter, ok := value.(Formatter); ok { if formatter, ok := value.(kern.Formatter); ok {
(*dict)[name] = formatter.ToString(0) (*dict)[name] = formatter.ToString(0)
} else { } else {
(*dict)[name] = fmt.Sprintf("%v", value) (*dict)[name] = fmt.Sprintf("%v", value)
@ -92,20 +111,23 @@ func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType {
return dict return dict
} }
func (ctx *SimpleStore) ToDict() (dict *DictType) { func (ctx *SimpleStore) ToDict() (dict *kern.DictType) {
dict = MakeDict() dict = kern.MakeDict()
(*dict)["variables"] = ctx.varsToDict(MakeDict()) (*dict)["variables"] = ctx.varsToDict(kern.MakeDict())
(*dict)["functions"] = ctx.funcsToDict(MakeDict()) (*dict)["functions"] = ctx.funcsToDict(kern.MakeDict())
return return
} }
func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) { func (ctx *SimpleStore) GetVar(varName string) (value any, exists bool) {
v, exists = ctx.varStore[varName] if value, exists = ctx.varStore[varName]; !exists && ctx.global != nil {
value, exists = ctx.global.GetVar(varName)
}
return return
} }
func (ctx *SimpleStore) GetLast() (v any) { func (ctx *SimpleStore) GetLast() (v any) {
v = ctx.varStore["last"] v = ctx.varStore[kern.ControlLastResult]
return return
} }
@ -116,7 +138,7 @@ func (ctx *SimpleStore) UnsafeSetVar(varName string, value any) {
func (ctx *SimpleStore) SetVar(varName string, value any) { func (ctx *SimpleStore) SetVar(varName string, value any) {
// fmt.Printf("[%p] SetVar(%v, %v)\n", ctx, varName, value) // fmt.Printf("[%p] SetVar(%v, %v)\n", ctx, varName, value)
if allowedValue, ok := fromGenericAny(value); ok { if allowedValue, ok := kern.FromGenericAny(value); ok {
ctx.varStore[varName] = allowedValue ctx.varStore[varName] = allowedValue
} else { } else {
panic(fmt.Errorf("unsupported type %T of value %v", value, value)) panic(fmt.Errorf("unsupported type %T of value %v", value, value))
@ -145,16 +167,42 @@ func (ctx *SimpleStore) DeleteVar(varName string) {
delete(ctx.varStore, varName) delete(ctx.varStore, varName)
} }
func (ctx *SimpleStore) GetFuncInfo(name string) (info ExprFunc, exists bool) { func (ctx *SimpleStore) GetFuncInfo(name string) (info kern.ExprFunc, exists bool) {
info, exists = ctx.funcStore[name] info, exists, _ = ctx.GetFuncInfoAndOwner(name)
return return
} }
func (ctx *SimpleStore) RegisterFuncInfo(info ExprFunc) { func (ctx *SimpleStore) GetFuncInfoAndOwner(name string) (info kern.ExprFunc, exists bool, ownerCtx kern.ExprContext) {
if len(name) > 0 {
if info, exists = ctx.GetLocalFuncInfo(name); exists {
ownerCtx = ctx
} else if globalCtx := ctx.GetGlobal(); globalCtx != nil {
if info, exists = globalCtx.GetFuncInfo(name); exists {
ownerCtx = globalCtx
}
}
}
return
}
func (ctx *SimpleStore) GetLocalFuncInfo(name string) (info kern.ExprFunc, exists bool) {
var v any
if len(name) > 0 {
if v, exists = ctx.GetVar(name); exists && kern.IsFunctor(v) {
f, _ := v.(kern.Functor)
info = f.GetFunc()
} else {
info, exists = ctx.funcStore[name]
}
}
return
}
func (ctx *SimpleStore) RegisterFuncInfo(info kern.ExprFunc) {
ctx.funcStore[info.Name()], _ = info.(*funcInfo) ctx.funcStore[info.Name()], _ = info.(*funcInfo)
} }
func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam) (exprFunc ExprFunc, err error) { func (ctx *SimpleStore) RegisterFunc(name string, functor kern.Functor, returnType string, params []kern.ExprFuncParam) (exprFunc kern.ExprFunc, err error) {
var info *funcInfo var info *funcInfo
if info, err = newFuncInfo(name, functor, returnType, params); err == nil { if info, err = newFuncInfo(name, functor, returnType, params); err == nil {
ctx.funcStore[name] = info ctx.funcStore[name] = info
@ -186,7 +234,7 @@ func (ctx *SimpleStore) DeleteFunc(funcName string) {
} }
func (ctx *SimpleStore) Call(name string, args map[string]any) (result any, err error) { func (ctx *SimpleStore) Call(name string, args map[string]any) (result any, err error) {
if info, exists := GetLocalFuncInfo(ctx, name); exists { if info, exists := ctx.GetLocalFuncInfo(name); exists {
functor := info.Functor() functor := info.Functor()
result, err = functor.InvokeNamed(ctx, name, args) result, err = functor.InvokeNamed(ctx, name, args)
} else { } else {

14
t_bool_test.go
View File

@ -7,6 +7,8 @@ package expr
import ( import (
"errors" "errors"
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestBool(t *testing.T) { func TestBool(t *testing.T) {
@ -19,10 +21,10 @@ func TestBool(t *testing.T) {
/* 5 */ {`not "true"`, false, nil}, /* 5 */ {`not "true"`, false, nil},
/* 6 */ {`not "false"`, false, nil}, /* 6 */ {`not "false"`, false, nil},
/* 7 */ {`not ""`, true, nil}, /* 7 */ {`not ""`, true, nil},
/* 8 */ {`not []`, nil, errors.New(`[1:4] prefix/postfix operator "NOT" do not support operand '[]' [list]`)}, /* 8 */ {`not []`, nil, errors.New(`[1:4] prefix/postfix operator "NOT" does not support operand '[]' [list]`)},
/* 9 */ {`true and false`, false, nil}, /* 9 */ {`true and false`, false, nil},
/* 10 */ {`true and []`, nil, errors.New(`[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`)}, /* 10 */ {`true and []`, nil, errors.New(`[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`)},
/* 11 */ {`[] and false`, nil, errors.New(`got list as left operand type of 'AND' operator, it must be bool`)}, /* 11 */ {`[] and false`, nil, errors.New(`[1:7] operator "AND" does not support operand '[]' [list] on its left side`)},
/* 12 */ {`true or false`, true, nil}, /* 12 */ {`true or false`, true, nil},
/* 13 */ {`true or []`, true, nil}, /* 13 */ {`true or []`, true, nil},
/* 14 */ {`[] or false`, nil, errors.New(`got list as left operand type of 'OR' operator, it must be bool`)}, /* 14 */ {`[] or false`, nil, errors.New(`got list as left operand type of 'OR' operator, it must be bool`)},
@ -32,7 +34,7 @@ func TestBool(t *testing.T) {
// t.Setenv("EXPR_PATH", ".") // t.Setenv("EXPR_PATH", ".")
// runTestSuiteSpec(t, section, inputs, 15) // runTestSuiteSpec(t, section, inputs, 13)
runTestSuite(t, section, inputs) runTestSuite(t, section, inputs)
} }
@ -46,7 +48,7 @@ func TestBoolNoShortcut(t *testing.T) {
/* 5 */ {`not "true"`, false, nil}, /* 5 */ {`not "true"`, false, nil},
/* 6 */ {`not "false"`, false, nil}, /* 6 */ {`not "false"`, false, nil},
/* 7 */ {`not ""`, true, nil}, /* 7 */ {`not ""`, true, nil},
/* 8 */ {`not []`, nil, `[1:4] prefix/postfix operator "NOT" do not support operand '[]' [list]`}, /* 8 */ {`not []`, nil, `[1:4] prefix/postfix operator "NOT" does not support operand '[]' [list]`},
/* 9 */ {`true and false`, false, nil}, /* 9 */ {`true and false`, false, nil},
/* 10 */ {`true and []`, nil, `[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`}, /* 10 */ {`true and []`, nil, `[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`},
/* 11 */ {`[] and false`, nil, `[1:7] left operand '[]' [list] and right operand 'false' [bool] are not compatible with operator "AND"`}, /* 11 */ {`[] and false`, nil, `[1:7] left operand '[]' [list] and right operand 'false' [bool] are not compatible with operator "AND"`},
@ -58,10 +60,10 @@ func TestBoolNoShortcut(t *testing.T) {
// t.Setenv("EXPR_PATH", ".") // t.Setenv("EXPR_PATH", ".")
ctx := NewSimpleStore() ctx := NewSimpleStore()
current := SetCtrl(ctx, ControlBoolShortcut, false) current := kern.SetCtrl(ctx, kern.ControlBoolShortcut, false)
// runCtxTestSuiteSpec(t, ctx, section, inputs, 1) // runCtxTestSuiteSpec(t, ctx, section, inputs, 1)
runCtxTestSuite(t, ctx, section, inputs) runCtxTestSuite(t, ctx, section, inputs)
SetCtrl(ctx, ControlBoolShortcut, current) kern.SetCtrl(ctx, kern.ControlBoolShortcut, current)
} }

14
t_builtin-base_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestFuncBase(t *testing.T) { func TestFuncBase(t *testing.T) {
@ -33,10 +35,10 @@ func TestFuncBase(t *testing.T) {
/* 19 */ {`isFract(1:3)`, true, nil}, /* 19 */ {`isFract(1:3)`, true, nil},
/* 20 */ {`isFract(3:1)`, false, nil}, /* 20 */ {`isFract(3:1)`, false, nil},
/* 21 */ {`isRational(3:1)`, true, nil}, /* 21 */ {`isRational(3:1)`, true, nil},
/* 22 */ {`fract("2.2(3)")`, newFraction(67, 30), nil}, /* 22 */ {`fract("2.2(3)")`, kern.NewFraction(67, 30), nil},
/* 23 */ {`fract("1.21(3)")`, newFraction(91, 75), nil}, /* 23 */ {`fract("1.21(3)")`, kern.NewFraction(91, 75), nil},
/* 24 */ {`fract(1.21(3))`, newFraction(91, 75), nil}, /* 24 */ {`fract(1.21(3))`, kern.NewFraction(91, 75), nil},
/* 25 */ {`fract(1.21)`, newFraction(121, 100), nil}, /* 25 */ {`fract(1.21)`, kern.NewFraction(121, 100), nil},
/* 26 */ {`dec(2)`, float64(2), nil}, /* 26 */ {`dec(2)`, float64(2), nil},
/* 27 */ {`dec(2.0)`, float64(2), nil}, /* 27 */ {`dec(2.0)`, float64(2), nil},
/* 28 */ {`dec("2.0")`, float64(2), nil}, /* 28 */ {`dec("2.0")`, float64(2), nil},
@ -45,8 +47,8 @@ func TestFuncBase(t *testing.T) {
/* 31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`}, /* 31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
/* 32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`}, /* 32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`},
/* 33 */ {`isBool(false)`, true, nil}, /* 33 */ {`isBool(false)`, true, nil},
/* 34 */ {`fract(1:2)`, newFraction(1, 2), nil}, /* 34 */ {`fract(1:2)`, kern.NewFraction(1, 2), nil},
/* 35 */ {`fract(12,2)`, newFraction(6, 1), nil}, /* 35 */ {`fract(12,2)`, kern.NewFraction(6, 1), nil},
/* 36 */ {`bool(2)`, true, nil}, /* 36 */ {`bool(2)`, true, nil},
/* 37 */ {`bool(1:2)`, true, nil}, /* 37 */ {`bool(1:2)`, true, nil},
/* 38 */ {`bool(1.0)`, true, nil}, /* 38 */ {`bool(1.0)`, true, nil},

6
t_builtin-fmt_test.go
View File

@ -9,6 +9,8 @@ import (
"bytes" "bytes"
"fmt" "fmt"
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestFuncFmt(t *testing.T) { func TestFuncFmt(t *testing.T) {
@ -37,11 +39,11 @@ func TestFmt(t *testing.T) {
var b bytes.Buffer var b bytes.Buffer
ctx := NewSimpleStore() ctx := NewSimpleStore()
currentStdout := SetCtrl(ctx, ControlStdout, &b) currentStdout := kern.SetCtrl(ctx, kern.ControlStdout, &b)
runCtxTestSuite(t, ctx, section, inputs) runCtxTestSuite(t, ctx, section, inputs)
SetCtrl(ctx, ControlStdout, currentStdout) kern.SetCtrl(ctx, kern.ControlStdout, currentStdout)
if b.String() != text+"\n" { if b.String() != text+"\n" {
t.Errorf("println(): Got: %q, Want: %q", b.String(), text+"\n") t.Errorf("println(): Got: %q, Want: %q", b.String(), text+"\n")
} }

4
t_builtin-string_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestFuncString(t *testing.T) { func TestFuncString(t *testing.T) {
@ -28,7 +30,7 @@ func TestFuncString(t *testing.T) {
/* 14 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "789")`, true, nil}, /* 14 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "789")`, true, nil},
/* 15 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "0125")`, false, nil}, /* 15 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "0125")`, false, nil},
/* 16 */ {`builtin "string"; strEndsWith("0123456789")`, nil, `strEndsWith(): too few params -- expected 2 or more, got 1`}, /* 16 */ {`builtin "string"; strEndsWith("0123456789")`, nil, `strEndsWith(): too few params -- expected 2 or more, got 1`},
/* 17 */ {`builtin "string"; strSplit("one-two-three", "-")`, newListA("one", "two", "three"), nil}, /* 17 */ {`builtin "string"; strSplit("one-two-three", "-")`, kern.NewListA("one", "two", "three"), nil},
/* 18 */ {`builtin "string"; strJoin("-", [1, "two", "three"])`, nil, `strJoin(): expected string, got integer (1)`}, /* 18 */ {`builtin "string"; strJoin("-", [1, "two", "three"])`, nil, `strJoin(): expected string, got integer (1)`},
/* 19 */ {`builtin "string"; strJoin()`, nil, `strJoin(): too few params -- expected 1 or more, got 0`}, /* 19 */ {`builtin "string"; strJoin()`, nil, `strJoin(): too few params -- expected 1 or more, got 0`},
/* 20 */ {`builtin "string"; strUpper("StOp")`, "STOP", nil}, /* 20 */ {`builtin "string"; strUpper("StOp")`, "STOP", nil},

20
t_common_test.go
View File

@ -9,6 +9,8 @@ import (
"reflect" "reflect"
"strings" "strings"
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
type inputType struct { type inputType struct {
@ -17,7 +19,7 @@ type inputType struct {
wantErr any wantErr any
} }
func runCtxTestSuiteSpec(t *testing.T, ctx ExprContext, section string, inputs []inputType, spec ...int) { func runCtxTestSuiteSpec(t *testing.T, ctx kern.ExprContext, section string, inputs []inputType, spec ...int) {
succeeded := 0 succeeded := 0
failed := 0 failed := 0
for _, count := range spec { for _, count := range spec {
@ -36,7 +38,7 @@ func runTestSuiteSpec(t *testing.T, section string, inputs []inputType, spec ...
runCtxTestSuiteSpec(t, nil, section, inputs, spec...) runCtxTestSuiteSpec(t, nil, section, inputs, spec...)
} }
func runCtxTestSuite(t *testing.T, ctx ExprContext, section string, inputs []inputType) { func runCtxTestSuite(t *testing.T, ctx kern.ExprContext, section string, inputs []inputType) {
succeeded := 0 succeeded := 0
failed := 0 failed := 0
@ -68,8 +70,8 @@ func getWantedError(input *inputType) error {
return wantErr return wantErr
} }
func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, count int) (good bool) { func doTest(t *testing.T, ctx kern.ExprContext, section string, input *inputType, count int) (good bool) {
var expr Expr var ast Expr
var gotResult any var gotResult any
var gotErr error var gotErr error
var eq, eqDone bool var eq, eqDone bool
@ -87,13 +89,13 @@ func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, cou
scanner := NewScanner(r, DefaultTranslations()) scanner := NewScanner(r, DefaultTranslations())
good = true good = true
if expr, gotErr = parser.Parse(scanner); gotErr == nil { if ast, gotErr = parser.Parse(scanner); gotErr == nil {
gotResult, gotErr = expr.Eval(ctx) gotResult, gotErr = ast.Eval(ctx)
} }
if input.wantResult != nil && gotResult != nil { if input.wantResult != nil && gotResult != nil {
if ls1, ok := input.wantResult.(*ListType); ok { if ls1, ok := input.wantResult.(*kern.ListType); ok {
if ls2, ok := gotResult.(*ListType); ok { if ls2, ok := gotResult.(*kern.ListType); ok {
eq = ls1.Equals(*ls2) eq = ls1.Equals(*ls2)
eqDone = true eqDone = true
} }
@ -105,7 +107,7 @@ func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, cou
} }
if !eq /*gotResult != input.wantResult*/ { if !eq /*gotResult != input.wantResult*/ {
t.Errorf("%d: `%s` -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, TypeName(gotResult), input.wantResult, TypeName(input.wantResult)) t.Errorf("%d: `%s` -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, kern.TypeName(gotResult), input.wantResult, kern.TypeName(input.wantResult))
good = false good = false
} }

60
t_context_test.go Normal file
View File

@ -0,0 +1,60 @@
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.
// t_context_test.go
package expr
import (
"testing"
)
func TestCtrlSet(t *testing.T) {
section := "Context"
varName := "_test_var"
varValue := "test-value"
prevValue := "test-prev"
ctx := NewSimpleStore()
GlobalCtrlSet(ctx, varName, prevValue)
if v := GlobalCtrlSet(ctx, varName, varValue); v != nil {
if s, ok := v.(string); ok {
if s != prevValue {
t.Errorf(`%s -- CtrlSet(%q, %q) should have returned %q, got %q`, section, varName, varValue, varValue, s)
}
} else {
t.Errorf(`%s -- CtrlSet(%q, %q) should have returned a string, got %v [%T]`, section, varName, varValue, v, v)
}
} else {
t.Errorf(`%s -- CtrlSet(%q, %q) should have returned a value, got nil`, section, varName, varValue)
}
}
func TestCtrlGet(t *testing.T) {
section := "Context"
varName := "_test_var"
varValue := "test-value"
ctx := NewSimpleStore()
GlobalCtrlSet(ctx, varName, varValue)
if v := GlobalCtrlGet(ctx, varName); v != nil {
if s, ok := v.(string); ok {
if s != "test-value" {
t.Errorf(`%s -- CtrlGet(%q) should have returned %q, got %q`, section, varName, varValue, s)
}
} else {
t.Errorf(`%s -- CtrlGet(%q) should have returned a string, got %v [%T]`, section, varName, v, v)
}
} else {
t.Errorf(`%s -- CtrlGet(%q) should have returned a value, got nil`, section, varName)
}
}
func TestCtrlGetNotDefined(t *testing.T) {
section := "Context"
varName := "_test_var"
ctx := NewSimpleStore()
if v := GlobalCtrlGet(ctx, varName); v != nil {
t.Errorf(`%s -- CtrlGet(%q) should have returned nil, got %v`, section, varName, v)
}
}

14
t_dict_test.go
View File

@ -9,6 +9,8 @@ import (
"strings" "strings"
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestDictParser(t *testing.T) { func TestDictParser(t *testing.T) {
@ -51,7 +53,7 @@ func TestDictParser(t *testing.T) {
var gotResult any var gotResult any
var gotErr error var gotErr error
ctx := NewSimpleStore() ctx := NewSimpleStoreWithoutGlobalContext()
ctx.SetVar("var1", int64(123)) ctx.SetVar("var1", int64(123))
ctx.SetVar("var2", "abc") ctx.SetVar("var2", "abc")
ImportMathFuncs(ctx) ImportMathFuncs(ctx)
@ -118,11 +120,11 @@ func TestDictToStringMultiLine(t *testing.T) {
want := `{ want := `{
"first": 1 "first": 1
}` }`
args := map[any]*term{ args := map[any]any{
"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)), "first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
} }
dict := newDict(args) dict := kern.NewDict(args)
got := dict.ToString(MultiLine) got := dict.ToString(kern.MultiLine)
// fmt.Printf("got=%q\n", got) // fmt.Printf("got=%q\n", got)
if good = got == want; !good { if good = got == want; !good {
@ -140,10 +142,10 @@ func TestDictToString(t *testing.T) {
var good bool var good bool
section := "dict-ToString-SL" section := "dict-ToString-SL"
want := `{"first": 1}` want := `{"first": 1}`
args := map[any]*term{ args := map[any]any{
"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)), "first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
} }
dict := newDict(args) dict := kern.NewDict(args)
got := dict.ToString(0) got := dict.ToString(0)
// fmt.Printf("got=%q\n", got) // fmt.Printf("got=%q\n", got)

4
t_expr_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestExpr(t *testing.T) { func TestExpr(t *testing.T) {
@ -29,7 +31,7 @@ func TestExpr(t *testing.T) {
/* 15 */ {`a=3; a*=2)+1; a`, nil, `[1:11] unexpected token ")"`}, /* 15 */ {`a=3; a*=2)+1; a`, nil, `[1:11] unexpected token ")"`},
/* 16 */ {`v=[2]; a=1; v[a-=1]=5; v[0]`, int64(5), nil}, /* 16 */ {`v=[2]; a=1; v[a-=1]=5; v[0]`, int64(5), nil},
/* 17 */ {`true ? {"a"} :: {"b"}`, "a", nil}, /* 17 */ {`true ? {"a"} :: {"b"}`, "a", nil},
/* 18 */ {`$$`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil}, /* 18 */ {`$$`, kern.NewDict(map[any]any{"variables": kern.NewDict(nil), "functions": kern.NewDict(nil)}), nil},
///* 19 */ {`$$global`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil}, ///* 19 */ {`$$global`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil},
/* 19 */ {` /* 19 */ {`
ds={ ds={

44
t_fractions_test.go
View File

@ -6,43 +6,45 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestFractionsParser(t *testing.T) { func TestFractionsParser(t *testing.T) {
section := "Fraction" section := "Fraction"
inputs := []inputType{ inputs := []inputType{
/* 1 */ {`1:2`, newFraction(1, 2), nil}, /* 1 */ {`1:2`, kern.NewFraction(1, 2), nil},
/* 2 */ {`1:2 + 1`, newFraction(3, 2), nil}, /* 2 */ {`1:2 + 1`, kern.NewFraction(3, 2), nil},
/* 3 */ {`1:2 - 1`, newFraction(-1, 2), nil}, /* 3 */ {`1:2 - 1`, kern.NewFraction(-1, 2), nil},
/* 4 */ {`1:2 * 1`, newFraction(1, 2), nil}, /* 4 */ {`1:2 * 1`, kern.NewFraction(1, 2), nil},
/* 5 */ {`1:2 * 2:3`, newFraction(2, 6), nil}, /* 5 */ {`1:2 * 2:3`, kern.NewFraction(2, 6), nil},
/* 6 */ {`1:2 / 2:3`, newFraction(3, 4), nil}, /* 6 */ {`1:2 / 2:3`, kern.NewFraction(3, 4), nil},
/* 7 */ {`1:"5"`, nil, `denominator must be integer, got string (5)`}, /* 7 */ {`1:"5"`, nil, `denominator must be integer, got string (5)`},
/* 8 */ {`"1":5`, nil, `numerator must be integer, got string (1)`}, /* 8 */ {`"1":5`, nil, `numerator must be integer, got string (1)`},
/* 9 */ {`1:+5`, newFraction(1, 5), nil}, /* 9 */ {`1:+5`, kern.NewFraction(1, 5), nil},
/* 10 */ {`1:(-2)`, newFraction(-1, 2), nil}, /* 10 */ {`1:(-2)`, kern.NewFraction(-1, 2), nil},
/* 11 */ {`builtin "math.arith"; add(1:2, 2:3)`, newFraction(7, 6), nil}, /* 11 */ {`builtin "math.arith"; add(1:2, 2:3)`, kern.NewFraction(7, 6), nil},
/* 12 */ {`builtin "math.arith"; add(1:2, 1.0, 2)`, float64(3.5), nil}, /* 12 */ {`builtin "math.arith"; add(1:2, 1.0, 2)`, float64(3.5), nil},
/* 13 */ {`builtin "math.arith"; mul(1:2, 2:3)`, newFraction(2, 6), nil}, /* 13 */ {`builtin "math.arith"; mul(1:2, 2:3)`, kern.NewFraction(2, 6), nil},
/* 14 */ {`builtin "math.arith"; mul(1:2, 1.0, 2)`, float64(1.0), nil}, /* 14 */ {`builtin "math.arith"; mul(1:2, 1.0, 2)`, float64(1.0), nil},
/* 15 */ {`1:0`, nil, `[1:3] division by zero`}, /* 15 */ {`1:0`, nil, `[1:3] division by zero`},
/* 16 */ {`fract(-0.5)`, newFraction(-1, 2), nil}, /* 16 */ {`fract(-0.5)`, kern.NewFraction(-1, 2), nil},
/* 17 */ {`fract("")`, (*FractionType)(nil), `bad syntax`}, /* 17 */ {`fract("")`, (*kern.FractionType)(nil), `bad syntax`},
/* 18 */ {`fract("-1")`, newFraction(-1, 1), nil}, /* 18 */ {`fract("-1")`, kern.NewFraction(-1, 1), nil},
/* 19 */ {`fract("+1")`, newFraction(1, 1), nil}, /* 19 */ {`fract("+1")`, kern.NewFraction(1, 1), nil},
/* 20 */ {`fract("1a")`, (*FractionType)(nil), `strconv.ParseInt: parsing "1a": invalid syntax`}, /* 20 */ {`fract("1a")`, (*kern.FractionType)(nil), `strconv.ParseInt: parsing "1a": invalid syntax`},
/* 21 */ {`fract(1,0)`, nil, `fract(): division by zero`}, /* 21 */ {`fract(1,0)`, nil, `fract(): division by zero`},
/* 22 */ {`string(1:2)`, "1:2", nil}, /* 22 */ {`string(1:2)`, "1:2", nil},
/* 23 */ {`1+1:2+0.5`, float64(2), nil}, /* 23 */ {`1+1:2+0.5`, float64(2), nil},
/* 24 */ {`1:(2-2)`, nil, `[1:3] division by zero`}, /* 24 */ {`1:(2-2)`, nil, `[1:3] division by zero`},
/* 25 */ {`[0,1][1-1]:1`, newFraction(0, 1), nil}, /* 25 */ {`[0,1][1-1]:1`, kern.NewFraction(0, 1), nil},
} }
// runTestSuiteSpec(t, section, inputs, 25) // runTestSuiteSpec(t, section, inputs, 25)
runTestSuite(t, section, inputs) runTestSuite(t, section, inputs)
} }
func TestFractionToStringSimple(t *testing.T) { func TestFractionToStringSimple(t *testing.T) {
source := newFraction(1, 2) source := kern.NewFraction(1, 2)
want := "1:2" want := "1:2"
got := source.ToString(0) got := source.ToString(0)
if got != want { if got != want {
@ -51,18 +53,18 @@ func TestFractionToStringSimple(t *testing.T) {
} }
func TestFractionToStringMultiline(t *testing.T) { func TestFractionToStringMultiline(t *testing.T) {
source := newFraction(1, 2) source := kern.NewFraction(1, 2)
want := "1\n-\n2" want := "1\n-\n2"
got := source.ToString(MultiLine) got := source.ToString(kern.MultiLine)
if got != want { if got != want {
t.Errorf(`(1,2) -> result = %v [%T], want = %v [%T]`, got, got, want, want) t.Errorf(`(1,2) -> result = %v [%T], want = %v [%T]`, got, got, want, want)
} }
} }
func TestToStringMultilineTty(t *testing.T) { func TestToStringMultilineTty(t *testing.T) {
source := newFraction(-1, 2) source := kern.NewFraction(-1, 2)
want := "\x1b[4m-1\x1b[0m\n 2" want := "\x1b[4m-1\x1b[0m\n 2"
got := source.ToString(MultiLine | TTY) got := source.ToString(kern.MultiLine | kern.TTY)
if got != want { if got != want {
t.Errorf(`(1,2) -> result = %#v [%T], want = %#v [%T]`, got, got, want, want) t.Errorf(`(1,2) -> result = %#v [%T], want = %#v [%T]`, got, got, want, want)
} }

18
t_funcs_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestFuncs(t *testing.T) { func TestFuncs(t *testing.T) {
@ -47,12 +49,12 @@ func TestFuncs(t *testing.T) {
runTestSuite(t, section, inputs) runTestSuite(t, section, inputs)
} }
func dummy(ctx ExprContext, name string, args map[string]any) (result any, err error) { func dummy(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
return return
} }
func TestFunctionToStringSimple(t *testing.T) { func TestFunctionToStringSimple(t *testing.T) {
source := NewGolangFunctor(dummy) source := kern.NewGolangFunctor(dummy)
want := "func(){}" want := "func(){}"
got := source.ToString(0) got := source.ToString(0)
if got != want { if got != want {
@ -61,8 +63,8 @@ func TestFunctionToStringSimple(t *testing.T) {
} }
func TestFunctionGetFunc(t *testing.T) { func TestFunctionGetFunc(t *testing.T) {
source := NewGolangFunctor(dummy) source := kern.NewGolangFunctor(dummy)
want := ExprFunc(nil) want := kern.ExprFunc(nil)
got := source.GetFunc() got := source.GetFunc()
if got != want { if got != want {
t.Errorf(`(func() -> result = %v [%T], want = %v [%T]`, got, got, want, want) t.Errorf(`(func() -> result = %v [%T], want = %v [%T]`, got, got, want, want)
@ -76,16 +78,16 @@ func TestGoFunction(t *testing.T) {
/* 2 */ {`myName("Peppino")`, "Peppino", nil}, /* 2 */ {`myName("Peppino")`, "Peppino", nil},
} }
myName := func(ctx ExprContext, name string, args map[string]any) (result any, err error) { myName := func(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
var ok bool var ok bool
if result, ok = args["name"].(string); !ok { if result, ok = args["name"].(string); !ok {
err = ErrWrongParamType(name, "name", TypeString, args["name"]) err = kern.ErrWrongParamType(name, "name", kern.TypeString, args["name"])
} }
return return
} }
ctx := NewSimpleStore() ctx := NewSimpleStoreWithoutGlobalContext()
ctx.RegisterFunc("myName", NewGolangFunctor(myName), TypeString, []ExprFuncParam{ ctx.RegisterFunc("myName", kern.NewGolangFunctor(myName), kern.TypeString, []kern.ExprFuncParam{
NewFuncParamFlagDef("name", PfOptional|PfDefault, "Celestino Amoroso"), NewFuncParamFlagDef("name", PfOptional|PfDefault, "Celestino Amoroso"),
}) })

2
t_helpers_test.go
View File

@ -53,7 +53,7 @@ import (
func TestEvalString(t *testing.T) { func TestEvalString(t *testing.T) {
ctx := NewSimpleStore() ctx := NewSimpleStoreWithoutGlobalContext()
ctx.SetVar("a", uint8(1)) ctx.SetVar("a", uint8(1))
ctx.SetVar("b", int8(2)) ctx.SetVar("b", int8(2))
ctx.SetVar("f", 2.0) ctx.SetVar("f", 2.0)

21
t_iter-list_test.go
View File

@ -7,10 +7,12 @@ package expr
import ( import (
"io" "io"
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestNewListIterator(t *testing.T) { func TestNewListIterator(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
if item, err := it.Next(); err != nil { if item, err := it.Next(); err != nil {
t.Errorf("error: %v", err) t.Errorf("error: %v", err)
@ -22,7 +24,7 @@ func TestNewListIterator(t *testing.T) {
} }
func TestNewListIterator2(t *testing.T) { func TestNewListIterator2(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{3, 1, -1}) it := NewListIterator(list, []any{3, 1, -1})
if item, err := it.Next(); err != nil { if item, err := it.Next(); err != nil {
t.Errorf("error: %v", err) t.Errorf("error: %v", err)
@ -34,7 +36,7 @@ func TestNewListIterator2(t *testing.T) {
} }
func TestNewListIterator3(t *testing.T) { func TestNewListIterator3(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, -1, 1}) it := NewListIterator(list, []any{1, -1, 1})
if item, err := it.Next(); err != nil { if item, err := it.Next(); err != nil {
t.Errorf("error: %v", err) t.Errorf("error: %v", err)
@ -90,7 +92,7 @@ func TestNewIterList5(t *testing.T) {
} }
func TestNewIterList6(t *testing.T) { func TestNewIterList6(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it1, _ := NewIterator(list) it1, _ := NewIterator(list)
it, _ := NewIterator(it1) it, _ := NewIterator(it1)
if item, err := it.Next(); err != nil { if item, err := it.Next(); err != nil {
@ -101,6 +103,7 @@ func TestNewIterList6(t *testing.T) {
t.Logf("Next: %v", item) t.Logf("Next: %v", item)
} }
} }
func TestNewString(t *testing.T) { func TestNewString(t *testing.T) {
list := "123" list := "123"
it, _ := NewIterator(list) it, _ := NewIterator(list)
@ -111,7 +114,7 @@ func TestNewString(t *testing.T) {
func TestHasOperation(t *testing.T) { func TestHasOperation(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
hasOp := it.HasOperation("reset") hasOp := it.HasOperation("reset")
if !hasOp { if !hasOp {
@ -121,7 +124,7 @@ func TestHasOperation(t *testing.T) {
func TestCallOperationReset(t *testing.T) { func TestCallOperationReset(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
if v, err := it.CallOperation("reset", nil); err != nil { if v, err := it.CallOperation("reset", nil); err != nil {
t.Errorf("Error on CallOperation(reset): %v", err) t.Errorf("Error on CallOperation(reset): %v", err)
@ -132,7 +135,7 @@ func TestCallOperationReset(t *testing.T) {
func TestCallOperationIndex(t *testing.T) { func TestCallOperationIndex(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
if v, err := it.CallOperation("index", nil); err != nil { if v, err := it.CallOperation("index", nil); err != nil {
t.Errorf("Error on CallOperation(index): %v", err) t.Errorf("Error on CallOperation(index): %v", err)
@ -143,7 +146,7 @@ func TestCallOperationIndex(t *testing.T) {
func TestCallOperationCount(t *testing.T) { func TestCallOperationCount(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
if v, err := it.CallOperation("count", nil); err != nil { if v, err := it.CallOperation("count", nil); err != nil {
t.Errorf("Error on CallOperation(count): %v", err) t.Errorf("Error on CallOperation(count): %v", err)
@ -154,7 +157,7 @@ func TestCallOperationCount(t *testing.T) {
func TestCallOperationUnknown(t *testing.T) { func TestCallOperationUnknown(t *testing.T) {
list := newListA("a", "b", "c", "d") list := kern.NewListA("a", "b", "c", "d")
it := NewListIterator(list, []any{1, 3, 1}) it := NewListIterator(list, []any{1, 3, 1})
if v, err := it.CallOperation("unknown", nil); err == nil { if v, err := it.CallOperation("unknown", nil); err == nil {
t.Errorf("Expected error on CallOperation(unknown), got %v", v) t.Errorf("Expected error on CallOperation(unknown), got %v", v)

10
t_iterator_test.go
View File

@ -4,7 +4,11 @@
// t_iterator_test.go // t_iterator_test.go
package expr package expr
import "testing" import (
"testing"
"git.portale-stac.it/go-pkg/expr/kern"
)
func TestIteratorParser(t *testing.T) { func TestIteratorParser(t *testing.T) {
section := "Iterator" section := "Iterator"
@ -30,8 +34,8 @@ func TestIteratorParser(t *testing.T) {
/* 19 */ {`it=$({1:"one",2:"two",3:"three"}); it++`, int64(1), nil}, /* 19 */ {`it=$({1:"one",2:"two",3:"three"}); it++`, int64(1), nil},
/* 20 */ {`it=$({1:"one",2:"two",3:"three"}, "default", "value"); it++`, "one", nil}, /* 20 */ {`it=$({1:"one",2:"two",3:"three"}, "default", "value"); it++`, "one", nil},
/* 21 */ {`it=$({1:"one",2:"two",3:"three"}, "desc", "key"); it++`, int64(3), nil}, /* 21 */ {`it=$({1:"one",2:"two",3:"three"}, "desc", "key"); it++`, int64(3), nil},
/* 22 */ {`it=$({1:"one",2:"two",3:"three"}, "asc", "item"); it++`, NewList([]any{int64(1), "one"}), nil}, /* 22 */ {`it=$({1:"one",2:"two",3:"three"}, "asc", "item"); it++`, kern.NewList([]any{int64(1), "one"}), nil},
/* 23 */ {`builtin "os.file"; fileReadIterator("test-file.txt") map ${_index}`, NewList([]any{int64(0), int64(1)}), nil}, /* 23 */ {`builtin "os.file"; fileReadIterator("test-file.txt") map ${_index}`, kern.NewList([]any{int64(0), int64(1)}), nil},
/* 24 */ {`builtin "os.file"; #(fileReadIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil}, /* 24 */ {`builtin "os.file"; #(fileReadIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil},
/* 25 */ {`builtin "os.file"; #(fileReadIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil}, /* 25 */ {`builtin "os.file"; #(fileReadIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil},
} }

50
t_list_test.go
View File

@ -6,52 +6,54 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestListParser(t *testing.T) { func TestListParser(t *testing.T) {
section := "List" section := "List"
inputs := []inputType{ inputs := []inputType{
/* 1 */ {`[]`, newListA(), nil}, /* 1 */ {`[]`, kern.NewListA(), nil},
/* 2 */ {`[1,2,3]`, newListA(int64(1), int64(2), int64(3)), nil}, /* 2 */ {`[1,2,3]`, kern.NewListA(int64(1), int64(2), int64(3)), nil},
/* 3 */ {`[1,2,"hello"]`, newListA(int64(1), int64(2), "hello"), nil}, /* 3 */ {`[1,2,"hello"]`, kern.NewListA(int64(1), int64(2), "hello"), nil},
/* 4 */ {`[1+2, not true, "hello"]`, newListA(int64(3), false, "hello"), nil}, /* 4 */ {`[1+2, not true, "hello"]`, kern.NewListA(int64(3), false, "hello"), nil},
/* 5 */ {`[1,2]+[3]`, newListA(int64(1), int64(2), int64(3)), nil}, /* 5 */ {`[1,2]+[3]`, kern.NewListA(int64(1), int64(2), int64(3)), nil},
/* 6 */ {`[1,4,3,2]-[3]`, newListA(int64(1), int64(4), int64(2)), nil}, /* 6 */ {`[1,4,3,2]-[3]`, kern.NewListA(int64(1), int64(4), int64(2)), nil},
/* 7 */ {`add([1,4,3,2])`, int64(10), nil}, /* 7 */ {`builtin "math.arith"; add([1,4,3,2])`, int64(10), nil},
/* 8 */ {`add([1,[2,2],3,2])`, int64(10), nil}, /* 8 */ {`builtin "math.arith"; add([1,[2,2],3,2])`, int64(10), nil},
/* 9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil}, /* 9 */ {`builtin "math.arith"; mul([1,4,3.0,2])`, float64(24.0), nil},
/* 10 */ {`add([1,"hello"])`, nil, `add(): param nr 2 (2 in 1) has wrong type string, number expected`}, /* 10 */ {`builtin "math.arith"; add([1,"hello"])`, nil, `add(): param nr 2 (2 in 1) has wrong type string, number expected`},
/* 11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil}, /* 11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
/* 12 */ {`[1,2,3] <+ 2+2`, newListA(int64(1), int64(2), int64(3), int64(4)), nil}, /* 12 */ {`[1,2,3] <+ 2+2`, kern.NewListA(int64(1), int64(2), int64(3), int64(4)), nil},
/* 13 */ {`2-1 +> [2,3]`, newListA(int64(1), int64(2), int64(3)), nil}, /* 13 */ {`2-1 +> [2,3]`, kern.NewListA(int64(1), int64(2), int64(3)), nil},
/* 14 */ {`[1,2,3][1]`, int64(2), nil}, /* 14 */ {`[1,2,3][1]`, int64(2), nil},
/* 15 */ {`ls=[1,2,3] but ls[1]`, int64(2), nil}, /* 15 */ {`ls=[1,2,3] but ls[1]`, int64(2), nil},
/* 16 */ {`ls=[1,2,3] but ls[-1]`, int64(3), nil}, /* 16 */ {`ls=[1,2,3] but ls[-1]`, int64(3), nil},
/* 17 */ {`list=["one","two","three"]; list[10]`, nil, `[1:34] index 10 out of bounds`}, /* 17 */ {`list=["one","two","three"]; list[10]`, nil, `[1:34] index 10 out of bounds`},
/* 18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil}, /* 18 */ {`["a", "b", "c"]`, kern.NewListA("a", "b", "c"), nil},
/* 19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil}, /* 19 */ {`["a", "b", "c"]`, kern.NewList([]any{"a", "b", "c"}), nil},
/* 20 */ {`#["a", "b", "c"]`, int64(3), nil}, /* 20 */ {`#["a", "b", "c"]`, int64(3), nil},
/* 21 */ {`"b" in ["a", "b", "c"]`, true, nil}, /* 21 */ {`"b" in ["a", "b", "c"]`, true, nil},
/* 22 */ {`a=[1,2]; (a)<+3`, newListA(int64(1), int64(2), int64(3)), nil}, /* 22 */ {`a=[1,2]; (a)<+3`, kern.NewListA(int64(1), int64(2), int64(3)), nil},
/* 23 */ {`a=[1,2]; (a)<+3; a`, newListA(int64(1), int64(2)), nil}, /* 23 */ {`a=[1,2]; (a)<+3; a`, kern.NewListA(int64(1), int64(2)), nil},
/* 24 */ {`["a","b","c","d"][1]`, "b", nil}, /* 24 */ {`["a","b","c","d"][1]`, "b", nil},
/* 25 */ {`["a","b","c","d"][1,1]`, nil, `[1:19] one index only is allowed`}, /* 25 */ {`["a","b","c","d"][1,1]`, nil, `[1:19] one index only is allowed`},
/* 26 */ {`[0,1,2,3,4][:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil}, /* 26 */ {`[0,1,2,3,4][:]`, kern.NewListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
/* 27 */ {`["a", "b", "c"] <+ ;`, nil, `[1:18] infix operator "<+" requires two non-nil operands, got 1`}, /* 27 */ {`["a", "b", "c"] <+ ;`, nil, `[1:18] infix operator "<+" requires two non-nil operands, got 1`},
/* 28 */ {`2 << 3;`, int64(16), nil}, /* 28 */ {`2 << 3;`, int64(16), nil},
/* 29 */ {`but +> ["a", "b", "c"]`, nil, `[1:6] infix operator "+>" requires two non-nil operands, got 0`}, /* 29 */ {`but +> ["a", "b", "c"]`, nil, `[1:6] infix operator "+>" requires two non-nil operands, got 0`},
/* 30 */ {`2 >> 3;`, int64(0), nil}, /* 30 */ {`2 >> 3;`, int64(0), nil},
/* 31 */ {`a=[1,2]; a<+3`, newListA(int64(1), int64(2), int64(3)), nil}, /* 31 */ {`a=[1,2]; a<+3`, kern.NewListA(int64(1), int64(2), int64(3)), nil},
/* 32 */ {`a=[1,2]; 5+>a`, newListA(int64(5), int64(1), int64(2)), nil}, /* 32 */ {`a=[1,2]; 5+>a`, kern.NewListA(int64(5), int64(1), int64(2)), nil},
/* 33 */ {`L=[1,2]; L[0]=9; L`, newListA(int64(9), int64(2)), nil}, /* 33 */ {`L=[1,2]; L[0]=9; L`, kern.NewListA(int64(9), int64(2)), nil},
/* 34 */ {`L=[1,2]; L[5]=9; L`, nil, `index 5 out of bounds (0, 1)`}, /* 34 */ {`L=[1,2]; L[5]=9; L`, nil, `index 5 out of bounds (0, 1)`},
/* 35 */ {`L=[1,2]; L[]=9; L`, nil, `[1:12] index/key specification expected, got [] [list]`}, /* 35 */ {`L=[1,2]; L[]=9; L`, nil, `[1:12] index/key specification expected, got [] [list]`},
/* 36 */ {`L=[1,2]; L[nil]=9;`, nil, `[1:12] index/key is nil`}, /* 36 */ {`L=[1,2]; L[nil]=9;`, nil, `[1:12] index/key is nil`},
/* 37 */ {`[0,1,2,3,4][2:3]`, newListA(int64(2)), nil}, /* 37 */ {`[0,1,2,3,4][2:3]`, kern.NewListA(int64(2)), nil},
/* 38 */ {`[0,1,2,3,4][3:-1]`, newListA(int64(3)), nil}, /* 38 */ {`[0,1,2,3,4][3:-1]`, kern.NewListA(int64(3)), nil},
/* 30 */ {`[0,1,2,3,4][-3:-1]`, newListA(int64(2), int64(3)), nil}, /* 30 */ {`[0,1,2,3,4][-3:-1]`, kern.NewListA(int64(2), int64(3)), nil},
/* 40 */ {`[0,1,2,3,4][0:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil}, /* 40 */ {`[0,1,2,3,4][0:]`, kern.NewListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
} }
// t.Setenv("EXPR_PATH", ".") // t.Setenv("EXPR_PATH", ".")

12
t_operator_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestOperator(t *testing.T) { func TestOperator(t *testing.T) {
@ -27,17 +29,17 @@ func TestOperator(t *testing.T) {
/* 14 */ {`0x1X`, nil, `[1:5] two adjacent operators: "1" and "X"`}, /* 14 */ {`0x1X`, nil, `[1:5] two adjacent operators: "1" and "X"`},
/* 15 */ {`0o10`, int64(8), nil}, /* 15 */ {`0o10`, int64(8), nil},
/* 16 */ {`0b10`, int64(2), nil}, /* 16 */ {`0b10`, int64(2), nil},
/* 17 */ {`~true`, nil, `[1:2] prefix/postfix operator "~" do not support operand 'true' [bool]`}, /* 17 */ {`~true`, nil, `[1:2] prefix/postfix operator "~" does not support operand 'true' [bool]`},
/* 18 */ {`1^2`, int64(3), nil}, /* 18 */ {`1^2`, int64(3), nil},
/* 19 */ {`3^2`, int64(1), nil}, /* 19 */ {`3^2`, int64(1), nil},
/* 20 */ {`a=1; a^=2`, int64(3), nil}, /* 20 */ {`a=1; a^=2`, int64(3), nil},
/* 21 */ {`a=1; ++a`, int64(2), nil}, /* 21 */ {`a=1; ++a`, int64(2), nil},
/* 22 */ {`a=1; --a`, int64(0), nil}, /* 22 */ {`a=1; --a`, int64(0), nil},
/* 23 */ {`[1,2,3] map var("_")`, newList([]any{int64(1), int64(2), int64(3)}), nil}, /* 23 */ {`[1,2,3] map var("_")`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
/* 24 */ {`[1,2,3] map $_`, newList([]any{int64(1), int64(2), int64(3)}), nil}, /* 24 */ {`[1,2,3] map $_`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil},
/* 25 */ {`[1,2,3,4] filter ($_ % 2 == 0)`, newList([]any{int64(2), int64(4)}), nil}, /* 25 */ {`[1,2,3,4] filter ($_ % 2 == 0)`, kern.NewList([]any{int64(2), int64(4)}), nil},
/* 26 */ {`max=0; [2,3,1] digest max=(($_ > max) ? {$_} :: {max})`, int64(3), nil}, /* 26 */ {`max=0; [2,3,1] digest max=(($_ > max) ? {$_} :: {max})`, int64(3), nil},
/* 27 */ {`["a","b"] join ["x"]`, newList([]any{"a", "b", "x"}), nil}, /* 27 */ {`["a","b"] join ["x"]`, kern.NewList([]any{"a", "b", "x"}), nil},
/* 28 */ {`["a","b"] join ["x"-true]`, nil, `[1:21] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`}, /* 28 */ {`["a","b"] join ["x"-true]`, nil, `[1:21] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`},
} }

10
t_parser_test.go
View File

@ -6,6 +6,8 @@ package expr
import ( import (
"testing" "testing"
"git.portale-stac.it/go-pkg/expr/kern"
) )
func TestGeneralParser(t *testing.T) { func TestGeneralParser(t *testing.T) {
@ -49,7 +51,7 @@ func TestGeneralParser(t *testing.T) {
/* 35 */ {`var2="abc"; "uno_" + var2`, `uno_abc`, nil}, /* 35 */ {`var2="abc"; "uno_" + var2`, `uno_abc`, nil},
/* 36 */ {`0 || 0.0 && "hello"`, false, nil}, /* 36 */ {`0 || 0.0 && "hello"`, false, nil},
/* 37 */ {`"s" + true`, nil, `[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`}, /* 37 */ {`"s" + true`, nil, `[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`},
/* 38 */ {`+false`, nil, `[1:2] prefix/postfix operator "+" do not support operand 'false' [bool]`}, /* 38 */ {`+false`, nil, `[1:2] prefix/postfix operator "+" does not support operand 'false' [bool]`},
/* 39 */ {`false // very simple expression`, false, nil}, /* 39 */ {`false // very simple expression`, false, nil},
/* 40 */ {`1 + // Missing right operator`, nil, `[1:4] infix operator "+" requires two non-nil operands, got 1`}, /* 40 */ {`1 + // Missing right operator`, nil, `[1:4] infix operator "+" requires two non-nil operands, got 1`},
/* 41 */ {"", nil, nil}, /* 41 */ {"", nil, nil},
@ -130,11 +132,11 @@ func TestGeneralParser(t *testing.T) {
/* 116 */ {`null`, nil, `undefined variable or function "null"`}, /* 116 */ {`null`, nil, `undefined variable or function "null"`},
/* 117 */ {`{"key"}`, nil, "[1:8] expected `:`, got `}`"}, /* 117 */ {`{"key"}`, nil, "[1:8] expected `:`, got `}`"},
/* 118 */ {`{"key":}`, nil, "[1:9] expected `dictionary-value`, got `}`"}, /* 118 */ {`{"key":}`, nil, "[1:9] expected `dictionary-value`, got `}`"},
/* 119 */ {`{}`, &DictType{}, nil}, /* 119 */ {`{}`, &kern.DictType{}, nil},
/* 120 */ {`v=10; v++; v`, int64(11), nil}, /* 120 */ {`v=10; v++; v`, int64(11), nil},
/* 121 */ {`1.2()`, newFraction(6, 5), nil}, /* 121 */ {`1.2()`, kern.NewFraction(6, 5), nil},
/* 122 */ {`x="abc"; x ?! #x`, int64(3), nil}, /* 122 */ {`x="abc"; x ?! #x`, int64(3), nil},
/* 123 */ {`x ?! #x`, nil, `[1:7] prefix/postfix operator "#" do not support operand '<nil>' [nil]`}, /* 123 */ {`x ?! #x`, nil, `[1:7] prefix/postfix operator "#" does not support operand '<nil>' [nil]`},
/* 124 */ {`x ?! (x+1)`, nil, nil}, /* 124 */ {`x ?! (x+1)`, nil, nil},
/* 125 */ {`"abx" ?! (x+1)`, nil, `[1:6] left operand of "?!" must be a variable`}, /* 125 */ {`"abx" ?! (x+1)`, nil, `[1:6] left operand of "?!" must be a variable`},
/* 126 */ {`"abx" ?? "pqr"`, nil, `[1:6] left operand of "??" must be a variable`}, /* 126 */ {`"abx" ?? "pqr"`, nil, `[1:6] left operand of "??" must be a variable`},

Some files were not shown because too many files have changed in this diff Show More