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

the iterator operator now can be defined providing values or a list of values directly

Browse Source
This commit is contained in:
Celestino Amoroso 2024-05-04 00:51:15 +02:00
parent 04e71a1b3f
commit 16557d70de
2 changed files with 89 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
operand-iterator.go
View File

@ -12,7 +12,7 @@ import (
// -------- iterator term // -------- iterator term
func newIteratorTerm(tk *Token, dsTerm *term, args []*term) *term { func newDsIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
tk.Sym = SymIterator tk.Sym = SymIterator
children := make([]*term, 0, 1+len(args)) children := make([]*term, 0, 1+len(args))
@ -28,6 +28,18 @@ func newIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
} }
} }
func newIteratorTerm(tk *Token, args []*term) *term {
tk.Sym = SymIterator
return &term{
tk: *tk,
parent: nil,
children: args,
position: posLeaf,
priority: priValue,
evalFunc: evalIterator,
}
}
// -------- eval iterator // -------- eval iterator
func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) { func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
@ -43,59 +55,21 @@ func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
return return
} }
// func getDataSourceDict(ctx ExprContext, self *term) (ds map[string]Functor, err error) { func evalFirstChild(ctx ExprContext, self *term) (value any, err error) {
// var value any
// if len(self.children) < 1 || self.children[0] == nil {
// err = self.Errorf("missing the data-source parameter")
// return
// }
// if value, err = self.children[0].compute(ctx); err != nil {
// return
// }
// if dictAny, ok := value.(map[any]any); ok {
// ds = make(map[string]Functor)
// // required functions
// for _, k := range []string{currentName, nextName} {
// if item, exists := dictAny[k]; exists && item != nil {
// if functor, ok := item.(*funcDefFunctor); ok {
// ds[k] = functor
// }
// } else {
// err = fmt.Errorf("the data-source must provide a non-nil %q operator", k)
// return
// }
// }
// // Optional functions
// for _, k := range []string{initName, resetName, cleanName} {
// if item, exists := dictAny[k]; exists && item != nil {
// if functor, ok := item.(*funcDefFunctor); ok {
// ds[k] = functor
// }
// }
// }
// } else {
// err = self.Errorf("the first param (data-source) of an iterator must be a dict, not a %T", value)
// }
// return
// }
func getDataSourceDict(ctx ExprContext, self *term) (ds map[string]Functor, err error) {
var value any
if len(self.children) < 1 || self.children[0] == nil { if len(self.children) < 1 || self.children[0] == nil {
err = self.Errorf("missing the data-source parameter") err = self.Errorf("missing the data-source parameter")
return return
} }
if value, err = self.children[0].compute(ctx); err != nil { value, err = self.children[0].compute(ctx)
return return
} }
requiredFields := []string{currentName, nextName} func getDataSourceDict(ctx ExprContext, self *term, firstChildValue any) (ds map[string]Functor, err error) {
fieldsMask := 0b11 if dictAny, ok := firstChildValue.(map[any]any); ok {
foundFields := 0 requiredFields := []string{currentName, nextName}
if dictAny, ok := value.(map[any]any); ok { fieldsMask := 0b11
foundFields := 0
ds = make(map[string]Functor) ds = make(map[string]Functor)
for keyAny, item := range dictAny { for keyAny, item := range dictAny {
if key, ok := keyAny.(string); ok { if key, ok := keyAny.(string); ok {
@ -117,45 +91,73 @@ func getDataSourceDict(ctx ExprContext, self *term) (ds map[string]Functor, err
} }
err = fmt.Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", ")) err = fmt.Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", "))
} }
} else { // } else {
err = self.Errorf("the first param (data-source) of an iterator must be a dict, not a %T", value) // err = self.Errorf("the first param (data-source) of an iterator must be a dict, not a %T", value)
} }
return return
} }
func evalIterator(ctx ExprContext, self *term) (v any, err error) { func evalIterator(ctx ExprContext, self *term) (v any, err error) {
var firstChildValue any
var ds map[string]Functor var ds map[string]Functor
if ds, err = getDataSourceDict(ctx, self); err != nil { if firstChildValue, err = evalFirstChild(ctx, self); err != nil {
return return
} }
dc := newDataCursor(ctx, ds) if ds, err = getDataSourceDict(ctx, self, firstChildValue); err != nil {
// var it Iterator = dc return
// fmt.Println(it)
if initFunc, exists := ds[initName]; exists && initFunc != nil {
var args []any
if len(self.children) > 1 {
if args, err = evalTermArray(ctx, self.children[1:]); err != nil {
return
}
} else {
args = []any{}
}
initCtx := dc.ctx.Clone()
if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
return
}
exportObjects(dc.ctx, initCtx)
} }
dc.nextFunc, _ = ds[nextName] if ds != nil {
dc.currentFunc, _ = ds[currentName] dc := newDataCursor(ctx, ds)
dc.cleanFunc, _ = ds[cleanName] if initFunc, exists := ds[initName]; exists && initFunc != nil {
dc.resetFunc, _ = ds[resetName] var args []any
if len(self.children) > 1 {
if args, err = evalTermArray(ctx, self.children[1:]); err != nil {
return
}
} else {
args = []any{}
}
v = dc initCtx := dc.ctx.Clone()
if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
return
}
exportObjects(dc.ctx, initCtx)
}
dc.nextFunc, _ = ds[nextName]
dc.currentFunc, _ = ds[currentName]
dc.cleanFunc, _ = ds[cleanName]
dc.resetFunc, _ = ds[resetName]
v = dc
} else if list, ok := firstChildValue.(*ListType); ok {
v = NewListIterator(list)
} else {
var list *ListType
if list, err = evalChildren(ctx, self.children, firstChildValue); err == nil {
v = NewListIterator(list)
}
}
return
}
func evalChildren(ctx ExprContext, terms []*term, firstChildValue any) (list *ListType, err error) {
items := make(ListType, len(terms))
for i, tree := range terms {
var param any
if i == 0 && firstChildValue != nil {
param = firstChildValue
} else if param, err = tree.compute(ctx); err != nil {
break
}
items[i] = param
}
if err == nil {
list = &items
}
return return
} }

