expr_test.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// expr_test.go
-package expr
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func TestExpr(t *testing.T) {
-	type inputType struct {
-		source     string
-		wantResult any
-		wantErr    error
-	}
-
-	inputs := []inputType{
-		/*   1 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
-	}
-
-	succeeded := 0
-	failed := 0
-
-	// inputs1 := []inputType{
-	// 	{`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
-	// }
-
-	for i, input := range inputs {
-		var expr Expr
-		var gotResult any
-		var gotErr error
-
-		ctx := NewSimpleFuncStore()
-		// ImportMathFuncs(ctx)
-		// ImportImportFunc(ctx)
-		parser := NewParser(ctx)
-
-		logTest(t, i+1, 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 != input.wantResult {
-			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.Log(fmt.Sprintf("test count: %d, succeeded count: %d, failed count: %d", len(inputs), succeeded, failed))
-}

graph.go

@@ -1,122 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// graph.go
-package expr
-
-import (
-	"fmt"
-	"strings"
-)
-
-func BuildGraph(root *term) (g string) {
-	//var sb strings.Builder
-	g = fmt.Sprintf("tree: %v", root)
-
-	r := NewReticle(root)
-	fmt.Println(r)
-	return
-}
-
-type NodeRef struct {
-	node  *term
-	pos   int
-	label string
-}
-
-type Level []*NodeRef
-
-type Reticle struct {
-	levels      []Level
-	left, right int
-	colsWidth   []int
-}
-
-func NewExprReticle(e Expr) *Reticle {
-	tree, _ := e.(*ast)
-	return NewReticle(tree.root)
-}
-
-func NewReticle(tree *term) *Reticle {
-	r := &Reticle{levels: make([]Level, 0)}
-	r.build(tree, 0, 0)
-	r.computeCharWidth()
-	return r
-}
-
-func (r *Reticle) computeCharWidth() {
-	numCol := r.right - r.left + 1
-	r.colsWidth = make([]int, numCol)
-	for _, level := range r.levels {
-		for _, ref := range level {
-			c := ref.pos - r.left
-			if v := ref.node.value(); v != nil {
-				ref.label = fmt.Sprintf("%v", v)
-			} else {
-				ref.label = ref.node.source()
-			}
-			r.colsWidth[c] = max(r.colsWidth[c], len(ref.label)+2) // +2 to make room for brakets
-		}
-	}
-}
-
-func (r *Reticle) build(node *term, depth, pos int) {
-	var level Level
-	if node == nil {
-		return
-	}
-	if len(r.levels) == depth {
-		level = make(Level, 0)
-		r.levels = append(r.levels, level)
-	} else {
-		level = r.levels[depth]
-	}
-	ref := &NodeRef{node: node, pos: pos}
-	level = append(level, ref)
-	if r.left > pos {
-		r.left = pos
-	}
-	if r.right < pos {
-		r.right = pos
-	}
-	if node.children != nil {
-		halfPos := len(node.children) / 2
-		childPos := pos - halfPos - 1
-		for _, child := range node.children {
-			childPos++
-			if childPos == pos && (len(node.children)&1) == 0 {
-				childPos++
-			}
-			r.build(child, depth+1, childPos)
-		}
-	}
-	r.levels[depth] = level
-}
-
-func (r *Reticle) nodeInLevel(level []*NodeRef, index int) (node *NodeRef) {
-	for _, ref := range level {
-		if ref.pos-r.left == index {
-			node = ref
-			break
-		}
-	}
-	return
-}
-
-func (r *Reticle) String() string {
-	var sb strings.Builder
-	for _, level := range r.levels {
-		for j, w := range r.colsWidth {
-			var label string
-			if ref := r.nodeInLevel(level, j); ref != nil {
-				s := "(" + ref.label + ")"
-				label = fmt.Sprintf("%[1]*s", -w, fmt.Sprintf("%[1]*s", (w+len(s))/2, s))
-			} else {
-				label = strings.Repeat(" ", w)
-			}
-			sb.WriteString(label)
-		}
-		sb.WriteByte('\n')
-	}
-	return sb.String()
-}

graph_test.go

@@ -1,33 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// graph_test.go
-package expr
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestGraph(t *testing.T) {
-	// tk0 := NewToken(0, 0, SymChangeSign, "-")
-	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
-	tk2 := NewToken(0, 0, SymPlus, "+")
-	tk3 := NewValueToken(0, 0, SymInteger, "200", 200)
-
-	tree := NewAst()
-	// tree.addToken(tk0)
-	tree.addToken(tk1)
-	tree.addToken(tk2)
-	tree.addToken(tk3)
-	tk4 := NewToken(0, 0, SymPlus, "-")
-	tk5 := NewValueToken(0, 0, SymInteger, "50", 50)
-	tree.addToken(tk4)
-	tree.addToken(tk5)
-
-	g := BuildGraph(tree.root)
-	fmt.Println(g)
-}

operand-list.go

@@ -5,15 +5,11 @@
 package expr
 
 // -------- list term
-func newListTermA(args ...*term) *term {
-	return newListTerm(args)
-}
-
 func newListTerm(args []*term) *term {
 	return &term{
-		tk:       *NewValueToken(0, 0, SymList, "[]", args),
+		tk:       *NewToken(0, 0, SymList, "[]"),
 		parent:   nil,
-		children: nil,
+		children: args,
 		position: posLeaf,
 		priority: priValue,
 		evalFunc: evalList,
@@ -22,9 +18,8 @@ func newListTerm(args []*term) *term {
 
 // -------- list func
 func evalList(ctx ExprContext, self *term) (v any, err error) {
-	list, _ := self.value().([]*term)
+	items := make([]any, len(self.children))
-	items := make([]any, len(list))
+	for i, tree := range self.children {
-	for i, tree := range list {
 		var param any
 		if param, err = tree.compute(ctx); err != nil {
 			break
@@ -36,31 +31,3 @@ 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
-// }

operator-selector.go

@@ -4,71 +4,13 @@
 // 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: posInfix,
+		position: posMultifix,
 		priority: priSelector,
 		evalFunc: evalSelector,
 	}
@@ -78,7 +20,8 @@ func isSelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (sel
 	caseData, _ := caseSel.(*selectorCase)
 	if caseData.filterList == nil {
 		selectedValue, err = caseData.caseExpr.eval(ctx, false)
-	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
+	} else {
+		filterList := caseData.filterList.children
 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
 			selectedValue, err = caseData.caseExpr.eval(ctx, false)
 		} else {
@@ -106,8 +49,7 @@ func evalSelector(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	caseListTerm := self.children[1]
+	caseList := 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 {

parser.go

@@ -154,19 +154,6 @@ 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, '?')
@@ -175,9 +162,8 @@ func (self *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool)
 	}
 
 	if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, false); err == nil {
-		addSelectorCase(selectorTerm, caseTerm)
+		selectorTerm.children = append(selectorTerm.children, caseTerm)
-		// selectorTerm.children = append(selectorTerm.children, caseTerm)
+		caseTerm.parent = selectorTerm
-		// caseTerm.parent = selectorTerm
 	}
 	return
 }
@@ -260,7 +246,9 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 				currentTerm, err = tree.addToken2(tk)
 			}
 		case SymQuestion:
-			if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == nil {
+			/*if selectorTerm != nil {
+				err = tk.Errorf("nested selectors must be enclosed in parentheses")
+			} else*/if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == nil {
 				currentTerm = selectorTerm
 			}
 		case SymColon, SymDoubleColon:
@@ -268,9 +256,8 @@ 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)
+				selectorTerm.children = append(selectorTerm.children, caseTerm)
-				// caseTerm.parent = selectorTerm
+				caseTerm.parent = selectorTerm
-				addSelectorCase(selectorTerm, caseTerm)
 				currentTerm = caseTerm
 				if tk.Sym == SymDoubleColon {
 					selectorTerm = nil

parser_test.go

@@ -155,7 +155,6 @@ 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
 
@@ -163,7 +162,7 @@ func TestParser(t *testing.T) {
 	failed := 0
 
 	// inputs1 := []inputType{
-	// 	{`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
+	// 	{`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
 	// }
 
 	for i, input := range inputs {