ast.go

@@ -10,6 +10,7 @@ import (
 
 type Expr interface {
 	Eval(ctx ExprContext) (result any, err error)
+	eval(ctx ExprContext, preset bool) (result any, err error)
 	String() string
 }
 
@@ -105,10 +106,16 @@ func (self *ast) Finish() {
 }
 
 func (self *ast) Eval(ctx ExprContext) (result any, err error) {
+	return self.eval(ctx, true)
+}
+
+func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 	self.Finish()
 
 	if self.root != nil {
-		// initDefaultVars(ctx)
+		if preset {
+			initDefaultVars(ctx)
+		}
 		if self.forest != nil {
 			for _, root := range self.forest {
 				if result, err = root.compute(ctx); err == nil {

common-type-names.go

@@ -5,16 +5,14 @@
 package expr
 
 const (
-	TypeAny      = "any"
+	typeAny      = "any"
-	TypeBoolean  = "boolean"
+	typeBoolean  = "boolean"
-	TypeFloat    = "float"
+	typeFloat    = "float"
-	TypeFraction = "fraction"
+	typeFraction = "fraction"
-	TypeHandle   = "handle"
+	typeHandle   = "handle"
-	TypeInt      = "integer"
+	typeInt      = "integer"
-	TypeItem     = "item"
+	typeItem     = "item"
-	TypeNumber   = "number"
+	typeNumber   = "number"
-	TypePair     = "pair"
+	typePair     = "pair"
-	TypeString   = "string"
+	typeString   = "string"
-	TypeListOf = "list-of-"
-	TypeListOfStrings = "list-of-strings"
 )

context-helpers.go

@@ -22,11 +22,13 @@ func exportFunc(ctx ExprContext, name string, info ExprFunc) {
 	if name[0] == '@' {
 		name = name[1:]
 	}
+	// ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
+	// ctx.RegisterFuncInfo(name, info)
 	ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
 }
 
 func exportObjects(destCtx, sourceCtx ExprContext) {
-	exportAll := CtrlIsEnabled(sourceCtx, control_export_all)
+	exportAll := isEnabled(sourceCtx, control_export_all)
 	// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
 	// Export variables
 	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return exportAll || name[0] == '@' }) {

context.go

@@ -16,7 +16,6 @@ type Functor interface {
 type ExprFuncParam interface {
 	Name() string
 	Type() string
-	IsDefault() bool
 	IsOptional() bool
 	IsRepeat() bool
 	DefaultValue() any
@@ -37,8 +36,6 @@ type ExprFunc interface {
 type ExprContext interface {
 	Clone() ExprContext
 	Merge(ctx ExprContext)
-	SetParent(ctx ExprContext)
-	GetParent() (ctx ExprContext)
 	GetVar(varName string) (value any, exists bool)
 	SetVar(varName string, value any)
 	UnsafeSetVar(varName string, value any)

control.go

@@ -4,13 +4,13 @@
 // control.go
 package expr
 
+import "strings"
+
 // Preset control variables
 const (
-	ControlPreset        = "_preset"
 	ControlLastResult   = "last"
 	ControlBoolShortcut = "_bool_shortcut"
-	ControlSearchPath    = "_search_path"
+	ControlImportPath   = "_import_path"
-	ControlParentContext = "_parent_context"
 )
 
 // Other control variables
@@ -20,14 +20,43 @@ const (
 
 // Initial values
 const (
-	init_search_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
+	init_import_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
 )
 
 func initDefaultVars(ctx ExprContext) {
-	if _, exists := ctx.GetVar(ControlPreset); exists {
+	ctx.SetVar(ControlBoolShortcut, true)
+	ctx.SetVar(ControlImportPath, init_import_path)
+}
+
+func enable(ctx ExprContext, name string) {
+	if strings.HasPrefix(name, "_") {
+		ctx.SetVar(name, true)
+	} else {
+		ctx.SetVar("_"+name, true)
+	}
+}
+
+func disable(ctx ExprContext, name string) {
+	if strings.HasPrefix(name, "_") {
+		ctx.SetVar(name, false)
+	} else {
+		ctx.SetVar("_"+name, false)
+	}
+}
+
+func isEnabled(ctx ExprContext, name string) (status bool) {
+	if v, exists := ctx.GetVar(name); exists {
+		if b, ok := v.(bool); ok {
+			status = b
+		}
+	}
 	return
 }
-	ctx.SetVar(ControlPreset, true)
+
-	ctx.SetVar(ControlBoolShortcut, true)
+func getControlString(ctx ExprContext, name string) (s string, exists bool) {
-	ctx.SetVar(ControlSearchPath, init_search_path)
+	var v any
+	if v, exists = ctx.GetVar(name); exists {
+		s, exists = v.(string)
+	}
+	return
 }

fraction-type.go

@@ -212,7 +212,7 @@ func anyToFract(v any) (f *FractionType, err error) {
 		}
 	}
 	if f == nil {
-		err = errExpectedGot("fract", TypeFraction, v)
+		err = errExpectedGot("fract", typeFraction, v)
 	}
 	return
 }

func-base.go

@@ -159,25 +159,25 @@ func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err err
 
 func ImportBuiltinsFuncs(ctx ExprContext) {
 	anyParams := []ExprFuncParam{
-		NewFuncParam(paramValue),
+		newFuncParam(paramValue),
 	}
 
-	ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isNil", newGolangFunctor(isNilFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isInt", NewGolangFunctor(isIntFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isInt", newGolangFunctor(isIntFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isFloat", NewGolangFunctor(isFloatFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFloat", newGolangFunctor(isFloatFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isBool", NewGolangFunctor(isBoolFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isBool", newGolangFunctor(isBoolFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isString", NewGolangFunctor(isStringFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isString", newGolangFunctor(isStringFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isFract", NewGolangFunctor(isFractionFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFract", newGolangFunctor(isFractionFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isRational", NewGolangFunctor(isRationalFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isRational", newGolangFunctor(isRationalFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isList", NewGolangFunctor(isListFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isList", newGolangFunctor(isListFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("isDict", NewGolangFunctor(isDictionaryFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isDict", newGolangFunctor(isDictionaryFunc), typeBoolean, anyParams)
 
-	ctx.RegisterFunc("bool", NewGolangFunctor(boolFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("bool", newGolangFunctor(boolFunc), typeBoolean, anyParams)
-	ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams)
+	ctx.RegisterFunc("int", newGolangFunctor(intFunc), typeInt, anyParams)
-	ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams)
+	ctx.RegisterFunc("dec", newGolangFunctor(decFunc), typeFloat, anyParams)
-	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
+	ctx.RegisterFunc("fract", newGolangFunctor(fractFunc), typeFraction, []ExprFuncParam{
-		NewFuncParam(paramValue),
+		newFuncParam(paramValue),
-		NewFuncParamFlagDef("denominator", PfDefault, 1),
+		newFuncParamFlagDef("denominator", pfOptional, 1),
 	})
 }
 

func-fmt.go

@@ -23,11 +23,11 @@ func printLnFunc(ctx ExprContext, name string, args []any) (result any, err erro
 }
 
 func ImportFmtFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("print", NewGolangFunctor(printFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("print", newGolangFunctor(printFunc), typeInt, []ExprFuncParam{
-		NewFuncParamFlag(paramItem, PfRepeat),
+		newFuncParamFlag(paramItem, pfRepeat),
 	})
-	ctx.RegisterFunc("println", NewGolangFunctor(printLnFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("println", newGolangFunctor(printLnFunc), typeInt, []ExprFuncParam{
-		NewFuncParamFlag(paramItem, PfRepeat),
+		newFuncParamFlag(paramItem, pfRepeat),
 	})
 }
 

func-import.go

@@ -5,25 +5,100 @@
 package expr
 
 import (
+	"errors"
+	"fmt"
 	"io"
 	"os"
+	"path"
+	"path/filepath"
+	"strings"
 )
 
+const ENV_EXPR_PATH = "EXPR_PATH"
+
 func importFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	return importGeneral(ctx, name, args)
 }
 
 func importAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	CtrlEnable(ctx, control_export_all)
+	enable(ctx, control_export_all)
 	return importGeneral(ctx, name, args)
 }
 
 func importGeneral(ctx ExprContext, name string, args []any) (result any, err error) {
-	dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH)
+	var dirList []string
+
+	dirList = addEnvImportDirs(dirList)
+	dirList = addPresetImportDirs(ctx, dirList)
 	result, err = doImport(ctx, name, dirList, NewArrayIterator(args))
 	return
 }
 
+func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
+	if !(IsString(paramValue) /*|| isList(paramValue)*/) {
+		err = fmt.Errorf("%s(): param nr %d has wrong type %T, string expected", funcName, paramPos+1, paramValue)
+	}
+	return
+}
+
+func addEnvImportDirs(dirList []string) []string {
+	if dirSpec, exists := os.LookupEnv(ENV_EXPR_PATH); exists {
+		dirs := strings.Split(dirSpec, ":")
+		if dirList == nil {
+			dirList = dirs
+		} else {
+			dirList = append(dirList, dirs...)
+		}
+	}
+	return dirList
+}
+
+func addPresetImportDirs(ctx ExprContext, dirList []string) []string {
+	if dirSpec, exists := getControlString(ctx, ControlImportPath); exists {
+		dirs := strings.Split(dirSpec, ":")
+		if dirList == nil {
+			dirList = dirs
+		} else {
+			dirList = append(dirList, dirs...)
+		}
+	}
+	return dirList
+}
+
+func isFile(filePath string) bool {
+	info, err := os.Stat(filePath)
+	return (err == nil || errors.Is(err, os.ErrExist)) && info.Mode().IsRegular()
+}
+
+func searchAmongPath(filename string, dirList []string) (filePath string) {
+	for _, dir := range dirList {
+		if fullPath := path.Join(dir, filename); isFile(fullPath) {
+			filePath = fullPath
+			break
+		}
+	}
+	return
+}
+
+func isPathRelative(filePath string) bool {
+	unixPath := filepath.ToSlash(filePath)
+	return strings.HasPrefix(unixPath, "./") || strings.HasPrefix(unixPath, "../")
+}
+
+func makeFilepath(filename string, dirList []string) (filePath string, err error) {
+	if path.IsAbs(filename) || isPathRelative(filename) {
+		if isFile(filename) {
+			filePath = filename
+		}
+	} else {
+		filePath = searchAmongPath(filename, dirList)
+	}
+	if len(filePath) == 0 {
+		err = fmt.Errorf("source file %q not found", filename)
+	}
+	return
+}
+
 func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (result any, err error) {
 	var v any
 	var sourceFilepath string
@@ -40,9 +115,9 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 			defer file.Close()
 			var expr *ast
 			scanner := NewScanner(file, DefaultTranslations())
-			parser := NewParser()
+			parser := NewParser(ctx)
 			if expr, err = parser.parseGeneral(scanner, true, true); err == nil {
-				result, err = expr.Eval(ctx)
+				result, err = expr.eval(ctx, false)
 			}
 			if err != nil {
 				break
@@ -62,11 +137,11 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 }
 
 func ImportImportFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("import", NewGolangFunctor(importFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("import", newGolangFunctor(importFunc), typeAny, []ExprFuncParam{
-		NewFuncParamFlag(paramFilepath, PfRepeat),
+		newFuncParamFlag(paramFilepath, pfRepeat),
 	})
-	ctx.RegisterFunc("importAll", NewGolangFunctor(importAllFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("importAll", newGolangFunctor(importAllFunc), typeAny, []ExprFuncParam{
-		NewFuncParamFlag(paramFilepath, PfRepeat),
+		newFuncParamFlag(paramFilepath, pfRepeat),
 	})
 }
 

func-math.go

@@ -167,12 +167,12 @@ func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 }
 
 func ImportMathFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, typeNumber, []ExprFuncParam{
-		NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, int64(0)),
+		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(0)),
 	})
 
-	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, typeNumber, []ExprFuncParam{
-		NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, int64(1)),
+		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(1)),
 	})
 }
 

func-os.go

@@ -187,25 +187,25 @@ func readFileFunc(ctx ExprContext, name string, args []any) (result any, err err
 }
 
 func ImportOsFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("openFile", NewGolangFunctor(openFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("openFile", newGolangFunctor(openFileFunc), typeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		newFuncParam(paramFilepath),
 	})
-	ctx.RegisterFunc("appendFile", NewGolangFunctor(appendFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("appendFile", newGolangFunctor(appendFileFunc), typeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		newFuncParam(paramFilepath),
 	})
-	ctx.RegisterFunc("createFile", NewGolangFunctor(createFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("createFile", newGolangFunctor(createFileFunc), typeHandle, []ExprFuncParam{
-		NewFuncParam(paramFilepath),
+		newFuncParam(paramFilepath),
 	})
-	ctx.RegisterFunc("writeFile", NewGolangFunctor(writeFileFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("writeFile", newGolangFunctor(writeFileFunc), typeInt, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		newFuncParam(typeHandle),
-		NewFuncParamFlagDef(TypeItem, PfDefault|PfRepeat, ""),
+		newFuncParamFlagDef(typeItem, pfOptional|pfRepeat, ""),
 	})
-	ctx.RegisterFunc("readFile", NewGolangFunctor(readFileFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("readFile", newGolangFunctor(readFileFunc), typeString, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		newFuncParam(typeHandle),
-		NewFuncParamFlagDef("limitCh", PfDefault, "\n"),
+		newFuncParamFlagDef("limitCh", pfOptional, "\n"),
 	})
-	ctx.RegisterFunc("closeFile", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("closeFile", newGolangFunctor(closeFileFunc), typeBoolean, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		newFuncParam(typeHandle),
 	})
 }
 

func-string.go

@@ -21,7 +21,7 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
 		if s, ok := v.(string); ok {
 			sb.WriteString(s)
 		} else {
-			err = errExpectedGot(funcName, TypeString, v)
+			err = errExpectedGot(funcName, typeString, v)
 			return
 		}
 	}
@@ -51,7 +51,7 @@ func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 			result, err = doJoinStr(name, sep, NewArrayIterator(args[1:]))
 		}
 	} else {
-		err = errWrongParamType(name, paramSeparator, TypeString, args[0])
+		err = errWrongParamType(name, paramSeparator, typeString, args[0])
 	}
 	return
 }
@@ -63,7 +63,7 @@ func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, TypeString, args[0])
+		return nil, errWrongParamType(name, paramSource, typeString, args[0])
 	}
 
 	if start, err = toInt(args[1], name+"()"); err != nil {
@@ -91,7 +91,7 @@ func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, TypeString, args[0])
+		return nil, errWrongParamType(name, paramSource, typeString, args[0])
 	}
 	result = strings.TrimSpace(source)
 	return
@@ -104,7 +104,7 @@ func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, er
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -127,7 +127,7 @@ func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -150,7 +150,7 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, TypeString, args[0])
+		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}
 
 	if sep, ok = args[1].(string); !ok {
@@ -182,37 +182,37 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 
 // Import above functions in the context
 func ImportStringFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("joinStr", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("joinStr", newGolangFunctor(joinStrFunc), typeString, []ExprFuncParam{
-		NewFuncParam(paramSeparator),
+		newFuncParam(paramSeparator),
-		NewFuncParamFlag(paramItem, PfRepeat),
+		newFuncParamFlag(paramItem, pfRepeat),
 	})
 
-	ctx.RegisterFunc("subStr", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("subStr", newGolangFunctor(subStrFunc), typeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		newFuncParam(paramSource),
-		NewFuncParamFlagDef(paramStart, PfDefault, int64(0)),
+		newFuncParamFlagDef(paramStart, pfOptional, int64(0)),
-		NewFuncParamFlagDef(paramCount, PfDefault, int64(-1)),
+		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
 	})
 
-	ctx.RegisterFunc("splitStr", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("splitStr", newGolangFunctor(splitStrFunc), "list of "+typeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		newFuncParam(paramSource),
-		NewFuncParamFlagDef(paramSeparator, PfDefault, ""),
+		newFuncParamFlagDef(paramSeparator, pfOptional, ""),
-		NewFuncParamFlagDef(paramCount, PfDefault, int64(-1)),
+		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
 	})
 
-	ctx.RegisterFunc("trimStr", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("trimStr", newGolangFunctor(trimStrFunc), typeString, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		newFuncParam(paramSource),
 	})
 
-	ctx.RegisterFunc("startsWithStr", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("startsWithStr", newGolangFunctor(startsWithStrFunc), typeBoolean, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		newFuncParam(paramSource),
-		NewFuncParam(paramPrefix),
+		newFuncParam(paramPrefix),
-		NewFuncParamFlag("other "+paramPrefix, PfRepeat),
+		newFuncParamFlag("other "+paramPrefix, pfRepeat),
 	})
 
-	ctx.RegisterFunc("endsWithStr", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("endsWithStr", newGolangFunctor(endsWithStrFunc), typeBoolean, []ExprFuncParam{
-		NewFuncParam(paramSource),
+		newFuncParam(paramSource),
-		NewFuncParam(paramSuffix),
+		newFuncParam(paramSuffix),
-		NewFuncParamFlag("other "+paramSuffix, PfRepeat),
+		newFuncParamFlag("other "+paramSuffix, pfRepeat),
 	})
 }
 

function.go

@@ -48,7 +48,7 @@ type golangFunctor struct {
 	f FuncTemplate
 }
 
-func NewGolangFunctor(f FuncTemplate) *golangFunctor {
+func newGolangFunctor(f FuncTemplate) *golangFunctor {
 	return &golangFunctor{f: f}
 }
 
@@ -83,7 +83,7 @@ func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (re
 			if funcArg, ok := arg.(Functor); ok {
 				// ctx.RegisterFunc(p, functor, 0, -1)
 				paramSpecs := funcArg.GetParams()
-				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
+				ctx.RegisterFunc(p.Name(), funcArg, typeAny, paramSpecs)
 			} else {
 				ctx.UnsafeSetVar(p.Name(), arg)
 			}
@@ -91,7 +91,7 @@ func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (re
 			ctx.UnsafeSetVar(p.Name(), nil)
 		}
 	}
-	result, err = functor.expr.Eval(ctx)
+	result, err = functor.expr.eval(ctx, false)
 	return
 }
 
@@ -99,9 +99,8 @@ func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (re
 type paramFlags uint16
 
 const (
-	PfDefault paramFlags = 1 << iota
+	pfOptional paramFlags = 1 << iota
-	PfOptional
+	pfRepeat
-	PfRepeat
 )
 
 type funcParamInfo struct {
@@ -110,15 +109,15 @@ type funcParamInfo struct {
 	defaultValue any
 }
 
-func NewFuncParam(name string) ExprFuncParam {
+func newFuncParam(name string) ExprFuncParam {
 	return &funcParamInfo{name: name}
 }
 
-func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+func newFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
 	return &funcParamInfo{name: name, flags: flags}
 }
 
-func NewFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
+func newFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
 	return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
 }
 
@@ -127,19 +126,15 @@ func (param *funcParamInfo) Name() string {
 }
 
 func (param *funcParamInfo) Type() string {
-	return TypeAny
+	return "any"
-}
-
-func (param *funcParamInfo) IsDefault() bool {
-	return (param.flags & PfDefault) != 0
 }
 
 func (param *funcParamInfo) IsOptional() bool {
-	return (param.flags & PfOptional) != 0
+	return (param.flags & pfOptional) != 0
 }
 
 func (param *funcParamInfo) IsRepeat() bool {
-	return (param.flags & PfRepeat) != 0
+	return (param.flags & pfRepeat) != 0
 }
 
 func (param *funcParamInfo) DefaultValue() any {
@@ -164,7 +159,7 @@ func newFuncInfo(name string, functor Functor, returnType string, params []ExprF
 			if maxArgs == -1 {
 				return nil, fmt.Errorf("no more params can be specified after the ellipsis symbol: %q", p.Name())
 			}
-			if p.IsDefault() || p.IsOptional() {
+			if p.IsOptional() {
 				maxArgs++
 			} else if maxArgs == minArgs {
 				minArgs++
@@ -212,7 +207,7 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 			}
 			sb.WriteString(p.Name())
 
-			if p.IsDefault() {
+			if p.IsOptional() {
 				sb.WriteByte('=')
 				if s, ok := p.DefaultValue().(string); ok {
 					sb.WriteByte('"')
@@ -231,7 +226,7 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 	if len(info.returnType) > 0 {
 		sb.WriteString(info.returnType)
 	} else {
-		sb.WriteString(TypeAny)
+		sb.WriteString(typeAny)
 	}
 	sb.WriteString(" {<body>}")
 	return sb.String()

global-context.go

@@ -4,10 +4,7 @@
 // global-context.go
 package expr
 
-import (
+import "path/filepath"
-	"path/filepath"
-	"strings"
-)
 
 var globalCtx *SimpleStore
 
@@ -66,78 +63,7 @@ func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool, owne
 	return
 }
 
-func GlobalCtrlSet(name string, newValue any) (currentValue any) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
-	currentValue, _ = globalCtx.GetVar(name)
-
-	globalCtx.SetVar(name, newValue)
-	return currentValue
-}
-
-func GlobalCtrlGet(name string) (currentValue any) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
-	currentValue, _ = globalCtx.GetVar(name)
-	return currentValue
-}
-
-func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
-	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
-		currentStatus, _ = v.(bool)
-	}
-
-	ctx.SetVar(name, true)
-	return currentStatus
-}
-
-func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) {
-	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
-	}
-	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
-		currentStatus, _ = v.(bool)
-	}
-
-	ctx.SetVar(name, false)
-	return currentStatus
-}
-
-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 {
-		v, exists = globalCtx.GetVar(name)
-	}
-
-	if exists {
-		if b, ok := v.(bool); ok {
-			status = b
-		}
-	}
-	return
-}
-
-func getControlString(name string) (s string, exists bool) {
-	var v any
-	if v, exists = globalCtx.GetVar(name); exists {
-		s, exists = v.(string)
-	}
-	return
-}
-
 func init() {
 	globalCtx = NewSimpleStore()
-	initDefaultVars(globalCtx)
 	ImportBuiltinsFuncs(globalCtx)
 }

helpers.go

@@ -16,10 +16,10 @@ func EvalString(ctx ExprContext, source string) (result any, err error) {
 
 	r := strings.NewReader(source)
 	scanner := NewScanner(r, DefaultTranslations())
-	parser := NewParser()
+	parser := NewParser(ctx)
 
 	if tree, err = parser.Parse(scanner); err == nil {
-		result, err = tree.Eval(ctx)
+		result, err = tree.eval(ctx, true)
 	}
 	return
 }
@@ -38,10 +38,10 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 	for _, arg := range args {
 		if isFunc(arg.Value) {
 			if f, ok := arg.Value.(FuncTemplate); ok {
-				functor := NewGolangFunctor(f)
+				functor := newGolangFunctor(f)
 				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
-				ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{
+				ctx.RegisterFunc(arg.Name, functor, typeAny, []ExprFuncParam{
-					NewFuncParamFlagDef(paramValue, PfDefault|PfRepeat, 0),
+					newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, 0),
 				})
 			} else {
 				err = fmt.Errorf("invalid function specification: %q", arg.Name)
@@ -68,7 +68,7 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
 	var tree *ast
 	scanner := NewScanner(r, DefaultTranslations())
-	parser := NewParser()
+	parser := NewParser(ctx)
 
 	if tree, err = parser.Parse(scanner); err == nil {
 		result, err = tree.Eval(ctx)

import-utils.go

@@ -1,104 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// import-utils.go
-package expr
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-)
-
-const (
-	ENV_EXPR_SOURCE_PATH = "EXPR_PATH"
-	ENV_EXPR_PLUGIN_PATH = "EXPR_PLUGIN_PATH"
-)
-
-func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
-	if !(IsString(paramValue) /*|| isList(paramValue)*/) {
-		err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, typeName(paramValue))
-	}
-	return
-}
-
-func addSourceEnvImportDirs(varName string, dirList []string) []string {
-	return addEnvImportDirs(ENV_EXPR_SOURCE_PATH, dirList)
-}
-
-func addPluginEnvImportDirs(varName string, dirList []string) []string {
-	return addEnvImportDirs(ENV_EXPR_PLUGIN_PATH, dirList)
-}
-
-func addEnvImportDirs(envVarName string, dirList []string) []string {
-	if dirSpec, exists := os.LookupEnv(envVarName); exists {
-		dirs := strings.Split(dirSpec, ":")
-		if dirList == nil {
-			dirList = dirs
-		} else {
-			dirList = append(dirList, dirs...)
-		}
-	}
-	return dirList
-}
-
-func addSearchDirs(endingPath string, dirList []string) []string {
-	if dirSpec, exists := getControlString(ControlSearchPath); exists {
-		dirs := strings.Split(dirSpec, ":")
-		if dirList == nil {
-			dirList = dirs
-		} else {
-			if len(endingPath) > 0 {
-				for _, d := range dirs {
-					dirList = append(dirList, path.Join(d, endingPath))
-				}
-			} else {
-				dirList = append(dirList, dirs...)
-			}
-		}
-	}
-	return dirList
-}
-
-func buildSearchDirList(endingPath, envVarName string) (dirList []string) {
-	dirList = addEnvImportDirs(envVarName, dirList)
-	dirList = addSearchDirs(endingPath, dirList)
-	return
-}
-
-func isFile(filePath string) bool {
-	info, err := os.Stat(filePath)
-	return (err == nil || errors.Is(err, os.ErrExist)) && info.Mode().IsRegular()
-}
-
-func searchAmongPath(filename string, dirList []string) (filePath string) {
-	for _, dir := range dirList {
-		if fullPath := path.Join(dir, filename); isFile(fullPath) {
-			filePath = fullPath
-			break
-		}
-	}
-	return
-}
-
-func isPathRelative(filePath string) bool {
-	unixPath := filepath.ToSlash(filePath)
-	return strings.HasPrefix(unixPath, "./") || strings.HasPrefix(unixPath, "../")
-}
-
-func makeFilepath(filename string, dirList []string) (filePath string, err error) {
-	if path.IsAbs(filename) || isPathRelative(filename) {
-		if isFile(filename) {
-			filePath = filename
-		}
-	} else {
-		filePath = searchAmongPath(filename, dirList)
-	}
-	if len(filePath) == 0 {
-		err = fmt.Errorf("file %q not found", filename)
-	}
-	return
-}

list-type.go

@@ -20,10 +20,6 @@ func newListA(listAny ...any) (list *ListType) {
 }
 
 func newList(listAny []any) (list *ListType) {
-	return NewList(listAny)
-}
-
-func NewList(listAny []any) (list *ListType) {
 	if listAny != nil {
 		ls := make(ListType, len(listAny))
 		for i, item := range listAny {
@@ -34,23 +30,6 @@ func NewList(listAny []any) (list *ListType) {
 	return
 }
 
-func MakeList(length, capacity int) (list *ListType) {
-	if capacity < length {
-		capacity = length
-	}
-	ls := make(ListType, length, capacity)
-	list = &ls
-	return
-}
-
-func ListFromStrings(stringList []string) (list *ListType) {
-	list = MakeList(len(stringList), 0)
-	for i, s := range stringList {
-		(*list)[i] = s
-	}
-	return
-}
-
 func (ls *ListType) ToString(opt FmtOpt) (s string) {
 	var sb strings.Builder
 	sb.WriteByte('[')

operand-func.go

@@ -30,7 +30,7 @@ func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err erro
 		}
 		for i, p := range info.Params() {
 			if i >= passedCount {
-				if !p.IsDefault() {
+				if !p.IsOptional() {
 					break
 				}
 				*varParams = append(*varParams, p.DefaultValue())
@@ -50,7 +50,6 @@ func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err erro
 
 func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
 	ctx := cloneContext(parentCtx)
-	ctx.SetParent(parentCtx)
 	name, _ := self.tk.Value.(string)
 	params := make([]any, len(self.children), len(self.children)+5)
 	for i, tree := range self.children {
@@ -92,12 +91,12 @@ func evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
 			var defValue any
 			flags := paramFlags(0)
 			if len(param.children) > 0 {
-				flags |= PfDefault
+				flags |= pfOptional
 				if defValue, err = param.children[0].compute(ctx); err != nil {
 					return
 				}
 			}
-			info := NewFuncParamFlagDef(param.source(), flags, defValue)
+			info := newFuncParamFlagDef(param.source(), flags, defValue)
 			paramList = append(paramList, info)
 		}
 		v = newExprFunctor(expr, paramList, ctx)

operator-assign.go

@@ -81,7 +81,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
 			} else if funcDef, ok := functor.(*exprFunctor); ok {
 				paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
 
-				ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
+				ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
 			} else {
 				err = self.Errorf("unknown function %s()", rightChild.source())
 			}

operator-bool.go

@@ -48,7 +48,7 @@ func newAndTerm(tk *Token) (inst *term) {
 }
 
 func evalAnd(ctx ExprContext, self *term) (v any, err error) {
-	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+	if isEnabled(ctx, ControlBoolShortcut) {
 		v, err = evalAndWithShortcut(ctx, self)
 	} else {
 		v, err = evalAndWithoutShortcut(ctx, self)
@@ -117,7 +117,7 @@ func newOrTerm(tk *Token) (inst *term) {
 }
 
 func evalOr(ctx ExprContext, self *term) (v any, err error) {
-	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+	if isEnabled(ctx, ControlBoolShortcut) {
 		v, err = evalOrWithShortcut(ctx, self)
 	} else {
 		v, err = evalOrWithoutShortcut(ctx, self)

operator-builtin.go

@@ -37,11 +37,11 @@ func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
 				if ImportInContext(module) {
 					count++
 				} else {
-					err = self.Errorf("unknown builtin module %q", module)
+					err = self.Errorf("unknown module %q", module)
 					break
 				}
 			} else {
-				err = self.Errorf("expected string at item nr %d, got %s", it.Index()+1, typeName(moduleSpec))
+				err = self.Errorf("expected string at item nr %d, got %T", it.Index()+1, moduleSpec)
 				break
 			}
 		}

operator-coalesce.go

@@ -67,8 +67,8 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
 		if functor, ok := rightValue.(Functor); ok {
 			//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
-			ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{
+			ctx.RegisterFunc(leftTerm.source(), functor, typeAny, []ExprFuncParam{
-				NewFuncParamFlag(paramValue, PfDefault|PfRepeat),
+				newFuncParamFlag(paramValue, pfOptional|pfRepeat),
 			})
 		} else {
 			v = rightValue

operator-context.go

@@ -34,8 +34,7 @@ func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
 		if formatter, ok := sourceCtx.(Formatter); ok {
 			v = formatter.ToString(0)
 		} else {
-			// keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
+			keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
-			keys := sourceCtx.EnumVars(nil)
 			d := make(map[string]any)
 			for _, key := range keys {
 				d[key], _ = sourceCtx.GetVar(key)

operator-ctrl.go

@@ -17,7 +17,7 @@ func newExportAllTerm(tk *Token) (inst *term) {
 }
 
 func evalExportAll(ctx ExprContext, self *term) (v any, err error) {
-	CtrlEnable(ctx, control_export_all)
+	enable(ctx, control_export_all)
 	return
 }
 

operator-plugin.go

@@ -1,102 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-plugin.go
-package expr
-
-import (
-	"fmt"
-	"io"
-	"plugin"
-)
-
-//-------- plugin term
-
-func newPluginTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 1),
-		position: posPrefix,
-		priority: priSign,
-		evalFunc: evalPlugin,
-	}
-}
-
-func importPlugin(ctx ExprContext, dirList []string, name string) (err error) {
-	var filePath string
-	var p *plugin.Plugin
-	var sym plugin.Symbol
-	var moduleName string
-	var importFunc func(ctx ExprContext)
-	var ok bool
-
-	decoratedName := fmt.Sprintf("expr-%s-plugin.so", name)
-
-	if filePath, err = makeFilepath(decoratedName, dirList); err != nil {
-		return
-	}
-
-	if p, err = plugin.Open(filePath); err != nil {
-		return
-	}
-
-	if sym, err = p.Lookup("MODULE_NAME"); err != nil {
-		return
-	}
-
-	if moduleName = *sym.(*string); moduleName == "" {
-		err = fmt.Errorf("plugin %q does not provide a valid module name", decoratedName)
-		return
-	}
-
-	if sym, err = p.Lookup("ImportFuncs"); err != nil {
-		return
-	}
-
-	if importFunc, ok = sym.(func(ExprContext)); !ok {
-		err = fmt.Errorf("plugin %q does not provide a valid import function", decoratedName)
-		return
-	}
-
-	registerPlugin(moduleName, p)
-	importFunc(globalCtx)
-
-	return
-}
-
-func evalPlugin(ctx ExprContext, self *term) (v any, err error) {
-	var childValue any
-	var moduleSpec any
-
-	if childValue, err = self.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	dirList := buildSearchDirList("plugin", ENV_EXPR_PLUGIN_PATH)
-	count := 0
-	it := NewAnyIterator(childValue)
-	for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
-		if module, ok := moduleSpec.(string); ok {
-			if err = importPlugin(ctx, dirList, module); err != nil {
-				break
-			}
-			count++
-		} else {
-			err = self.Errorf("expected string as item nr %d, got %s", it.Index()+1, typeName(moduleSpec))
-			break
-		}
-	}
-	if err == io.EOF {
-		err = nil
-	}
-
-	if err == nil {
-		v = int64(count)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymKwPlugin, newPluginTerm)
-}

operator-range.go

@@ -12,7 +12,7 @@ type intPair struct {
 }
 
 func (p *intPair) TypeName() string {
-	return TypePair
+	return typePair
 }
 
 func (p *intPair) ToString(opt FmtOpt) string {

operator-selector.go

@@ -19,17 +19,17 @@ func newSelectorTerm(tk *Token) (inst *term) {
 func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
 	caseData, _ := caseSel.(*selectorCase)
 	if caseData.filterList == nil {
-		selectedValue, err = caseData.caseExpr.Eval(ctx)
+		selectedValue, err = caseData.caseExpr.eval(ctx, false)
 		match = true
 	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
-			selectedValue, err = caseData.caseExpr.Eval(ctx)
+			selectedValue, err = caseData.caseExpr.eval(ctx, false)
 			match = true
 		} else {
 			var caseValue any
 			for _, caseTerm := range filterList {
 				if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue {
-					selectedValue, err = caseData.caseExpr.Eval(ctx)
+					selectedValue, err = caseData.caseExpr.eval(ctx, false)
 					match = true
 					break
 				}

parser.go

@@ -11,10 +11,13 @@ import (
 //-------- parser
 
 type parser struct {
+	ctx ExprContext
 }
 
-func NewParser() (p *parser) {
+func NewParser(ctx ExprContext) (p *parser) {
-	p = &parser{}
+	p = &parser{
+		ctx: ctx,
+	}
 	return p
 }
 

plugins.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// plugin.go
-package expr
-
-import (
-	"fmt"
-	"plugin"
-)
-
-var pluginRegister map[string]*plugin.Plugin
-
-func registerPlugin(name string, p *plugin.Plugin) (err error) {
-	if pluginExists(name) {
-		err = fmt.Errorf("plugin %q already loaded", name)
-	} else {
-		pluginRegister[name] = p
-	}
-	return
-}
-
-func pluginExists(name string) (exists bool) {
-	_, exists = pluginRegister[name]
-	return
-}
-
-func init() {
-	pluginRegister = make(map[string]*plugin.Plugin)
-}

simple-store.go

@@ -11,7 +11,6 @@ import (
 )
 
 type SimpleStore struct {
-	parent    ExprContext
 	varStore  map[string]any
 	funcStore map[string]ExprFunc
 }
@@ -27,14 +26,6 @@ func NewSimpleStore() *SimpleStore {
 func filterRefName(name string) bool  { return name[0] != '@' }
 func filterPrivName(name string) bool { return name[0] != '_' }
 
-func (ctx *SimpleStore) SetParent(parentCtx ExprContext) {
-	ctx.parent = parentCtx
-}
-
-func (ctx *SimpleStore) GetParent() ExprContext {
-	return ctx.parent
-}
-
 func (ctx *SimpleStore) Clone() ExprContext {
 	return &SimpleStore{
 		varStore:  CloneFilteredMap(ctx.varStore, filterRefName),
@@ -54,7 +45,7 @@ func (ctx *SimpleStore) Merge(src ExprContext) {
 func varsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
 	sb.WriteString("vars: {\n")
 	first := true
-	for _, name := range ctx.EnumVars(nil) {
+	for _, name := range ctx.EnumVars(filterPrivName) {
 		if first {
 			first = false
 		} else {

symbol.go

@@ -101,7 +101,6 @@ const (
 	SymKwBut
 	SymKwFunc
 	SymKwBuiltin
-	SymKwPlugin
 	SymKwIn
 	SymKwInclude
 	SymKwNil
@@ -114,7 +113,6 @@ func init() {
 	keywords = map[string]Symbol{
 		"AND":     SymKwAnd,
 		"BUILTIN": SymKwBuiltin,
-		"PLUGIN":  SymKwPlugin,
 		"BUT":     SymKwBut,
 		"FUNC":    SymKwFunc,
 		"IN":      SymKwIn,

t_dict_test.go

@@ -49,7 +49,7 @@ func TestDictParser(t *testing.T) {
 		ctx.SetVar("var1", int64(123))
 		ctx.SetVar("var2", "abc")
 		ImportMathFuncs(ctx)
-		parser := NewParser()
+		parser := NewParser(ctx)
 
 		logTest(t, i+1, "Dict", input.source, input.wantResult, input.wantErr)
 

t_funcs_test.go

@@ -43,7 +43,7 @@ func dummy(ctx ExprContext, name string, args []any) (result any, err error) {
 }
 
 func TestFunctionToStringSimple(t *testing.T) {
-	source := NewGolangFunctor(dummy)
+	source := newGolangFunctor(dummy)
 	want := "func() {<body>}"
 	got := source.ToString(0)
 	if got != want {
@@ -52,7 +52,7 @@ func TestFunctionToStringSimple(t *testing.T) {
 }
 
 func TestFunctionGetFunc(t *testing.T) {
-	source := NewGolangFunctor(dummy)
+	source := newGolangFunctor(dummy)
 	want := ExprFunc(nil)
 	got := source.GetFunc()
 	if got != want {

t_iter-list_test.go

@@ -1,162 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_iter-list_test.go
-package expr
-
-import (
-	"io"
-	"testing"
-)
-
-func TestNewListIterator(t *testing.T) {
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "b" {
-		t.Errorf("expcted %q, got %q", "b", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewListIterator2(t *testing.T) {
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{3, 1, -1})
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "d" {
-		t.Errorf("expcted %q, got %q", "d", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewListIterator3(t *testing.T) {
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, -1, 1})
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "b" {
-		t.Errorf("expcted %q, got %q", "b", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewIterList2(t *testing.T) {
-	list := []any{"a", "b", "c", "d"}
-	it := NewArrayIterator(list)
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "a" {
-		t.Errorf("expcted %q, got %q", "a", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewIterList3(t *testing.T) {
-	list := []any{"a", "b", "c", "d"}
-	it := NewAnyIterator(list)
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "a" {
-		t.Errorf("expcted %q, got %q", "a", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewIterList4(t *testing.T) {
-	list := any(nil)
-	it := NewAnyIterator(list)
-	if _, err := it.Next(); err != io.EOF {
-		t.Errorf("error: %v", err)
-	}
-}
-
-func TestNewIterList5(t *testing.T) {
-	list := "123"
-	it := NewAnyIterator(list)
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "123" {
-		t.Errorf("expcted %q, got %q", "123", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-
-func TestNewIterList6(t *testing.T) {
-	list := newListA("a", "b", "c", "d")
-	it1 := NewAnyIterator(list)
-	it := NewAnyIterator(it1)
-	if item, err := it.Next(); err != nil {
-		t.Errorf("error: %v", err)
-	} else if item != "a" {
-		t.Errorf("expcted %q, got %q", "a", item)
-	} else {
-		t.Logf("Next: %v", item)
-	}
-}
-func TestNewString(t *testing.T) {
-	list := "123"
-	it := NewAnyIterator(list)
-	if s := it.String(); s != "$(#1)" {
-		t.Errorf("expected $(#1), got %s", s)
-	}
-}
-
-func TestHasOperation(t *testing.T) {
-
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	hasOp := it.HasOperation("reset")
-	if !hasOp {
-		t.Errorf("HasOperation(reset) must be true, got false")
-	}
-}
-
-func TestCallOperationReset(t *testing.T) {
-
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	if v, err := it.CallOperation("reset", nil); err != nil {
-		t.Errorf("Error on CallOperation(reset): %v", err)
-	} else {
-		t.Logf("Reset result: %v", v)
-	}
-}
-
-func TestCallOperationIndex(t *testing.T) {
-
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	if v, err := it.CallOperation("index", nil); err != nil {
-		t.Errorf("Error on CallOperation(index): %v", err)
-	} else {
-		t.Logf("Index result: %v", v)
-	}
-}
-
-func TestCallOperationCount(t *testing.T) {
-
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	if v, err := it.CallOperation("count", nil); err != nil {
-		t.Errorf("Error on CallOperation(count): %v", err)
-	} else {
-		t.Logf("Count result: %v", v)
-	}
-}
-
-func TestCallOperationUnknown(t *testing.T) {
-
-	list := newListA("a", "b", "c", "d")
-	it := NewListIterator(list, []any{1, 3, 1})
-	if v, err := it.CallOperation("unknown", nil); err == nil {
-		t.Errorf("Expected error on CallOperation(unknown), got %v", v)
-	}
-}

t_list_test.go

@@ -6,12 +6,19 @@ package expr
 
 import (
 	"errors"
+	"strings"
 	"testing"
 )
 
 func TestListParser(t *testing.T) {
 	section := "List"
 
+	/*	type inputType struct {
+			source     string
+			wantResult any
+			wantErr    error
+		}
+	*/
 	inputs := []inputType{
 		/*   1 */ {`[]`, newListA(), nil},
 		/*   2 */ {`[1,2,3]`, newListA(int64(1), int64(2), int64(3)), nil},
@@ -57,4 +64,74 @@ func TestListParser(t *testing.T) {
 
 	// parserTestSpec(t, section, inputs, 17)
 	parserTest(t, section, inputs)
+	return
+	succeeded := 0
+	failed := 0
+
+	// inputs1 := []inputType{
+	// 	/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
+	// }
+
+	for i, input := range inputs {
+		var expr *ast
+		var gotResult any
+		var gotErr error
+
+		ctx := NewSimpleStore()
+		ImportMathFuncs(ctx)
+		parser := NewParser(ctx)
+
+		logTest(t, i+1, "List", input.source, input.wantResult, input.wantErr)
+
+		r := strings.NewReader(input.source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		good := true
+		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
+			gotResult, gotErr = expr.Eval(ctx)
+		}
+
+		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
+			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+			good = false
+		}
+
+		if gotList, okGot := gotResult.([]any); okGot {
+			if wantList, okWant := input.wantResult.([]any); okWant {
+				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
+					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+					good = false
+				} else {
+					equal := len(gotList) == len(wantList)
+					if equal {
+						for i, gotItem := range gotList {
+							wantItem := wantList[i]
+							equal = gotItem == wantItem
+							if !equal {
+								break
+							}
+						}
+					}
+					if !equal {
+						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
+						good = false
+					}
+				}
+			}
+		}
+
+		if gotErr != input.wantErr {
+			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
+				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
+				good = false
+			}
+		}
+
+		if good {
+			succeeded++
+		} else {
+			failed++
+		}
+	}
+	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
 }

t_parser_test.go

@@ -188,7 +188,7 @@ func doTest(t *testing.T, section string, input *inputType, count int) (good boo
 	var gotErr error
 
 	ctx := NewSimpleStore()
-	parser := NewParser()
+	parser := NewParser(ctx)
 
 	logTest(t, count, section, input.source, input.wantResult, input.wantErr)