64
parser.go
View File

@ -58,42 +58,6 @@ func (self *parser) parseFuncCall(scanner *scanner, allowVarRef bool, tk *Token)
return return
} }
// func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
// // Example: "add = func(x,y) {x+y}
// var body *ast
// args := make([]*term, 0)
// tk := scanner.Next()
// for tk.Sym != SymClosedRound && tk.Sym != SymEos {
// if tk.Sym == SymIdentifier {
// t := newTerm(tk, nil)
// args = append(args, t)
// } else {
// err = tk.Errorf("invalid param %q, variable identifier expected", tk.source)
// break
// }
// tk = scanner.Next()
// }
// if err == nil && tk.Sym != SymClosedRound {
// err = tk.Errorf("unterminate function params list")
// }
// if err == nil {
// tk = scanner.Next()
// if tk.Sym == SymOpenBrace {
// body, err = self.parseGeneral(scanner, true, true, SymClosedBrace)
// }
// }
// if err == nil {
// // TODO Check arguments
// if scanner.Previous().Sym != SymClosedBrace {
// err = scanner.Previous().Errorf("not properly terminated function body")
// } else {
// tk = scanner.makeValueToken(SymExpression, "", body)
// tree = newFuncDefTerm(tk, args)
// }
// }
// return
// }
func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) { func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
// Example: "add = func(x,y) {x+y} // Example: "add = func(x,y) {x+y}
var body *ast var body *ast
@ -175,26 +139,26 @@ func (self *parser) parseList(scanner *scanner, allowVarRef bool) (subtree *term
} }
func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *term, err error) { func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
var ds *term // var ds *term
tk := scanner.Previous() tk := scanner.Previous()
args := make([]*term, 0) args := make([]*term, 0)
lastSym := SymUnknown lastSym := SymUnknown
dsExpected := true //dsExpected := true
itemExpected := false itemExpected := false
for lastSym != SymClosedRound && lastSym != SymEos { for lastSym != SymClosedRound && lastSym != SymEos {
var subTree *ast var subTree *ast
if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil { if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
if subTree.root != nil { if subTree.root != nil {
if dsExpected { /* if dsExpected {
if sym := subTree.root.symbol(); sym == SymDict || sym == SymIdentifier { if sym := subTree.root.symbol(); sym == SymDict || sym == SymIdentifier {
ds = subTree.root ds = subTree.root
} else { } else {
err = subTree.root.Errorf("data-source dictionary expected, got %q", subTree.root.source()) err = subTree.root.Errorf("data-source dictionary expected, got %q", subTree.root.source())
} }
dsExpected = false dsExpected = false
} else { } else {*/
args = append(args, subTree.root) args = append(args, subTree.root)
} // }
} else if itemExpected { } else if itemExpected {
prev := scanner.Previous() prev := scanner.Previous()
err = prev.Errorf("expected iterator argument, got %q", prev) err = prev.Errorf("expected iterator argument, got %q", prev)
@ -210,10 +174,8 @@ func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *t
// TODO Check arguments // TODO Check arguments
if lastSym != SymClosedRound { if lastSym != SymClosedRound {
err = scanner.Previous().Errorf("unterminate iterator param list") err = scanner.Previous().Errorf("unterminate iterator param list")
} else if ds != nil {
subtree = newIteratorTerm(tk, ds, args)
} else { } else {
tk.Errorf("missing data-source param") subtree = newIteratorTerm(tk, args)
} }
} }
return return