commented out some test code

expr_test.go

@@ -0,0 +1,70 @@
+// 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

@@ -0,0 +1,122 @@
+// 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

@@ -0,0 +1,33 @@
+// 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,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))
+	list, _ := self.value().([]*term)
-	for i, tree := range self.children {
+	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
+// }

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,
 	}
@@ -20,8 +78,7 @@ 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 {
+	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
-		filterList := caseData.filterList.children
 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
 			selectedValue, err = caseData.caseExpr.eval(ctx, false)
 		} else {
@@ -49,7 +106,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 {

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)
+		addSelectorCase(selectorTerm, caseTerm)
-		caseTerm.parent = selectorTerm
+		// 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 {
+			if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == 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:
@@ -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)
+				// 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,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
 
@@ -162,7 +163,7 @@ func TestParser(t *testing.T) {
 	failed := 0
 
 	// inputs1 := []inputType{
-	// 	{`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
+	// 	{`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
 	// }
 
 	for i, input := range inputs {