Expressions now support function definition

parser.go

@@ -5,6 +5,7 @@
 package expr
 
 import (
+	"errors"
 	"fmt"
 )
 
@@ -21,22 +22,23 @@ func NewParser(ctx exprContext) (p *parser) {
 	return p
 }
 
-func (self *parser) parseFunction(scanner *scanner, tk *Token) (tree *term, err error) {
-	name, _ := tk.Value.(string)
-	funcObj := self.ctx.GetFuncInfo(name)
-	if funcObj == nil {
-		err = fmt.Errorf("unknown function %s()", name)
-		return
-	}
-	maxArgs := funcObj.MaxArgs()
-	if maxArgs < 0 {
-		maxArgs = funcObj.MinArgs() + 10
-	}
-	args := make([]*term, 0, maxArgs)
+func (self *parser) parseFuncCall(scanner *scanner, tk *Token) (tree *term, err error) {
+	// name, _ := tk.Value.(string)
+	// funcObj := self.ctx.GetFuncInfo(name)
+	// if funcObj == nil {
+	// 	err = fmt.Errorf("unknown function %s()", name)
+	// 	return
+	// }
+	// maxArgs := funcObj.MaxArgs()
+	// if maxArgs < 0 {
+	// 	maxArgs = funcObj.MinArgs() + 10
+	// }
+	// args := make([]*term, 0, maxArgs)
+	args := make([]*term, 0, 10)
 	lastSym := SymUnknown
 	for lastSym != SymClosedRound && lastSym != SymEos {
 		var subTree *ast
-		if subTree, err = self.parse(scanner, SymComma, SymClosedRound); err == nil {
+		if subTree, err = self.parseItem(scanner, SymComma, SymClosedRound); err == nil {
 			if subTree.root != nil {
 				args = append(args, subTree.root)
 			}
@@ -47,7 +49,47 @@ func (self *parser) parseFunction(scanner *scanner, tk *Token) (tree *term, err
 	}
 	if err == nil {
 		// TODO Check arguments
-		tree = newFuncTerm(tk, args)
+		if lastSym != SymClosedRound {
+			err = errors.New("unterminate arguments list")
+		} else {
+			tree = newFuncCallTerm(tk, args)
+		}
+	}
+	return
+}
+
+func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
+	// Example: "add = func(x,y) {x+y}
+	var body *ast
+	args := make([]*term, 0)
+	tk := scanner.Next()
+	for tk.Sym != SymClosedRound && tk.Sym != SymEos {
+		if tk.Sym == SymIdentifier {
+			t := newTerm(tk, nil)
+			args = append(args, t)
+		} else {
+			err = tk.Errorf("invalid param %q, variable identifier expected", tk.source)
+			break
+		}
+		tk = scanner.Next()
+	}
+	if err == nil && tk.Sym != SymClosedRound {
+		err = tk.Errorf("unterminate function params list")
+	}
+	if err == nil {
+		tk = scanner.Next()
+		if tk.Sym == SymOpenBrace {
+			body, err = self.parseGeneral(scanner, true, SymClosedBrace)
+		}
+	}
+	if err == nil {
+		// TODO Check arguments
+		if scanner.Previous().Sym != SymClosedBrace {
+			err = scanner.Previous().Errorf("unterminate function body")
+		} else {
+			tk = scanner.makeValueToken(SymExpression, "", body)
+			tree = newFuncDefTerm(tk, args)
+		}
 	}
 	return
 }
@@ -57,7 +99,7 @@ func (self *parser) parseList(scanner *scanner) (tree *term, err error) {
 	lastSym := SymUnknown
 	for lastSym != SymClosedSquare && lastSym != SymEos {
 		var subTree *ast
-		if subTree, err = self.parse(scanner, SymComma, SymClosedSquare); err == nil {
+		if subTree, err = self.parseItem(scanner, SymComma, SymClosedSquare); err == nil {
 			if subTree.root != nil {
 				args = append(args, subTree.root)
 			}
@@ -68,12 +110,24 @@ func (self *parser) parseList(scanner *scanner) (tree *term, err error) {
 	}
 	if err == nil {
 		// TODO Check arguments
-		tree = newListTerm(args)
+		if lastSym != SymClosedSquare {
+			err = scanner.Previous().Errorf("unterminate items list")
+		} else {
+			tree = newListTerm(args)
+		}
 	}
 	return
 }
 
 func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
+	return self.parseGeneral(scanner, true, termSymbols...)
+}
+
+func (self *parser) parseItem(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
+	return self.parseGeneral(scanner, false, termSymbols...)
+}
+
+func (self *parser) parseGeneral(scanner *scanner, allowForset bool, termSymbols ...Symbol) (tree *ast, err error) {
 	tree = NewAst()
 	firstToken := true
 	lastSym := SymUnknown
@@ -83,19 +137,25 @@ func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, e
 		}
 
 		if tk.Sym == SymSemiColon {
-			tree.ToForest()
-			continue
+			if allowForset {
+				tree.ToForest()
+				continue
+			} else {
+				err = tk.Errorf(`unexpected token %q, expected ",", "]", or ")"`, tk.source)
+				break
+			}
 		}
 
 		//fmt.Println("Token:", tk)
-		if firstToken && (tk.Sym == SymMinus || tk.Sym == SymPlus) {
+		if firstToken {
 			if tk.Sym == SymMinus {
 				tk.Sym = SymChangeSign
-			} else {
+			} else if tk.Sym == SymPlus {
 				tk.Sym = SymUnchangeSign
 			}
+			firstToken = false
 		}
-		firstToken = false
+
 		switch tk.Sym {
 		case SymOpenRound:
 			var subTree *ast
@@ -103,10 +163,10 @@ func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, e
 				subTree.root.priority = priValue
 				tree.addTerm(subTree.root)
 			}
-		case SymFunction:
-			var funcTerm *term
-			if funcTerm, err = self.parseFunction(scanner, tk); err == nil {
-				err = tree.addTerm(funcTerm)
+		case SymFuncCall:
+			var funcCallTerm *term
+			if funcCallTerm, err = self.parseFuncCall(scanner, tk); err == nil {
+				err = tree.addTerm(funcCallTerm)
 			}
 		case SymOpenSquare:
 			var listTerm *term
@@ -114,10 +174,13 @@ func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, e
 				err = tree.addTerm(listTerm)
 			}
 		case SymEqual:
-			if lastSym == SymIdentifier {
+			if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
 				err = tree.addToken(tk)
-			} else {
-				err = fmt.Errorf(`assign operator (%q) must be preceded by a variable`, tk.source)
+			}
+		case SymFuncDef:
+			var funcDefTerm *term
+			if funcDefTerm, err = self.parseFuncDef(scanner); err == nil {
+				err = tree.addTerm(funcDefTerm)
 			}
 		default:
 			err = tree.addToken(tk)
@@ -126,3 +189,10 @@ func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, e
 	}
 	return
 }
+
+func checkPrevSymbol(lastSym, wantedSym Symbol, tk *Token) (err error) {
+	if lastSym != wantedSym {
+		err = fmt.Errorf(`assign operator (%q) must be preceded by a variable`, tk.source)
+	}
+	return
+}