initial
This commit is contained in:
commit
0562659220
19 changed files with 1909 additions and 0 deletions
130
README.md
Normal file
130
README.md
Normal file
|
|
@ -0,0 +1,130 @@
|
||||||
|
|
||||||
|
# Lexpr - universal expression evaluator
|
||||||
|
|
||||||
|
This library can evaluate any types of expressions: math expression, logic expression, simple DSLs.
|
||||||
|
|
||||||
|
## Installation
|
||||||
|
|
||||||
|
`go get go.neonxp.dev/lexpr`
|
||||||
|
|
||||||
|
## Usage
|
||||||
|
|
||||||
|
```go
|
||||||
|
ctx := context.Background()
|
||||||
|
l := lexpr.New(lexpr.WithDefaults())
|
||||||
|
|
||||||
|
// Simple math
|
||||||
|
result1 := <-l.Eval(ctx, `2 + 2 * 2`) // Output channel can return many results
|
||||||
|
log.Println("Result 1:", result1.Value) // Output: 6
|
||||||
|
|
||||||
|
// Helper for exact one result
|
||||||
|
result2, err := l.OneResult(ctx, `len("test") + 10`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 2:", result2) // Output: 14
|
||||||
|
|
||||||
|
// Custom functions
|
||||||
|
l.SetFunction("add", func(ts *lexpr.TokenStack) error {
|
||||||
|
a, okA := ts.Pop().Number() // first func argument
|
||||||
|
b, okB := ts.Pop().Number() // second func argument
|
||||||
|
if !okA || !okB {
|
||||||
|
return fmt.Errorf("Both args must be number")
|
||||||
|
}
|
||||||
|
ts.Push(lexpr.TokenFromInt(a + b))
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
result3, err := l.OneResult(ctx, `add(12, 24) * 2`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 3:", result3) // Output: 72
|
||||||
|
|
||||||
|
// JSON extraction via dots and variables
|
||||||
|
jsonString := `{
|
||||||
|
"rootKey1": "value1",
|
||||||
|
"rootKey2": {
|
||||||
|
"childKey1": "value2",
|
||||||
|
"childKey2": "value3"
|
||||||
|
},
|
||||||
|
"arrayKey": [
|
||||||
|
"array value 1",
|
||||||
|
"array value 2",
|
||||||
|
"array value 3",
|
||||||
|
"array value 4"
|
||||||
|
]
|
||||||
|
}`
|
||||||
|
key1name := "rootKey1"
|
||||||
|
l.SetVariable("jsonData", jsonString)
|
||||||
|
l.SetVariable("key1name", key1name)
|
||||||
|
result41, err := l.OneResult(ctx, `jsonData.key1name`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-1:", result41) // Output: "value1"
|
||||||
|
result42, err := l.OneResult(ctx, `jsonData.rootKey2.childKey2`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-2:", result42) // Output: "value3"
|
||||||
|
result43, err := l.OneResult(ctx, `jsonData.arrayKey.3`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-3:", result43) // Output: "array value 4"
|
||||||
|
|
||||||
|
// Logic expressions
|
||||||
|
result51, err := l.OneResult(ctx, `jsonData.key1name == "value1"`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-1:", result51) // Output: 1
|
||||||
|
result52, err := l.OneResult(ctx, `10 >= 5 || 10 <= 5`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-2:", result52) // Output: 1
|
||||||
|
result53, err := l.OneResult(ctx, `10 >= 5 && 10 <= 5`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-3:", result53) // Output: 0
|
||||||
|
```
|
||||||
|
|
||||||
|
## Default operators
|
||||||
|
|
||||||
|
|Operator|Description|Example|
|
||||||
|
|:------:|:---------:|:-----:|
|
||||||
|
||JSON operators||
|
||||||
|
|`.`|Extract field from json|`jsonData.key1.0.key2`|
|
||||||
|
||Math operators||
|
||||||
|
|`**`|Power number|`3 ** 3` = 27|
|
||||||
|
|`*`|Multiple numbers|`2 * 4` = 8|
|
||||||
|
|`/`|Divide number|`6 / 3` = 2|
|
||||||
|
|`%`|Rem of division|`5 % 3` = 2|
|
||||||
|
|`+`|Sum|`2 + 2` = 4|
|
||||||
|
|`-`|Substract|`6 - 2` = 4|
|
||||||
|
||Logic operators||
|
||||||
|
|`!`|Logic not|`!1` = 0|
|
||||||
|
|`>`|More|`3 > 2` = 1|
|
||||||
|
|`>=`|More or equal|`3 >= 3` = 1|
|
||||||
|
|`<`|Less|`3 < 2` = 0|
|
||||||
|
|`<=`|Less or equal|`3 <= 3` = 1|
|
||||||
|
|`==`|Equal|`1==1` = 1|
|
||||||
|
|`!=`|Not equal|`1!=1` = 0|
|
||||||
|
|`&&`|Logic and|`3 > 0 && 1 > 0` = 1|
|
||||||
|
|`||`|Logic or|`1 > 0 || 1 == 1` = 1|
|
||||||
|
|
||||||
|
## Default functions
|
||||||
|
|
||||||
|
|Function|Description|Example|
|
||||||
|
|:------:|:---------:|:-----:|
|
||||||
|
|max|returns max of two values|`max(1,2)` = 2|
|
||||||
|
|min|returns min of two values|`max(1,2)` = 1|
|
||||||
|
|len|returns length of string|`len("test")` = 4|
|
||||||
|
|atoi|converts string to number|`atoi("123")` = 123|
|
||||||
|
|itoa|converts number to string|`itoa(123)` = "123"|
|
||||||
|
|
||||||
|
## Contribution
|
||||||
|
|
||||||
|
PRs are welcome.
|
||||||
91
example/main.go
Normal file
91
example/main.go
Normal file
|
|
@ -0,0 +1,91 @@
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
|
||||||
|
"go.neonxp.dev/lexpr"
|
||||||
|
)
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
ctx := context.Background()
|
||||||
|
l := lexpr.New(lexpr.WithDefaults())
|
||||||
|
|
||||||
|
// Simple math
|
||||||
|
result1 := <-l.Eval(ctx, `2 + 2 * 2`)
|
||||||
|
log.Println("Result 1:", result1.Value)
|
||||||
|
|
||||||
|
// Helper for one result
|
||||||
|
result2, err := l.OneResult(ctx, `len("test") + 10`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 2:", result2)
|
||||||
|
|
||||||
|
// Custom functions
|
||||||
|
l.SetFunction("add", func(ts *lexpr.TokenStack) error {
|
||||||
|
a, okA := ts.Pop().Number() // first func argument
|
||||||
|
b, okB := ts.Pop().Number() // second func argument
|
||||||
|
if !okA || !okB {
|
||||||
|
return fmt.Errorf("Both args must be number")
|
||||||
|
}
|
||||||
|
ts.Push(lexpr.TokenFromInt(a + b))
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
result3, err := l.OneResult(ctx, `add(12, 24) * 2`)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 3:", result3)
|
||||||
|
|
||||||
|
// JSON extraction via dots and variables
|
||||||
|
jsonString := `{
|
||||||
|
"rootKey1": "value1",
|
||||||
|
"rootKey2": {
|
||||||
|
"childKey1": "value2",
|
||||||
|
"childKey2": "value3"
|
||||||
|
},
|
||||||
|
"arrayKey": [
|
||||||
|
"array value 1",
|
||||||
|
"array value 2",
|
||||||
|
"array value 3",
|
||||||
|
"array value 4"
|
||||||
|
]
|
||||||
|
}`
|
||||||
|
key1name := "rootKey1"
|
||||||
|
l.SetVariable("jsonData", jsonString)
|
||||||
|
l.SetVariable("key1name", key1name)
|
||||||
|
result41, err := l.OneResult(ctx, `jsonData.key1name`) // = value1
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-1:", result41)
|
||||||
|
result42, err := l.OneResult(ctx, `jsonData.rootKey2.childKey2`) // = value3
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-2:", result42)
|
||||||
|
result43, err := l.OneResult(ctx, `jsonData.arrayKey.3`) // = array value 4
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 4-3:", result43)
|
||||||
|
|
||||||
|
// Logic expressions
|
||||||
|
result51, err := l.OneResult(ctx, `jsonData.key1name == "value1"`) // = 1
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-1:", result51)
|
||||||
|
result52, err := l.OneResult(ctx, `10 >= 5 || 10 <= 5`) // = 1
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-2:", result52)
|
||||||
|
result53, err := l.OneResult(ctx, `10 >= 5 && 10 <= 5`) // = 0
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Println("Result 5-3:", result53)
|
||||||
|
}
|
||||||
75
executor.go
Normal file
75
executor.go
Normal file
|
|
@ -0,0 +1,75 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
func (l *Lexpr) execute(ctx context.Context, tokens <-chan Token) chan Result {
|
||||||
|
out := make(chan Result)
|
||||||
|
stack := TokenStack{}
|
||||||
|
go func() {
|
||||||
|
defer func() {
|
||||||
|
for len(stack) > 0 {
|
||||||
|
ret := stack.Pop()
|
||||||
|
switch ret.typ {
|
||||||
|
case str:
|
||||||
|
out <- Result{Value: ret.value}
|
||||||
|
case number:
|
||||||
|
out <- Result{Value: ret.ivalue}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
close(out)
|
||||||
|
}()
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ctx.Done():
|
||||||
|
return
|
||||||
|
case tkn, ok := <-tokens:
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch tkn.typ {
|
||||||
|
case number:
|
||||||
|
stack.Push(tkn)
|
||||||
|
case str:
|
||||||
|
stack.Push(Token{
|
||||||
|
typ: str,
|
||||||
|
value: strings.Trim(tkn.value, `"`),
|
||||||
|
})
|
||||||
|
case funct:
|
||||||
|
fn := l.functions[tkn.value]
|
||||||
|
if err := fn(&stack); err != nil {
|
||||||
|
out <- Result{Error: err}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
case op:
|
||||||
|
op := l.operators[tkn.value]
|
||||||
|
if err := op.handler(&stack); err != nil {
|
||||||
|
out <- Result{Error: err}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
case word:
|
||||||
|
variable, hasVariable := l.variables[strings.ToLower(tkn.value)]
|
||||||
|
if !hasVariable {
|
||||||
|
stack.Push(tkn)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
vtkn, ok := TokenFromAny(variable)
|
||||||
|
if !ok {
|
||||||
|
out <- Result{Error: fmt.Errorf("invalid variable value: %+v", variable)}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
stack.Push(vtkn)
|
||||||
|
case tokError:
|
||||||
|
out <- Result{Error: fmt.Errorf(tkn.value)}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
return out
|
||||||
|
}
|
||||||
3
go.mod
Normal file
3
go.mod
Normal file
|
|
@ -0,0 +1,3 @@
|
||||||
|
module go.neonxp.dev/lexpr
|
||||||
|
|
||||||
|
go 1.18
|
||||||
12
helpers.go
Normal file
12
helpers.go
Normal file
|
|
@ -0,0 +1,12 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import "context"
|
||||||
|
|
||||||
|
func (l *Lexpr) OneResult(ctx context.Context, expression string) (any, error) {
|
||||||
|
select {
|
||||||
|
case r := <-l.Eval(ctx, expression):
|
||||||
|
return r.Value, r.Error
|
||||||
|
case <-ctx.Done():
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
78
itr.go
Normal file
78
itr.go
Normal file
|
|
@ -0,0 +1,78 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import "context"
|
||||||
|
|
||||||
|
func infixToRpn(ctx context.Context, tokens <-chan Token) <-chan Token {
|
||||||
|
out := make(chan Token)
|
||||||
|
stack := TokenStack{}
|
||||||
|
go func() {
|
||||||
|
defer func() {
|
||||||
|
if len(stack) > 0 {
|
||||||
|
for {
|
||||||
|
if stack.Head().typ == lp {
|
||||||
|
out <- Token{
|
||||||
|
typ: tokError,
|
||||||
|
value: "invalid brakets",
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
out <- stack.Pop()
|
||||||
|
if len(stack) == 0 {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
close(out)
|
||||||
|
}()
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ctx.Done():
|
||||||
|
return
|
||||||
|
case tkn, ok := <-tokens:
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch tkn.typ {
|
||||||
|
case number, word, str, tokError:
|
||||||
|
out <- tkn
|
||||||
|
case funct:
|
||||||
|
stack.Push(tkn)
|
||||||
|
case sep:
|
||||||
|
for stack.Head().typ != lp {
|
||||||
|
if len(stack) == 0 {
|
||||||
|
out <- Token{
|
||||||
|
typ: tokError,
|
||||||
|
value: "no arg separator or opening braket",
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
out <- stack.Pop()
|
||||||
|
}
|
||||||
|
case op:
|
||||||
|
for len(stack) > 0 && (stack.Head().typ != op || (stack.Head().priority >= tkn.priority)) {
|
||||||
|
out <- stack.Pop()
|
||||||
|
}
|
||||||
|
stack.Push(tkn)
|
||||||
|
case lp:
|
||||||
|
stack.Push(tkn)
|
||||||
|
case rp:
|
||||||
|
for stack.Head().typ != lp {
|
||||||
|
if len(stack) == 0 {
|
||||||
|
out <- Token{
|
||||||
|
typ: tokError,
|
||||||
|
value: "no opening braket",
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
out <- stack.Pop()
|
||||||
|
}
|
||||||
|
stack.Pop()
|
||||||
|
if stack.Head().typ == funct {
|
||||||
|
out <- stack.Pop()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
return out
|
||||||
|
}
|
||||||
149
itr_test.go
Normal file
149
itr_test.go
Normal file
|
|
@ -0,0 +1,149 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func Test_infixToRpn(t *testing.T) {
|
||||||
|
type args struct {
|
||||||
|
in []Token
|
||||||
|
}
|
||||||
|
tests := []struct {
|
||||||
|
name string
|
||||||
|
args args
|
||||||
|
want []Token
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
name: "simple",
|
||||||
|
args: args{
|
||||||
|
in: []Token{
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "min",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: lp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 3,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: sep,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 2,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: rp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "*",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "max",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: lp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 10,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: sep,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 20,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: rp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "==",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 40,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
want: []Token{
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 3,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 2,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "min",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 10,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 20,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "max",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "*",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 40,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "==",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
inCh := make(chan Token)
|
||||||
|
go func() {
|
||||||
|
defer close(inCh)
|
||||||
|
for _, tk := range tt.args.in {
|
||||||
|
inCh <- tk
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
gotCh := infixToRpn(context.Background(), inCh)
|
||||||
|
got := []Token{}
|
||||||
|
for o := range gotCh {
|
||||||
|
got = append(got, o)
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(got, tt.want) {
|
||||||
|
t.Errorf("infixToRpn() = %v, want %v", got, tt.want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
181
lex.go
Normal file
181
lex.go
Normal file
|
|
@ -0,0 +1,181 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"strings"
|
||||||
|
"unicode/utf8"
|
||||||
|
)
|
||||||
|
|
||||||
|
// EOF const.
|
||||||
|
const EOF rune = -1
|
||||||
|
|
||||||
|
// lex holds current scanner state.
|
||||||
|
type lex struct {
|
||||||
|
input string // Input string.
|
||||||
|
start int // Start position of current lexem.
|
||||||
|
pos int // Pos at input string.
|
||||||
|
output chan lexem // Lexems channel.
|
||||||
|
width int // Width of last rune.
|
||||||
|
}
|
||||||
|
|
||||||
|
// newLex returns new scanner for input string.
|
||||||
|
func newLex() *lex {
|
||||||
|
return &lex{
|
||||||
|
input: "",
|
||||||
|
start: 0,
|
||||||
|
pos: 0,
|
||||||
|
output: nil,
|
||||||
|
width: 0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// parse input to lexems.
|
||||||
|
func (l *lex) parse(ctx context.Context, input string) <-chan lexem {
|
||||||
|
l.input = input
|
||||||
|
l.output = make(chan lexem)
|
||||||
|
go func() {
|
||||||
|
defer close(l.output)
|
||||||
|
for {
|
||||||
|
if ctx.Err() != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch {
|
||||||
|
case l.acceptWhile(" \n\t", false):
|
||||||
|
l.ignore()
|
||||||
|
case l.accept("("):
|
||||||
|
l.emit(lp)
|
||||||
|
case l.accept(")"):
|
||||||
|
l.emit(rp)
|
||||||
|
case l.accept(","):
|
||||||
|
l.emit(sep)
|
||||||
|
case scanNumber(l):
|
||||||
|
l.emit(number)
|
||||||
|
case scanOps(l):
|
||||||
|
l.emit(op)
|
||||||
|
case scanWord(l):
|
||||||
|
l.emit(word)
|
||||||
|
case scanQuotedString(l, `"`):
|
||||||
|
l.emit(str)
|
||||||
|
case l.peek() == EOF:
|
||||||
|
return
|
||||||
|
default:
|
||||||
|
l.emit(tokError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
return l.output
|
||||||
|
}
|
||||||
|
|
||||||
|
// emit current lexem to output.
|
||||||
|
func (l *lex) emit(typ lexType) {
|
||||||
|
l.output <- lexem{
|
||||||
|
Type: typ,
|
||||||
|
Value: l.input[l.start:l.pos],
|
||||||
|
Start: l.start,
|
||||||
|
End: l.pos,
|
||||||
|
}
|
||||||
|
l.start = l.pos
|
||||||
|
}
|
||||||
|
|
||||||
|
// next rune from input.
|
||||||
|
func (l *lex) next() (r rune) {
|
||||||
|
if int(l.pos) >= len(l.input) {
|
||||||
|
l.width = 0
|
||||||
|
return EOF
|
||||||
|
}
|
||||||
|
r, l.width = utf8.DecodeRuneInString(l.input[l.pos:])
|
||||||
|
l.pos += l.width
|
||||||
|
return r
|
||||||
|
}
|
||||||
|
|
||||||
|
// back move position to previos rune.
|
||||||
|
func (l *lex) back() {
|
||||||
|
l.pos -= l.width
|
||||||
|
}
|
||||||
|
|
||||||
|
// ignore previosly buffered text.
|
||||||
|
func (l *lex) ignore() {
|
||||||
|
l.start = l.pos
|
||||||
|
l.width = 0
|
||||||
|
}
|
||||||
|
|
||||||
|
// peek rune at current position without moving position.
|
||||||
|
func (l *lex) peek() (r rune) {
|
||||||
|
r = l.next()
|
||||||
|
l.back()
|
||||||
|
return r
|
||||||
|
}
|
||||||
|
|
||||||
|
// accept any rune from valid string. Returns true if next rune was in valid string.
|
||||||
|
func (l *lex) accept(valid string) bool {
|
||||||
|
if strings.ContainsRune(valid, l.next()) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
l.back()
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// acceptString returns true if given string was at position.
|
||||||
|
func (l *lex) acceptString(s string, caseInsentive bool) bool {
|
||||||
|
input := l.input
|
||||||
|
if caseInsentive {
|
||||||
|
input = strings.ToLower(input)
|
||||||
|
s = strings.ToLower(s)
|
||||||
|
}
|
||||||
|
if strings.HasPrefix(input, s) {
|
||||||
|
l.width = 0
|
||||||
|
l.pos += len(s)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// acceptAnyOf substrings. Retuns true if any of substrings was found.
|
||||||
|
func (l *lex) acceptAnyOf(s []string, caseInsentive bool) bool {
|
||||||
|
for _, substring := range s {
|
||||||
|
if l.acceptString(substring, caseInsentive) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// acceptWhile passing symbols from input while they at `valid` string.
|
||||||
|
func (l *lex) acceptWhile(valid string, ignoreEscaped bool) bool {
|
||||||
|
start := l.pos
|
||||||
|
for {
|
||||||
|
ch := l.next()
|
||||||
|
switch {
|
||||||
|
case ch == EOF:
|
||||||
|
return false
|
||||||
|
case ch == '\\' && ignoreEscaped:
|
||||||
|
l.next()
|
||||||
|
case !strings.ContainsRune(valid, ch):
|
||||||
|
l.back()
|
||||||
|
return l.pos > start
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// acceptWhileNot passing symbols from input while they NOT in `invalid` string.
|
||||||
|
func (l *lex) acceptWhileNot(invalid string, ignoreEscaped bool) bool {
|
||||||
|
start := l.pos
|
||||||
|
for {
|
||||||
|
ch := l.next()
|
||||||
|
switch {
|
||||||
|
case ch == EOF:
|
||||||
|
return false
|
||||||
|
case ch == '\\' && ignoreEscaped:
|
||||||
|
l.next()
|
||||||
|
case strings.ContainsRune(invalid, ch):
|
||||||
|
l.back()
|
||||||
|
return l.pos > start
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// atStart returns true if current lexem not empty
|
||||||
|
func (l *lex) atStart() bool {
|
||||||
|
return l.pos == l.start
|
||||||
|
}
|
||||||
89
lex_test.go
Normal file
89
lex_test.go
Normal file
|
|
@ -0,0 +1,89 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func Test_lex_Parse(t *testing.T) {
|
||||||
|
type args struct {
|
||||||
|
input string
|
||||||
|
}
|
||||||
|
tests := []struct {
|
||||||
|
name string
|
||||||
|
args args
|
||||||
|
want []lexem
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
name: "math",
|
||||||
|
args: args{
|
||||||
|
input: "min(3, 2) * max(10, 20) == 40",
|
||||||
|
},
|
||||||
|
want: []lexem{
|
||||||
|
{
|
||||||
|
Type: word,
|
||||||
|
Value: "min",
|
||||||
|
}, {
|
||||||
|
Type: lp,
|
||||||
|
Value: "(",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "3",
|
||||||
|
}, {
|
||||||
|
Type: sep,
|
||||||
|
Value: ",",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "2",
|
||||||
|
}, {
|
||||||
|
Type: rp,
|
||||||
|
Value: ")",
|
||||||
|
}, {
|
||||||
|
Type: op,
|
||||||
|
Value: "*",
|
||||||
|
}, {
|
||||||
|
Type: word,
|
||||||
|
Value: "max",
|
||||||
|
}, {
|
||||||
|
Type: lp,
|
||||||
|
Value: "(",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "10",
|
||||||
|
}, {
|
||||||
|
Type: sep,
|
||||||
|
Value: ",",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "20",
|
||||||
|
}, {
|
||||||
|
Type: rp,
|
||||||
|
Value: ")",
|
||||||
|
}, {
|
||||||
|
Type: op,
|
||||||
|
Value: "==",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "40",
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
l := newLex()
|
||||||
|
gotCh := l.parse(context.Background(), tt.args.input)
|
||||||
|
got := []lexem{}
|
||||||
|
for o := range gotCh {
|
||||||
|
got = append(got, lexem{
|
||||||
|
Type: o.Type,
|
||||||
|
Value: o.Value,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(got, tt.want) {
|
||||||
|
t.Errorf("lex.Parse() = %v, want %v", got, tt.want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
26
lexem.go
Normal file
26
lexem.go
Normal file
|
|
@ -0,0 +1,26 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
// lexem represents part of parsed string.
|
||||||
|
type lexem struct {
|
||||||
|
Type lexType // Type of Lexem.
|
||||||
|
Value string // Value of Lexem.
|
||||||
|
Start int // Start position at input string.
|
||||||
|
End int // End position at input string.
|
||||||
|
}
|
||||||
|
|
||||||
|
// lexType represents type of current lexem.
|
||||||
|
type lexType int
|
||||||
|
|
||||||
|
// Some std lexem types
|
||||||
|
const (
|
||||||
|
lexEOF lexType = iota
|
||||||
|
tokError
|
||||||
|
number
|
||||||
|
str
|
||||||
|
word
|
||||||
|
op
|
||||||
|
funct
|
||||||
|
lp
|
||||||
|
rp
|
||||||
|
sep
|
||||||
|
)
|
||||||
52
lexpr.go
Normal file
52
lexpr.go
Normal file
|
|
@ -0,0 +1,52 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Lexpr struct {
|
||||||
|
operators map[string]Operator
|
||||||
|
functions map[string]func(ts *TokenStack) error
|
||||||
|
variables map[string]any
|
||||||
|
}
|
||||||
|
|
||||||
|
func New(opts ...Opt) *Lexpr {
|
||||||
|
l := &Lexpr{}
|
||||||
|
for _, o := range opts {
|
||||||
|
o(l)
|
||||||
|
}
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *Lexpr) Eval(ctx context.Context, expression string) chan Result {
|
||||||
|
lexer := newLex()
|
||||||
|
lexems := lexer.parse(ctx, expression)
|
||||||
|
tokens := l.tokenize(ctx, lexems)
|
||||||
|
rpnTokens := infixToRpn(ctx, tokens)
|
||||||
|
return l.execute(ctx, rpnTokens)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *Lexpr) SetFunction(name string, fn func(ts *TokenStack) error) *Lexpr {
|
||||||
|
l.functions[strings.ToLower(name)] = fn
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *Lexpr) SetOperator(name string, fn func(ts *TokenStack) error, priority int, leftAssoc bool) *Lexpr {
|
||||||
|
l.operators[strings.ToLower(name)] = Operator{
|
||||||
|
handler: fn,
|
||||||
|
priority: priority,
|
||||||
|
leftAssoc: leftAssoc,
|
||||||
|
}
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
|
||||||
|
func (l *Lexpr) SetVariable(name string, value any) *Lexpr {
|
||||||
|
l.variables[strings.ToLower(name)] = value
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
|
||||||
|
type Result struct {
|
||||||
|
Value any
|
||||||
|
Error error
|
||||||
|
}
|
||||||
176
lexpr_test.go
Normal file
176
lexpr_test.go
Normal file
|
|
@ -0,0 +1,176 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestLexpr_Eval(t *testing.T) {
|
||||||
|
type fields struct {
|
||||||
|
operators map[string]Operator
|
||||||
|
functions map[string]func(ts *TokenStack) error
|
||||||
|
variables map[string]any
|
||||||
|
}
|
||||||
|
type args struct {
|
||||||
|
expression string
|
||||||
|
}
|
||||||
|
tests := []struct {
|
||||||
|
name string
|
||||||
|
fields fields
|
||||||
|
args args
|
||||||
|
want any
|
||||||
|
wantErr bool
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
name: "simple math",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: "2 + 2 * 2"},
|
||||||
|
want: 6,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "complex equal",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: "min(3, 2) * max(10, 20) == 40"},
|
||||||
|
want: 1,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "complex neql",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: "min(3, 2) * max(10, 20) != 40"},
|
||||||
|
want: 0,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "variables",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{
|
||||||
|
"svar": "test",
|
||||||
|
"ivar": int(123),
|
||||||
|
"fvar": 321.0,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
args: args{
|
||||||
|
expression: "len(svar) + ivar + fvar",
|
||||||
|
},
|
||||||
|
want: 448,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "invalid1",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: ")("},
|
||||||
|
want: nil,
|
||||||
|
wantErr: true,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "invalid2",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: "var1 + var2"},
|
||||||
|
want: nil,
|
||||||
|
wantErr: true,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "invalid3",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{},
|
||||||
|
},
|
||||||
|
args: args{expression: "3 @ 4"},
|
||||||
|
want: nil,
|
||||||
|
wantErr: true,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "dot notation",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{
|
||||||
|
"j": `{ "one" : { "four": {"five": "six"} }, "two": "three" }`,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
args: args{
|
||||||
|
expression: `j.one.four.five`,
|
||||||
|
},
|
||||||
|
want: `six`,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "dot notation with arrays",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{
|
||||||
|
"j": `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
args: args{
|
||||||
|
expression: `j.one.four.1`,
|
||||||
|
},
|
||||||
|
want: `six`,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "dot notation with arrays and variables",
|
||||||
|
fields: fields{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
variables: map[string]any{
|
||||||
|
"j": `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
|
||||||
|
"key1": "one",
|
||||||
|
"key2": 1,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
args: args{
|
||||||
|
expression: `j.key1.four.key2`,
|
||||||
|
},
|
||||||
|
want: `six`,
|
||||||
|
wantErr: false,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
l := &Lexpr{
|
||||||
|
operators: tt.fields.operators,
|
||||||
|
functions: tt.fields.functions,
|
||||||
|
variables: tt.fields.variables,
|
||||||
|
}
|
||||||
|
gotCh := l.Eval(context.Background(), tt.args.expression)
|
||||||
|
res := <-gotCh
|
||||||
|
got := res.Value
|
||||||
|
err := res.Error
|
||||||
|
if (err != nil) != tt.wantErr {
|
||||||
|
t.Errorf("Lexpr.Eval() error = %v, wantErr %v", err, tt.wantErr)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(got, tt.want) {
|
||||||
|
t.Errorf("Lexpr.Eval() = %v, want %v", got, tt.want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
29
options.go
Normal file
29
options.go
Normal file
|
|
@ -0,0 +1,29 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
type Opt func(*Lexpr)
|
||||||
|
|
||||||
|
func WithOperators(operators map[string]Operator) Opt {
|
||||||
|
return func(l *Lexpr) {
|
||||||
|
l.operators = operators
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func WithFunctions(functions map[string]func(ts *TokenStack) error) Opt {
|
||||||
|
return func(l *Lexpr) {
|
||||||
|
l.functions = functions
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func WithValues(variables map[string]any) Opt {
|
||||||
|
return func(l *Lexpr) {
|
||||||
|
l.variables = variables
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func WithDefaults() Opt {
|
||||||
|
return func(l *Lexpr) {
|
||||||
|
l.operators = Operators
|
||||||
|
l.functions = Functions
|
||||||
|
l.variables = map[string]any{}
|
||||||
|
}
|
||||||
|
}
|
||||||
50
scanners.go
Normal file
50
scanners.go
Normal file
|
|
@ -0,0 +1,50 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
digits = "0123456789"
|
||||||
|
alpha = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
|
||||||
|
chars = "+-*/=<>@&|:!."
|
||||||
|
)
|
||||||
|
|
||||||
|
// scanNumber simplest scanner that accepts decimal int and float.
|
||||||
|
func scanNumber(l *lex) bool {
|
||||||
|
l.acceptWhile(digits, false)
|
||||||
|
if l.atStart() {
|
||||||
|
// not found any digit
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
l.accept(".")
|
||||||
|
l.acceptWhile(digits, false)
|
||||||
|
return !l.atStart()
|
||||||
|
}
|
||||||
|
|
||||||
|
// scanWord returns true if next input token contains alphanum sequence that not starts from digit and not contains.
|
||||||
|
// spaces or special characters.
|
||||||
|
func scanWord(l *lex) bool {
|
||||||
|
if !l.accept(alpha) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
l.acceptWhile(alpha+digits, false)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func scanOps(l *lex) bool {
|
||||||
|
return l.acceptWhile(chars, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
// scanQuotedString returns true if next input tokens is quoted string. Can be used with any type of quotes.
|
||||||
|
func scanQuotedString(l *lex, quote string) bool {
|
||||||
|
start := l.pos
|
||||||
|
if !strings.ContainsRune(quote, l.next()) {
|
||||||
|
l.pos = start
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if l.acceptWhileNot(quote, true) {
|
||||||
|
l.next()
|
||||||
|
}
|
||||||
|
return !l.atStart()
|
||||||
|
}
|
||||||
23
stack.go
Normal file
23
stack.go
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
type TokenStack []Token
|
||||||
|
|
||||||
|
func (s *TokenStack) Push(item Token) {
|
||||||
|
*s = append(*s, item)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *TokenStack) Pop() (item Token) {
|
||||||
|
if len(*s) == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
*s, item = (*s)[:len(*s)-1], (*s)[len(*s)-1]
|
||||||
|
return item
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *TokenStack) Head() (item Token) {
|
||||||
|
if len(*s) == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
return (*s)[len(*s)-1]
|
||||||
|
}
|
||||||
415
std.go
Normal file
415
std.go
Normal file
|
|
@ -0,0 +1,415 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"math"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Operator struct {
|
||||||
|
handler func(ts *TokenStack) error
|
||||||
|
priority int
|
||||||
|
leftAssoc bool
|
||||||
|
}
|
||||||
|
|
||||||
|
var Operators = map[string]Operator{
|
||||||
|
".": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t2 := ts.Pop()
|
||||||
|
t1 := ts.Pop()
|
||||||
|
switch t2.typ {
|
||||||
|
case str, word:
|
||||||
|
m := map[string]json.RawMessage{}
|
||||||
|
if err := json.Unmarshal([]byte(t1.value), &m); err != nil {
|
||||||
|
return fmt.Errorf("invalid json %s err: %s", t1.value, err.Error())
|
||||||
|
}
|
||||||
|
val, ok := m[t2.value]
|
||||||
|
if !ok {
|
||||||
|
return fmt.Errorf("invalid json key %s key: %s", t1.value, t2.value)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: str,
|
||||||
|
value: strings.Trim(string(val), `"`),
|
||||||
|
})
|
||||||
|
case number:
|
||||||
|
m := []json.RawMessage{}
|
||||||
|
if err := json.Unmarshal([]byte(t1.value), &m); err != nil {
|
||||||
|
return fmt.Errorf("invalid json %s err: %s", t1.value, err.Error())
|
||||||
|
}
|
||||||
|
if len(m) <= t2.ivalue {
|
||||||
|
return fmt.Errorf("invalid json key %s key: %s", t1.value, t2.value)
|
||||||
|
}
|
||||||
|
val := m[t2.ivalue]
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: str,
|
||||||
|
value: strings.Trim(string(val), `"`),
|
||||||
|
})
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("invalid json key: %+v", t2)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 140,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
// Math operators
|
||||||
|
"**": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: int(math.Pow(float64(t1.ivalue), float64(t2.ivalue))),
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 130,
|
||||||
|
leftAssoc: true,
|
||||||
|
},
|
||||||
|
"*": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: t1.ivalue * t2.ivalue,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"/": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: t1.ivalue / t2.ivalue,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"%": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: t1.ivalue % t2.ivalue,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"+": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: t1.ivalue + t2.ivalue,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 110,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"-": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: t1.ivalue - t2.ivalue,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 110,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
|
||||||
|
// Logic operators
|
||||||
|
"!": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t := ts.Pop()
|
||||||
|
switch ts.Pop().typ {
|
||||||
|
case number:
|
||||||
|
t.ivalue = ^t.ivalue
|
||||||
|
ts.Push(t)
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("Argument must be number, got %+v", t)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 50,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
">": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if t2.ivalue > t1.ivalue {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
">=": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if t2.ivalue >= t1.ivalue {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"<": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if t2.ivalue < t1.ivalue {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"<=": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if t2.ivalue <= t1.ivalue {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"==": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
r := 0
|
||||||
|
if t1.typ == number && t2.typ == number && t1.ivalue == t2.ivalue {
|
||||||
|
r = 1
|
||||||
|
} else if t1.value == t2.value {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"!=": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
r := 0
|
||||||
|
if t1.typ == number && t2.typ == number && t1.ivalue != t2.ivalue {
|
||||||
|
r = 1
|
||||||
|
} else if t1.value != t2.value {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"&&": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
b1 := true
|
||||||
|
b2 := true
|
||||||
|
if t1.ivalue == 0 {
|
||||||
|
b1 = false
|
||||||
|
}
|
||||||
|
if t2.ivalue == 0 {
|
||||||
|
b2 = false
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if b1 && b2 {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 10,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
"||": {
|
||||||
|
handler: func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
b1 := true
|
||||||
|
b2 := true
|
||||||
|
if t1.ivalue == 0 {
|
||||||
|
b1 = false
|
||||||
|
}
|
||||||
|
if t2.ivalue == 0 {
|
||||||
|
b2 = false
|
||||||
|
}
|
||||||
|
r := 0
|
||||||
|
if b1 || b2 {
|
||||||
|
r = 1
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: r,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
priority: 0,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
var Functions = map[string]func(ts *TokenStack) error{
|
||||||
|
"max": func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
max := t1.ivalue
|
||||||
|
if t2.ivalue > max {
|
||||||
|
max = t2.ivalue
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: max,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
"min": func(ts *TokenStack) error {
|
||||||
|
t1 := ts.Pop()
|
||||||
|
t2 := ts.Pop()
|
||||||
|
if t1.typ != number || t2.typ != number {
|
||||||
|
return fmt.Errorf("Both arguments must be number, got op1 = %+v, op2 = %+v", t1, t2)
|
||||||
|
}
|
||||||
|
min := t1.ivalue
|
||||||
|
if t2.ivalue < min {
|
||||||
|
min = t2.ivalue
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: min,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
"len": func(ts *TokenStack) error {
|
||||||
|
t := ts.Pop()
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: len(t.value),
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
"atoi": func(ts *TokenStack) error {
|
||||||
|
t := ts.Pop()
|
||||||
|
if t.typ != str && t.typ != word {
|
||||||
|
return fmt.Errorf("atoi requires string argument, got %+v", t)
|
||||||
|
}
|
||||||
|
n, err := strconv.Atoi(t.value)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: n,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
"itoa": func(ts *TokenStack) error {
|
||||||
|
t := ts.Pop()
|
||||||
|
if t.typ != number {
|
||||||
|
return fmt.Errorf("itoa requires number argument, got %+v", t)
|
||||||
|
}
|
||||||
|
s := strconv.Itoa(t.ivalue)
|
||||||
|
ts.Push(Token{
|
||||||
|
typ: str,
|
||||||
|
value: s,
|
||||||
|
})
|
||||||
|
return nil
|
||||||
|
},
|
||||||
|
}
|
||||||
80
token.go
Normal file
80
token.go
Normal file
|
|
@ -0,0 +1,80 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
type Token struct {
|
||||||
|
typ lexType
|
||||||
|
value string
|
||||||
|
ivalue int
|
||||||
|
priority int
|
||||||
|
leftAssoc bool
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t Token) Number() (int, bool) {
|
||||||
|
return t.ivalue, t.typ == number
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t Token) String() (string, bool) {
|
||||||
|
return t.value, t.typ == str
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t Token) Word() (string, bool) {
|
||||||
|
return t.value, t.typ == word
|
||||||
|
}
|
||||||
|
|
||||||
|
func TokenFromAny(variable any) (Token, bool) {
|
||||||
|
if s, ok := variable.(string); ok {
|
||||||
|
return Token{
|
||||||
|
typ: str,
|
||||||
|
value: s,
|
||||||
|
}, true
|
||||||
|
}
|
||||||
|
if n, ok := variable.(int); ok {
|
||||||
|
return Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: n,
|
||||||
|
}, true
|
||||||
|
}
|
||||||
|
if n, ok := variable.(float64); ok {
|
||||||
|
return Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: int(n),
|
||||||
|
}, true
|
||||||
|
}
|
||||||
|
if n, ok := variable.(float32); ok {
|
||||||
|
return Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: int(n),
|
||||||
|
}, true
|
||||||
|
}
|
||||||
|
if b, ok := variable.(bool); ok {
|
||||||
|
n := 0
|
||||||
|
if b {
|
||||||
|
n = 1
|
||||||
|
}
|
||||||
|
return Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: n,
|
||||||
|
}, true
|
||||||
|
}
|
||||||
|
return Token{}, false
|
||||||
|
}
|
||||||
|
|
||||||
|
func TokenFromWord(wordName string) Token {
|
||||||
|
return Token{
|
||||||
|
typ: word,
|
||||||
|
value: wordName,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TokenFromString(s string) Token {
|
||||||
|
return Token{
|
||||||
|
typ: str,
|
||||||
|
value: s,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TokenFromInt(n int) Token {
|
||||||
|
return Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: n,
|
||||||
|
}
|
||||||
|
}
|
||||||
93
tokenizer.go
Normal file
93
tokenizer.go
Normal file
|
|
@ -0,0 +1,93 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"strconv"
|
||||||
|
)
|
||||||
|
|
||||||
|
func (l *Lexpr) tokenize(ctx context.Context, lexems <-chan lexem) <-chan Token {
|
||||||
|
out := make(chan Token)
|
||||||
|
go func() {
|
||||||
|
defer close(out)
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ctx.Done():
|
||||||
|
return
|
||||||
|
case lexem, ok := <-lexems:
|
||||||
|
if !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
switch {
|
||||||
|
case lexem.Type == lp:
|
||||||
|
out <- Token{
|
||||||
|
typ: lp,
|
||||||
|
}
|
||||||
|
case lexem.Type == rp:
|
||||||
|
out <- Token{
|
||||||
|
typ: rp,
|
||||||
|
}
|
||||||
|
case lexem.Type == sep:
|
||||||
|
out <- Token{
|
||||||
|
typ: sep,
|
||||||
|
}
|
||||||
|
case lexem.Type == number:
|
||||||
|
ivalue, _ := strconv.Atoi(lexem.Value)
|
||||||
|
out <- Token{
|
||||||
|
typ: number,
|
||||||
|
ivalue: ivalue,
|
||||||
|
}
|
||||||
|
case lexem.Type == str:
|
||||||
|
out <- Token{
|
||||||
|
typ: str,
|
||||||
|
value: lexem.Value,
|
||||||
|
}
|
||||||
|
case lexem.Type == op:
|
||||||
|
o, isOp := l.operators[lexem.Value]
|
||||||
|
if !isOp {
|
||||||
|
out <- Token{
|
||||||
|
typ: tokError,
|
||||||
|
value: fmt.Sprintf("unknown operator: %s", lexem.Value),
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
out <- Token{
|
||||||
|
typ: op,
|
||||||
|
value: lexem.Value,
|
||||||
|
priority: o.priority,
|
||||||
|
leftAssoc: o.leftAssoc,
|
||||||
|
}
|
||||||
|
case lexem.Type == word:
|
||||||
|
o, isOp := l.operators[lexem.Value]
|
||||||
|
_, isFunc := l.functions[lexem.Value]
|
||||||
|
switch {
|
||||||
|
case isOp:
|
||||||
|
out <- Token{
|
||||||
|
typ: op,
|
||||||
|
value: lexem.Value,
|
||||||
|
priority: o.priority,
|
||||||
|
leftAssoc: o.leftAssoc,
|
||||||
|
}
|
||||||
|
case isFunc:
|
||||||
|
out <- Token{
|
||||||
|
typ: funct,
|
||||||
|
value: lexem.Value,
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
out <- Token{
|
||||||
|
typ: word,
|
||||||
|
value: lexem.Value,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
case lexem.Type == tokError:
|
||||||
|
out <- Token{
|
||||||
|
typ: tokError,
|
||||||
|
value: lexem.Value,
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
return out
|
||||||
|
}
|
||||||
157
tokenizer_test.go
Normal file
157
tokenizer_test.go
Normal file
|
|
@ -0,0 +1,157 @@
|
||||||
|
package lexpr
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestLexpr_tokenize(t *testing.T) {
|
||||||
|
type args struct {
|
||||||
|
lexems []lexem
|
||||||
|
}
|
||||||
|
tests := []struct {
|
||||||
|
name string
|
||||||
|
args args
|
||||||
|
want []Token
|
||||||
|
}{
|
||||||
|
{
|
||||||
|
name: "math",
|
||||||
|
args: args{
|
||||||
|
lexems: []lexem{
|
||||||
|
{
|
||||||
|
Type: word,
|
||||||
|
Value: "min",
|
||||||
|
}, {
|
||||||
|
Type: lp,
|
||||||
|
Value: "(",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "3",
|
||||||
|
}, {
|
||||||
|
Type: sep,
|
||||||
|
Value: ",",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "2",
|
||||||
|
}, {
|
||||||
|
Type: rp,
|
||||||
|
Value: ")",
|
||||||
|
}, {
|
||||||
|
Type: word,
|
||||||
|
Value: "*",
|
||||||
|
}, {
|
||||||
|
Type: word,
|
||||||
|
Value: "max",
|
||||||
|
}, {
|
||||||
|
Type: lp,
|
||||||
|
Value: "(",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "10",
|
||||||
|
}, {
|
||||||
|
Type: sep,
|
||||||
|
Value: ",",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "20",
|
||||||
|
}, {
|
||||||
|
Type: rp,
|
||||||
|
Value: ")",
|
||||||
|
}, {
|
||||||
|
Type: word,
|
||||||
|
Value: "==",
|
||||||
|
}, {
|
||||||
|
Type: number,
|
||||||
|
Value: "40",
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
want: []Token{
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "min",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: lp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 3,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: sep,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 2,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: rp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "*",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 120,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: funct,
|
||||||
|
value: "max",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: lp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 10,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: sep,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 20,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: rp,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: op,
|
||||||
|
value: "==",
|
||||||
|
ivalue: 0,
|
||||||
|
priority: 20,
|
||||||
|
leftAssoc: false,
|
||||||
|
},
|
||||||
|
{
|
||||||
|
typ: number,
|
||||||
|
ivalue: 40,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
l := &Lexpr{
|
||||||
|
operators: Operators,
|
||||||
|
functions: Functions,
|
||||||
|
}
|
||||||
|
lexemsCh := make(chan lexem)
|
||||||
|
go func() {
|
||||||
|
defer close(lexemsCh)
|
||||||
|
for _, l := range tt.args.lexems {
|
||||||
|
lexemsCh <- l
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
gotCh := l.tokenize(context.Background(), lexemsCh)
|
||||||
|
got := []Token{}
|
||||||
|
for o := range gotCh {
|
||||||
|
got = append(got, o)
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(got, tt.want) {
|
||||||
|
t.Errorf("Lexpr.tokenize() = \n%v, want \n%v", got, tt.want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue