Compare commits
23 Commits
v0.3.0
...
ed6af6603a
| Author | SHA1 | Date | |
|---|---|---|---|
| ed6af6603a | |||
| 51e740d243 | |||
| 53dacd5332 | |||
| e297f2a1d3 | |||
| 70cdb9367e | |||
| efd9af9030 | |||
| b67d896415 | |||
| f03ae555fc | |||
| f36ae33acc | |||
| b9ea96f649 | |||
| 838ab9fd7e | |||
| ad6b4b872f | |||
| c75e6485e0 | |||
| 7b80f7f03b | |||
| 7f9fd570b2 | |||
| b17d2250a4 | |||
| dda10749d0 | |||
| 07ca84170e | |||
| 55e136e9bc | |||
| e493c40c7b | |||
| 95605232ab | |||
| 8f396a35de | |||
| bd323efedf |
+47
-8
@@ -68,7 +68,7 @@ import (
|
||||
|
||||
func main() {
|
||||
ctx := expr.NewSimpleVarStore()
|
||||
ctx.SetVar("var", int64(4))
|
||||
ctx.SetVar("var", 4)
|
||||
|
||||
source := `(3-1)*(10/5) == var`
|
||||
|
||||
@@ -101,7 +101,7 @@ import (
|
||||
|
||||
func main() {
|
||||
ctx := expr.NewSimpleVarStore()
|
||||
ctx.SetVar("var", int64(4))
|
||||
ctx.SetVar("var", 4)
|
||||
|
||||
source := `(3-1)*(10/5) == var`
|
||||
|
||||
@@ -121,14 +121,13 @@ package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"git.portale-stac.it/go-pkg/expr"
|
||||
)
|
||||
|
||||
func main() {
|
||||
source := `(3-1)*(10/5) == var`
|
||||
|
||||
if result, err := expr.EvalStringA(source, expr.Arg{"var", int64(4)}); err == nil {
|
||||
if result, err := expr.EvalStringA(source, expr.Arg{"var", 4}); err == nil {
|
||||
fmt.Printf("%q -> %v [%T]\n", source, result, result)
|
||||
} else {
|
||||
fmt.Println("Error calculating the expression:", err)
|
||||
@@ -136,6 +135,9 @@ func main() {
|
||||
}
|
||||
----
|
||||
|
||||
=== Concepts and terminology
|
||||
#TODO#
|
||||
|
||||
=== Data types
|
||||
_Expr_ supports numerical, string, relational, boolean expressions, and mixed-type lists.
|
||||
|
||||
@@ -237,10 +239,39 @@ Currently, boolean operations are evaluated using _short cut evaluation_. This m
|
||||
====
|
||||
|
||||
==== List
|
||||
#TODO: List operations#
|
||||
_Expr_ supports list of mixed-type values, also specified by normal expressions.
|
||||
|
||||
.List examples
|
||||
[source,go]
|
||||
----
|
||||
[1, 2, 3] // List of integers
|
||||
["one", "two", "three"] // List of strings
|
||||
["one", 2, false, 4.1] // List of mixed-types
|
||||
["one"+1, 2.0*(9-2)] // List of expressions
|
||||
[ [1,"one"], [2,"two"]] // List of lists
|
||||
----
|
||||
|
||||
|
||||
.List operators
|
||||
[cols="^2,^2,5,4"]
|
||||
|===
|
||||
| Symbol | Operation | Description | Examples
|
||||
|
||||
| [blue]`+` | _Join_ | Joins two lists | [blue]`[1,2] + [3]` _[ [1,2,3] ]_
|
||||
|
||||
| [blue]`-` | _Difference_ | Left list without elements in the right list | [blue]`[1,2,3] - [2]` _[ [1,3] ]_
|
||||
|===
|
||||
|
||||
=== Variables
|
||||
#TODO: variables#
|
||||
A variable is an identifier with an assigned value. Variables are stored in the object that implements the _ExprContext_ interface.
|
||||
|
||||
.Examples
|
||||
[source,go]
|
||||
----
|
||||
a=1
|
||||
x = 5.2 * (9-3)
|
||||
x = 1; y = 2*x
|
||||
----
|
||||
|
||||
=== Other operations
|
||||
|
||||
@@ -326,12 +357,15 @@ The table below shows all supported operators by decreasing priorities.
|
||||
.2+|*AND*| [blue]`and` | _Infix_ | _and_ | _boolean_ "and" _boolean_ -> _boolean_
|
||||
| [blue]`&&` | _Infix_ | _and_ | _boolean_ "&&" _boolean_ -> _boolean_
|
||||
.2+|*OR*| [blue]`or` | _Infix_ | _or_ | _boolean_ "or" _boolean_ -> _boolean_
|
||||
| [blue]`||` | _Infix_ | _or_ | _boolean_ "||" _boolean_ -> _boolean_
|
||||
| [blue]`\|\|` | _Infix_ | _or_ | _boolean_ "\|\|" _boolean_ -> _boolean_
|
||||
.1+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
|
||||
.1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
|
||||
|===
|
||||
|
||||
=== Functions
|
||||
Functions in _Expr_ are very similar to functions in many programming languages.
|
||||
|
||||
In _Expr_ functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator [blue]`@` it is possibile to export local definition to the calling context.
|
||||
|
||||
==== Function calls
|
||||
#TODO: function calls operations#
|
||||
@@ -339,8 +373,13 @@ The table below shows all supported operators by decreasing priorities.
|
||||
==== Function definitions
|
||||
#TODO: function definitions operations#
|
||||
|
||||
==== Builtins
|
||||
=== Builtins
|
||||
#TODO: builtins#
|
||||
|
||||
==== Builtin functions
|
||||
|
||||
==== [blue]_import()_
|
||||
[blue]_import([grey]#<source-file>#)_ loads the multi-expression contained in the specified source and returns its value.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
type Expr interface {
|
||||
Eval(ctx ExprContext) (result any, err error)
|
||||
eval(ctx ExprContext, preset bool) (result any, err error)
|
||||
String() string
|
||||
}
|
||||
|
||||
//-------- ast
|
||||
@@ -118,7 +119,7 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
|
||||
if self.forest != nil {
|
||||
for _, root := range self.forest {
|
||||
if result, err = root.compute(ctx); err == nil {
|
||||
ctx.SetVar(control_last_result, result)
|
||||
ctx.setVar(ControlLastResult, result)
|
||||
} else {
|
||||
//err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
|
||||
break
|
||||
|
||||
@@ -33,6 +33,7 @@ type ExprContext interface {
|
||||
Clone() ExprContext
|
||||
GetVar(varName string) (value any, exists bool)
|
||||
SetVar(varName string, value any)
|
||||
setVar(varName string, value any)
|
||||
EnumVars(func(name string) (accept bool)) (varNames []string)
|
||||
EnumFuncs(func(name string) (accept bool)) (funcNames []string)
|
||||
GetFuncInfo(name string) ExprFunc
|
||||
|
||||
+9
-6
@@ -1,13 +1,16 @@
|
||||
// preset.go
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// control.go
|
||||
package expr
|
||||
|
||||
import "strings"
|
||||
|
||||
// Preset control variables
|
||||
const (
|
||||
control_last_result = "_last"
|
||||
control_bool_shortcut = "_bool_shortcut"
|
||||
control_import_path = "_import_path"
|
||||
ControlLastResult = "last"
|
||||
ControlBoolShortcut = "_bool_shortcut"
|
||||
ControlImportPath = "_import_path"
|
||||
)
|
||||
|
||||
// Other control variables
|
||||
@@ -21,8 +24,8 @@ const (
|
||||
)
|
||||
|
||||
func initDefaultVars(ctx ExprContext) {
|
||||
ctx.SetVar(control_bool_shortcut, true)
|
||||
ctx.SetVar(control_import_path, init_import_path)
|
||||
ctx.SetVar(ControlBoolShortcut, true)
|
||||
ctx.SetVar(ControlImportPath, init_import_path)
|
||||
}
|
||||
|
||||
func enable(ctx ExprContext, name string) {
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
+5
-2
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// func-import.go
|
||||
package expr
|
||||
|
||||
@@ -51,7 +54,7 @@ func addEnvImportDirs(dirList []string) []string {
|
||||
}
|
||||
|
||||
func addPresetImportDirs(ctx ExprContext, dirList []string) []string {
|
||||
if dirSpec, exists := getControlString(ctx, control_import_path); exists {
|
||||
if dirSpec, exists := getControlString(ctx, ControlImportPath); exists {
|
||||
dirs := strings.Split(dirSpec, ":")
|
||||
if dirList == nil {
|
||||
dirList = dirs
|
||||
@@ -133,7 +136,7 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
|
||||
return
|
||||
}
|
||||
|
||||
func importImportFunc(ctx ExprContext) {
|
||||
func ImportImportFunc(ctx ExprContext) {
|
||||
ctx.RegisterFunc("import", &simpleFunctor{f: importFunc}, 1, -1)
|
||||
ctx.RegisterFunc("include", &simpleFunctor{f: includeFunc}, 1, -1)
|
||||
}
|
||||
|
||||
+4
-1
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// funcs-math.go
|
||||
package expr
|
||||
|
||||
@@ -101,7 +104,7 @@ func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func importMathFuncs(ctx ExprContext) {
|
||||
func ImportMathFuncs(ctx ExprContext) {
|
||||
ctx.RegisterFunc("add", &simpleFunctor{f: addFunc}, 0, -1)
|
||||
ctx.RegisterFunc("mul", &simpleFunctor{f: mulFunc}, 0, -1)
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// helpers.go
|
||||
package expr
|
||||
|
||||
|
||||
+3
-2
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// helpers_test.go
|
||||
package expr
|
||||
|
||||
@@ -45,7 +48,6 @@ func TestEvalStringA(t *testing.T) {
|
||||
t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
|
||||
t.Errorf("Error: %v", gotErr)
|
||||
}
|
||||
fmt.Println("Hello World!")
|
||||
}
|
||||
|
||||
func TestEvalString(t *testing.T) {
|
||||
@@ -76,5 +78,4 @@ func TestEvalString(t *testing.T) {
|
||||
t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
|
||||
t.Errorf("Error: %v", gotErr)
|
||||
}
|
||||
fmt.Println("Hello World!")
|
||||
}
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// it-range.go
|
||||
package expr
|
||||
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// iterator.go
|
||||
package expr
|
||||
|
||||
|
||||
+3
-3
@@ -57,7 +57,7 @@ func exportVar(ctx ExprContext, name string, value any) {
|
||||
if name[0] == '@' {
|
||||
name = name[1:]
|
||||
}
|
||||
ctx.SetVar(name, value)
|
||||
ctx.setVar(name, value)
|
||||
}
|
||||
|
||||
func exportFunc(ctx ExprContext, name string, info ExprFunc) {
|
||||
@@ -89,9 +89,9 @@ type funcDefFunctor struct {
|
||||
func (functor *funcDefFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
|
||||
for i, p := range functor.params {
|
||||
if i < len(args) {
|
||||
ctx.SetVar(p, args[i])
|
||||
ctx.setVar(p, args[i])
|
||||
} else {
|
||||
ctx.SetVar(p, nil)
|
||||
ctx.setVar(p, nil)
|
||||
}
|
||||
}
|
||||
result, err = functor.expr.eval(ctx, false)
|
||||
|
||||
+37
-4
@@ -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
|
||||
// }
|
||||
|
||||
@@ -4,7 +4,10 @@
|
||||
// operand-selector-case.go
|
||||
package expr
|
||||
|
||||
import "fmt"
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// -------- selector case term
|
||||
|
||||
@@ -13,6 +16,18 @@ type selectorCase struct {
|
||||
caseExpr Expr
|
||||
}
|
||||
|
||||
func (sc *selectorCase) String() string {
|
||||
var sb strings.Builder
|
||||
if sc.filterList != nil {
|
||||
sc.filterList.toString(&sb)
|
||||
sb.WriteByte(' ')
|
||||
}
|
||||
sb.WriteByte('{')
|
||||
sb.WriteString(sc.caseExpr.String())
|
||||
sb.WriteByte('}')
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
|
||||
tk := NewValueToken(row, col, SymSelectorCase, "", &selectorCase{filterList: filterList, caseExpr: caseExpr})
|
||||
return &term{
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
|
||||
if functor, ok := v.(Functor); ok {
|
||||
ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
|
||||
} else {
|
||||
ctx.SetVar(leftTerm.tk.source, v)
|
||||
ctx.setVar(leftTerm.tk.source, v)
|
||||
}
|
||||
}
|
||||
return
|
||||
|
||||
+2
-2
@@ -48,7 +48,7 @@ func newAndTerm(tk *Token) (inst *term) {
|
||||
}
|
||||
|
||||
func evalAnd(ctx ExprContext, self *term) (v any, err error) {
|
||||
if isEnabled(ctx, control_bool_shortcut) {
|
||||
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 isEnabled(ctx, control_bool_shortcut) {
|
||||
if isEnabled(ctx, ControlBoolShortcut) {
|
||||
v, err = evalOrWithShortcut(ctx, self)
|
||||
} else {
|
||||
v, err = evalOrWithoutShortcut(ctx, self)
|
||||
|
||||
@@ -75,7 +75,7 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
|
||||
err = errCoalesceNoFunc(self.children[1])
|
||||
} else {
|
||||
v = rightValue
|
||||
ctx.SetVar(leftTerm.source(), rightValue)
|
||||
ctx.setVar(leftTerm.source(), rightValue)
|
||||
}
|
||||
}
|
||||
return
|
||||
|
||||
+62
-4
@@ -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 {
|
||||
filterList := caseData.filterList.children
|
||||
} else if filterList, ok := caseData.filterList.value().([]*term); ok {
|
||||
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 {
|
||||
|
||||
@@ -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
|
||||
@@ -268,7 +281,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
|
||||
currentTerm, err = tree.addToken2(tk)
|
||||
}
|
||||
|
||||
if currentTerm != nil && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
|
||||
if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
|
||||
selectorTerm = nil
|
||||
|
||||
}
|
||||
|
||||
+6
-5
@@ -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 {
|
||||
@@ -173,8 +174,8 @@ func TestParser(t *testing.T) {
|
||||
ctx := NewSimpleFuncStore()
|
||||
ctx.SetVar("var1", int64(123))
|
||||
ctx.SetVar("var2", "abc")
|
||||
importMathFuncs(ctx)
|
||||
importImportFunc(ctx)
|
||||
ImportMathFuncs(ctx)
|
||||
ImportImportFunc(ctx)
|
||||
parser := NewParser(ctx)
|
||||
|
||||
logTest(t, i+1, input.source, input.wantResult, input.wantErr)
|
||||
@@ -204,7 +205,7 @@ func TestParser(t *testing.T) {
|
||||
} else {
|
||||
failed++
|
||||
if i+1 == check_env_expr_path {
|
||||
t.Logf(`NOTICE: Test nr %d requires EXPR_PATH environment variable with value "."`, check_env_expr_path)
|
||||
t.Logf(`NOTICE: Test nr %d requires EXPR_PATH="."`, check_env_expr_path)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -249,7 +250,7 @@ func TestListParser(t *testing.T) {
|
||||
ctx := NewSimpleFuncStore()
|
||||
ctx.SetVar("var1", int64(123))
|
||||
ctx.SetVar("var2", "abc")
|
||||
importMathFuncs(ctx)
|
||||
ImportMathFuncs(ctx)
|
||||
parser := NewParser(ctx)
|
||||
|
||||
logTest(t, i+1, input.source, input.wantResult, input.wantErr)
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// simple-func-store.go
|
||||
package expr
|
||||
|
||||
|
||||
+14
-1
@@ -1,6 +1,11 @@
|
||||
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// simple-var-store.go
|
||||
package expr
|
||||
|
||||
import "fmt"
|
||||
|
||||
type SimpleVarStore struct {
|
||||
varStore map[string]any
|
||||
}
|
||||
@@ -23,10 +28,18 @@ func (ctx *SimpleVarStore) GetVar(varName string) (v any, exists bool) {
|
||||
return
|
||||
}
|
||||
|
||||
func (ctx *SimpleVarStore) SetVar(varName string, value any) {
|
||||
func (ctx *SimpleVarStore) setVar(varName string, value any) {
|
||||
ctx.varStore[varName] = value
|
||||
}
|
||||
|
||||
func (ctx *SimpleVarStore) SetVar(varName string, value any) {
|
||||
if allowedValue, ok := fromGenericAny(value); ok {
|
||||
ctx.varStore[varName] = allowedValue
|
||||
} else {
|
||||
panic(fmt.Errorf("unsupported type %T of value %v", value, value))
|
||||
}
|
||||
}
|
||||
|
||||
func (ctx *SimpleVarStore) EnumVars(acceptor func(name string) (accept bool)) (varNames []string) {
|
||||
varNames = make([]string, 0)
|
||||
for name := range ctx.varStore {
|
||||
|
||||
+3
-4
@@ -5,7 +5,6 @@
|
||||
package expr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
@@ -16,7 +15,7 @@ func TestString(t *testing.T) {
|
||||
|
||||
tree := NewAst()
|
||||
if gotErr := tree.addTokens(tk1, tk2, tk3); gotErr == nil {
|
||||
fmt.Println("Tree:", tree)
|
||||
t.Log("Tree:", tree)
|
||||
} else {
|
||||
t.Errorf("err: got <%v>, want <nil>", gotErr)
|
||||
}
|
||||
@@ -27,7 +26,7 @@ func TestGetRoom(t *testing.T) {
|
||||
|
||||
tree := NewAst()
|
||||
if gotErr := tree.addTokens(tk1); gotErr == nil {
|
||||
fmt.Println("Tree-root room:", tree.root.getRoom())
|
||||
t.Log("Tree-root room:", tree.root.getRoom())
|
||||
} else {
|
||||
t.Errorf("err: got <%v>, want <nil>", gotErr)
|
||||
}
|
||||
@@ -37,7 +36,7 @@ func TestGetChildrenCount(t *testing.T) {
|
||||
|
||||
tree := NewAst()
|
||||
if gotErr := tree.addTokens(tk1); gotErr == nil {
|
||||
fmt.Println("Tree-root children count:", tree.root.getChildrenCount())
|
||||
t.Log("Tree-root children count:", tree.root.getChildrenCount())
|
||||
} else {
|
||||
t.Errorf("err: got <%v>, want <nil>", gotErr)
|
||||
}
|
||||
|
||||
@@ -27,7 +27,11 @@ func (tk *Token) DevString() string {
|
||||
|
||||
func (tk *Token) String() string {
|
||||
if tk.Value != nil {
|
||||
return fmt.Sprintf("%#v", tk.Value)
|
||||
if s, ok := tk.Value.(string); ok {
|
||||
return fmt.Sprintf("%q", s)
|
||||
} else {
|
||||
return fmt.Sprintf("%v", tk.Value)
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("%s", tk.source)
|
||||
}
|
||||
|
||||
+25
-5
@@ -5,14 +5,34 @@
|
||||
package expr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestDevString(t *testing.T) {
|
||||
tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
|
||||
tk2 := NewToken(0, 0, SymPlus, "+")
|
||||
type inputType struct {
|
||||
source string
|
||||
sym Symbol
|
||||
value any
|
||||
wantResult string
|
||||
}
|
||||
|
||||
fmt.Println("Token '100':", tk1.DevString())
|
||||
fmt.Println("Token '+':", tk2.DevString())
|
||||
inputs := []inputType{
|
||||
/* 1 */ {"100", SymInteger, 100, `[55]"100"{100}`},
|
||||
/* 2 */ {"+", SymPlus, nil, `[6]"+"{}`},
|
||||
}
|
||||
|
||||
for i, input := range inputs {
|
||||
var tk *Token
|
||||
if input.value == nil {
|
||||
tk = NewToken(0, 0, input.sym, input.source)
|
||||
} else {
|
||||
tk = NewValueToken(0, 0, input.sym, input.source, input.value)
|
||||
}
|
||||
|
||||
t.Logf("Test nr %2d: %q --> %q", i+1, input.source, input.wantResult)
|
||||
|
||||
if s := tk.DevString(); s != input.wantResult {
|
||||
t.Errorf("wrong token from symbol '+': expected %q, got %q", input.wantResult, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -73,6 +73,8 @@ func anyInteger(v any) (i int64, ok bool) {
|
||||
i = int64(intval)
|
||||
case uint16:
|
||||
i = int64(intval)
|
||||
case uint64:
|
||||
i = int64(intval)
|
||||
case uint32:
|
||||
i = int64(intval)
|
||||
case int8:
|
||||
@@ -89,6 +91,22 @@ func anyInteger(v any) (i int64, ok bool) {
|
||||
return
|
||||
}
|
||||
|
||||
func fromGenericAny(v any) (exprAny any, ok bool) {
|
||||
if exprAny, ok = v.(bool); ok {
|
||||
return
|
||||
}
|
||||
if exprAny, ok = v.(string); ok {
|
||||
return
|
||||
}
|
||||
if exprAny, ok = anyInteger(v); ok {
|
||||
return
|
||||
}
|
||||
if exprAny, ok = anyFloat(v); ok {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func anyFloat(v any) (float float64, ok bool) {
|
||||
ok = true
|
||||
switch floatval := v.(type) {
|
||||
|
||||
Reference in New Issue
Block a user