use parser less

katydid · Jan 17, 2025 · 28d21df · 28d21df
1 parent 5b344d2
commit 28d21df
Show file tree

Hide file tree

Showing 5 changed files with 28 additions and 175 deletions.
diff --git a/validator/combinator/funcs.go b/validator/combinator/funcs.go
@@ -16,7 +16,6 @@ package combinator
 
 import (
 	"github.com/katydid/validator-go/validator/ast"
-	"github.com/katydid/validator-go/validator/parser"
 	"github.com/katydid/validator-go/validator/types"
 )
 
@@ -40,11 +39,7 @@ func Value(expr *ast.Expr) *ast.Pattern {
 			}
 		}
 	}
-	e, err := parser.ParseExpr(expr.String())
-	if err != nil {
-		panic(err)
-	}
-	return ast.NewLeafNode(e)
+	return ast.NewLeafNode(expr)
 }
 
 func Eq(left, right *ast.Expr) *ast.Expr {

diff --git a/validator/compose/error_test.go b/validator/compose/error_test.go
@@ -18,18 +18,13 @@ import (
 	"testing"
 
 	"github.com/katydid/parser-go/parser/debug"
+	"github.com/katydid/validator-go/validator/ast"
+	. "github.com/katydid/validator-go/validator/combinator"
 	"github.com/katydid/validator-go/validator/compose"
-	. "github.com/katydid/validator-go/validator/funcs"
-	"github.com/katydid/validator-go/validator/parser"
 )
 
 func TestNoEqualError(t *testing.T) {
-	exprStr := Sprint(StringEq(ElemStrings(NewListOfString([]String{StringVar()}), IntConst(3)), StringConst("0123456789")))
-	t.Logf(exprStr)
-	e, err := parser.NewParser().ParseExpr(exprStr)
-	if err != nil {
-		t.Fatal(err)
-	}
+	e := Eq(ast.NewFunction("elem", ast.NewStringList(StringVar()), IntConst(3)), StringConst("0123456789"))
 	b, err := compose.NewBool(e)
 	if err != nil {
 		t.Fatal(err)

diff --git a/validator/intern/pattern.go b/validator/intern/pattern.go
@@ -16,11 +16,10 @@ package intern
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/katydid/validator-go/validator/ast"
 	"github.com/katydid/validator-go/validator/funcs"
-	nameexpr "github.com/katydid/validator-go/validator/name"
-	"github.com/katydid/validator-go/validator/parser"
 )
 
 type PatternType int
@@ -54,104 +53,51 @@ func (p *Pattern) GoString() string {
 	return fmt.Sprintf("&%#v", *p)
 }
 
-func (p *Pattern) NewAst() *ast.Pattern {
-	pp, err := newASTPattern(p)
-	if err != nil {
-		panic(err)
+func joinPatterns(patterns []*Pattern, sep string) string {
+	ss := make([]string, len(patterns))
+	for i, p := range patterns {
+		ss[i] = p.String()
 	}
-	return pp
+	return strings.Join(ss, sep)
 }
 
-func newASTPattern(p *Pattern) (*ast.Pattern, error) {
+func (p *Pattern) String() string {
+	if p == nil {
+		return ""
+	}
 	switch p.Type {
 	case Empty:
-		return ast.NewEmpty(), nil
+		return ast.NewEmpty().String()
 	case Node:
 		if isEmpty(p.Patterns[0]) {
-			exprStr := funcs.Sprint(p.Func)
-			expr, err := parser.NewParser().ParseExpr(exprStr)
-			if err != nil {
-				return nil, err
-			}
-			return ast.NewLeafNode(expr), nil
+			return funcs.Sprint(p.Func)
 		} else {
-			name, err := nameexpr.FuncToName(p.Func)
-			if err != nil {
-				return nil, err
-			}
-			p, err := newASTPattern(p.Patterns[0])
-			if err != nil {
-				return nil, err
-			}
-			return ast.NewTreeNode(name, p), nil
+			return p.Func.String() + ":" + p.Patterns[0].String()
 		}
 	case Concat:
-		ps, err := traverse(newASTPattern, p.Patterns)
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewConcat(ps...), nil
+		return "[" + joinPatterns(p.Patterns, ", ") + "]"
 	case Or:
-		ps, err := traverse(newASTPattern, p.Patterns)
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewOr(ps...), nil
+		return "(" + joinPatterns(p.Patterns, " | ") + ")"
 	case And:
-		ps, err := traverse(newASTPattern, p.Patterns)
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewAnd(ps...), nil
+		return "(" + joinPatterns(p.Patterns, " & ") + ")"
 	case ZeroOrMore:
-		pp, err := newASTPattern(p.Patterns[0])
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewZeroOrMore(pp), nil
+		return "(" + p.Patterns[0].String() + ")*"
 	case Reference:
-		return ast.NewReference(p.Ref), nil
+		return "@" + p.Ref
 	case Not:
-		pp, err := newASTPattern(p.Patterns[0])
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewNot(pp), nil
+		return "!(" + p.Patterns[0].String() + ")"
 	case ZAny:
-		return ast.NewZAny(), nil
+		return ast.NewZAny().String()
 	case Contains:
-		pp, err := newASTPattern(p.Patterns[0])
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewContains(pp), nil
+		return "." + p.Patterns[0].String()
 	case Optional:
-		pp, err := newASTPattern(p.Patterns[0])
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewOptional(pp), nil
+		return "(" + p.Patterns[0].String() + ")?"
 	case Interleave:
-		ps, err := traverse(newASTPattern, p.Patterns)
-		if err != nil {
-			return nil, err
-		}
-		return ast.NewInterleave(ps...), nil
+		return "{" + joinPatterns(p.Patterns, "; ") + "}"
 	}
 	panic(fmt.Sprintf("unknown pattern: %d", p.Type))
 }
 
-func (p *Pattern) String() string {
-	if p == nil {
-		return ""
-	}
-	st, err := newASTPattern(p)
-	if err != nil {
-		return fmt.Sprintf("could not get ast of: %v", *p)
-	}
-	return st.String()
-}
-
 func (p *Pattern) Equal(pp *Pattern) bool {
 	if p.hash != pp.hash {
 		return false

diff --git a/validator/mem/inject_test.go b/validator/mem/inject_test.go
@@ -23,7 +23,6 @@ import (
 	. "github.com/katydid/validator-go/validator/combinator"
 	"github.com/katydid/validator-go/validator/funcs"
 	"github.com/katydid/validator-go/validator/mem"
-	validatorparser "github.com/katydid/validator-go/validator/parser"
 )
 
 func newInjectable() *injectableInt {
@@ -70,15 +69,9 @@ func (this *injectableInt) HasVariable() bool {
 
 func init() {
 	funcs.Register("inject", newInjectable)
-
-	parsedGrammar, err := validatorparser.ParseGrammar("Num:->eq($int, inject())")
-	if err != nil {
-		panic(err)
-	}
-	injectNumber = G(ast.NewRefLookup(parsedGrammar))
 }
 
-var injectNumber = G{}
+var injectNumber = G(map[string]*ast.Pattern{"main": In("Num", Value(Eq(IntVar(), ast.NewFunction("inject"))))})
 
 type Number struct {
 	Num int64

diff --git a/validator/name/name.go b/validator/name/name.go
@@ -22,7 +22,6 @@ import (
 	"github.com/katydid/validator-go/validator/ast"
 	"github.com/katydid/validator-go/validator/compose"
 	"github.com/katydid/validator-go/validator/funcs"
-	validatorparser "github.com/katydid/validator-go/validator/parser"
 )
 
 // EvalName evaluates a name expression given a name value.
@@ -67,78 +66,3 @@ func NameToFunc(n *ast.NameExpr) funcs.Bool {
 	}
 	panic(fmt.Sprintf("unknown name expr typ %T", typ))
 }
-
-// FuncToName decompiles a function back into a name expression, if possible.
-func FuncToName(f funcs.Bool) (*ast.NameExpr, error) {
-	exprStr := funcs.Sprint(f)
-	expr, err := validatorparser.NewParser().ParseExpr(exprStr)
-	if err != nil {
-		return nil, err
-	}
-	return exprToName(expr)
-}
-
-func exprToName(e *ast.Expr) (*ast.NameExpr, error) {
-	if e.GetBuiltIn() != nil {
-		if e.GetBuiltIn().GetSymbol().String() == "==" {
-			if e.GetBuiltIn().GetExpr().GetTerminal() != nil {
-				t := e.GetBuiltIn().GetExpr().GetTerminal()
-				if t.DoubleValue != nil {
-					return ast.NewDoubleName(t.GetDoubleValue()), nil
-				}
-				if t.IntValue != nil {
-					return ast.NewIntName(t.GetIntValue()), nil
-				}
-				if t.UintValue != nil {
-					return ast.NewUintName(t.GetUintValue()), nil
-				}
-				if t.BoolValue != nil {
-					return ast.NewBoolName(t.GetBoolValue()), nil
-				}
-				if t.StringValue != nil {
-					return ast.NewStringName(t.GetStringValue()), nil
-				}
-				if t.BytesValue != nil {
-					return ast.NewBytesName(t.GetBytesValue()), nil
-				}
-			} else {
-				return nil, fmt.Errorf("unknown terminal: %v", e.GetBuiltIn().GetExpr())
-			}
-		} else {
-			return nil, fmt.Errorf("not equal: %v", e)
-		}
-	}
-	if e.GetFunction() != nil {
-		if e.GetFunction().GetName() == "not" {
-			e, err := exprToName(e.GetFunction().GetParams()[0])
-			if err != nil {
-				return nil, err
-			}
-			return ast.NewAnyNameExcept(e), nil
-		}
-		if e.GetFunction().GetName() == "or" {
-			e1, err := exprToName(e.GetFunction().GetParams()[0])
-			if err != nil {
-				return nil, err
-			}
-			e2, err := exprToName(e.GetFunction().GetParams()[1])
-			if err != nil {
-				return nil, err
-			}
-			return ast.NewNameChoice(e1, e2), nil
-		}
-		return nil, fmt.Errorf("unsupported function: %v", e)
-	}
-	if e.GetTerminal() != nil {
-		if e.GetTerminal().BoolValue != nil {
-			if e.GetTerminal().GetBoolValue() {
-				return ast.NewAnyName(), nil
-			} else {
-				return nil, fmt.Errorf("not true")
-			}
-		} else {
-			return nil, fmt.Errorf("not bool")
-		}
-	}
-	return nil, fmt.Errorf("unsupported expression: %v", e)
-}