From 70cdb9367e39cf0e1f4911cc1c5e40a942c579f6 Mon Sep 17 00:00:00 2001 From: Celestino Amoroso Date: Sat, 13 Apr 2024 10:10:25 +0200 Subject: [PATCH] changed the structer of the selector components: now all case are a list value assigned as right operand of the selector operator --- operand-list.go | 41 +++++++++++++++++++++++++--- operator-selector.go | 63 ++++++++++++++++++++++++++++++++++++++++++-- parser.go | 27 ++++++++++++++----- parser_test.go | 1 + 4 files changed, 119 insertions(+), 13 deletions(-) diff --git a/operand-list.go b/operand-list.go index 6d83a01..fdfba3b 100644 --- a/operand-list.go +++ b/operand-list.go @@ -5,11 +5,15 @@ package expr // -------- list term +func newListTermA(args ...*term) *term { + return newListTerm(args) +} + func newListTerm(args []*term) *term { return &term{ - tk: *NewToken(0, 0, SymList, "[]"), + tk: *NewValueToken(0, 0, SymList, "[]", args), parent: nil, - children: args, + children: nil, position: posLeaf, priority: priValue, evalFunc: evalList, @@ -18,8 +22,9 @@ func newListTerm(args []*term) *term { // -------- list func func evalList(ctx ExprContext, self *term) (v any, err error) { - items := make([]any, len(self.children)) - for i, tree := range self.children { + list, _ := self.value().([]*term) + items := make([]any, len(list)) + for i, tree := range list { var param any if param, err = tree.compute(ctx); err != nil { break @@ -31,3 +36,31 @@ func evalList(ctx ExprContext, self *term) (v any, err error) { } return } + +// // -------- list term +// func newListTerm(args []*term) *term { +// return &term{ +// tk: *NewToken(0, 0, SymList, "[]"), +// parent: nil, +// children: args, +// position: posLeaf, +// priority: priValue, +// evalFunc: evalList, +// } +// } + +// // -------- list func +// func evalList(ctx ExprContext, self *term) (v any, err error) { +// items := make([]any, len(self.children)) +// for i, tree := range self.children { +// var param any +// if param, err = tree.compute(ctx); err != nil { +// break +// } +// items[i] = param +// } +// if err == nil { +// v = items +// } +// return +// } diff --git a/operator-selector.go b/operator-selector.go index 9cc864a..701be48 100644 --- a/operator-selector.go +++ b/operator-selector.go @@ -4,13 +4,71 @@ // operator-selector.go package expr +// //-------- export all term + +// func newSelectorTerm(tk *Token) (inst *term) { +// return &term{ +// tk: *tk, +// children: make([]*term, 0, 3), +// position: posMultifix, +// priority: priSelector, +// evalFunc: evalSelector, +// } +// } + +// func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (selectedValue any, err error) { +// caseData, _ := caseSel.(*selectorCase) +// if caseData.filterList == nil { +// selectedValue, err = caseData.caseExpr.eval(ctx, false) +// } else { +// filterList := caseData.filterList.children +// if len(filterList) == 0 && exprValue == int64(caseIndex) { +// selectedValue, err = caseData.caseExpr.eval(ctx, false) +// } else { +// var caseValue any +// for _, caseTerm := range filterList { +// if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue { +// selectedValue, err = caseData.caseExpr.eval(ctx, false) +// break +// } +// } +// } +// } +// return +// } + +// func evalSelector(ctx ExprContext, self *term) (v any, err error) { +// var exprValue any +// // var caseList []*term + +// if err = self.checkOperands(); err != nil { +// return +// } +// exprTerm := self.children[0] +// if exprValue, err = exprTerm.compute(ctx); err != nil { +// return +// } + +// caseList := self.children[1:] +// for i, caseTerm := range caseList { +// caseSel := caseTerm.value() +// if v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || v != nil { +// break +// } +// } +// if err == nil && v == nil { +// err = exprTerm.tk.Errorf("no case catches the value (%v) of the selection expression", exprValue) +// } +// return +// } + //-------- export all term func newSelectorTerm(tk *Token) (inst *term) { return &term{ tk: *tk, children: make([]*term, 0, 3), - position: posMultifix, + position: posInfix, priority: priSelector, evalFunc: evalSelector, } @@ -49,7 +107,8 @@ func evalSelector(ctx ExprContext, self *term) (v any, err error) { return } - caseList := self.children[1:] + caseListTerm := self.children[1] + caseList, _ := caseListTerm.value().([]*term) for i, caseTerm := range caseList { caseSel := caseTerm.value() if v, err = isSelectorCase(ctx, exprValue, caseSel, i); err != nil || v != nil { diff --git a/parser.go b/parser.go index 2c4e498..329b6fe 100644 --- a/parser.go +++ b/parser.go @@ -154,6 +154,19 @@ func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaul return } +func addSelectorCase(selectorTerm, caseTerm *term) { + if len(selectorTerm.children) < 2 { + caseListTerm := newListTermA(caseTerm) + selectorTerm.children = append(selectorTerm.children, caseListTerm) + } else { + caseListTerm := selectorTerm.children[1] + caseList, _ := caseListTerm.value().([]*term) + caseList = append(caseList, caseTerm) + caseListTerm.tk.Value = caseList + } + caseTerm.parent = selectorTerm +} + func (self *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) { var caseTerm *term tk := scanner.makeToken(SymSelector, '?') @@ -162,8 +175,9 @@ func (self *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) } if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, false); err == nil { - selectorTerm.children = append(selectorTerm.children, caseTerm) - caseTerm.parent = selectorTerm + addSelectorCase(selectorTerm, caseTerm) + // selectorTerm.children = append(selectorTerm.children, caseTerm) + // caseTerm.parent = selectorTerm } return } @@ -246,9 +260,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef currentTerm, err = tree.addToken2(tk) } case SymQuestion: - /*if selectorTerm != nil { - err = tk.Errorf("nested selectors must be enclosed in parentheses") - } else*/if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == nil { + if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == nil { currentTerm = selectorTerm } case SymColon, SymDoubleColon: @@ -256,8 +268,9 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef if selectorTerm == nil { err = tk.Errorf("selector-case outside of a selector context") } else if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil { - selectorTerm.children = append(selectorTerm.children, caseTerm) - caseTerm.parent = selectorTerm + // selectorTerm.children = append(selectorTerm.children, caseTerm) + // caseTerm.parent = selectorTerm + addSelectorCase(selectorTerm, caseTerm) currentTerm = caseTerm if tk.Sym == SymDoubleColon { selectorTerm = nil diff --git a/parser_test.go b/parser_test.go index a71611c..1cb6937 100644 --- a/parser_test.go +++ b/parser_test.go @@ -155,6 +155,7 @@ func TestParser(t *testing.T) { /* 134 */ {`10 ? {"a"} : {"b"}`, nil, errors.New(`[1:3] no case catches the value (10) of the selection expression`)}, /* 135 */ {`10 ? {"a"} :: {"b"} : {"c"}`, nil, errors.New(`[1:22] selector-case outside of a selector context`)}, /* 136 */ {`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil}, + /* 137 */ {`2 + 1 ? {"a"} : {"b"} * 3`, "2bbb", nil}, } check_env_expr_path := 113