support ParseAst and EnableAstCache

Author: shockerli

spiker.go

@@ -1,20 +1,20 @@
 package spiker
 
-import "strings"
+import (
+	"crypto/sha1"
+	"strings"
+	"sync"
+)
 
-// Execute return the computed result of a string expression
-func Execute(code string) (val interface{}, err error) {
-	code = padSemicolon(code)
-
-	lexer := NewLexer(code)
-	p := Parser{Lexer: lexer}
+// EnableAstCache enable ast cache, default is false
+var EnableAstCache = false
 
-	stmts, err := p.Statements()
-	if err != nil {
-		return
-	}
+// cachedAst cached ast node map
+var cachedAst = sync.Map{}
 
-	ast, err := Transform(stmts)
+// Execute return the computed result of a string expression
+func Execute(code string) (val interface{}, err error) {
+	ast, err := ParseAst(code)
 	if err != nil {
 		return
 	}
@@ -24,42 +24,60 @@ func Execute(code string) (val interface{}, err error) {
 
 // ExecuteWithScope return the execute result with scope
 func ExecuteWithScope(code string, scope *VariableScope) (val interface{}, err error) {
-	code = padSemicolon(code)
-
-	lexer := NewLexer(code)
-	p := Parser{Lexer: lexer}
-
-	stmts, err := p.Statements()
+	ast, err := ParseAst(code)
 	if err != nil {
 		return
 	}
 
-	ast, err := Transform(stmts)
+	return EvaluateWithScope(ast, scope)
+}
+
+// Format return the formatted expression
+func Format(code string) (s string, err error) {
+	ast, err := ParseAst(code)
 	if err != nil {
 		return
 	}
 
-	return EvaluateWithScope(ast, scope)
+	return FormatAst(ast)
 }
 
-// Format return the formatted expression
-func Format(code string) (s string, err error) {
+// ParseAst lexer, statements, transform, and return the ast nodes
+// if EnableAstCache is true, it will cache the ast nodes
+func ParseAst(code string) (ast []AstNode, err error) {
+	// get cached ast nodes
+	hashKey := sha1.Sum([]byte(code))
+	if EnableAstCache {
+		if ast, ok := cachedAst.Load(hashKey); ok {
+			return ast.([]AstNode), nil
+		}
+	}
+
+	// padding semicolon
 	code = padSemicolon(code)
 
+	// lexer, parser, transform
 	lexer := NewLexer(code)
 	p := Parser{Lexer: lexer}
 
+	// parse statements
 	stmts, err := p.Statements()
 	if err != nil {
 		return
 	}
 
-	ast, err := Transform(stmts)
+	// transform to ast nodes
+	ast, err = Transform(stmts)
 	if err != nil {
 		return
 	}
 
-	return FormatAst(ast)
+	// cache ast nodes
+	if EnableAstCache {
+		cachedAst.Store(hashKey, ast)
+	}
+
+	return
 }
 
 // padding semicolon

spiker_test.go

@@ -103,6 +103,19 @@ func BenchmarkExecute(b *testing.B) {
 	}
 }
 
+func BenchmarkParseAst(b *testing.B) {
+	spiker.EnableAstCache = true // enable ast cache
+	src := readFile("testdata/collect.src")
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		if _, err := spiker.ParseAst(src); err != nil {
+			b.Log(err)
+			b.Fail()
+		}
+	}
+}
+
 func TestFormat(t *testing.T) {
 	tests := []struct {
 		input  string