Added support to op-assign operators like '+='.

This feature is implemented by expansion, not by dedicated operators, e.g. a*=2+x is exapanded as a=a*(2+x)

parser.go

@@ -19,7 +19,8 @@ func NewParser() (p *parser) {
 }
 
 func (parser *parser) Next(scanner *scanner) (tk *Token) {
-	for tk=scanner.Next(); tk.IsSymbol(SymComment); tk=scanner.Next() {}
+	for tk = scanner.Next(); tk.IsSymbol(SymComment); tk = scanner.Next() {
+	}
 	return
 }
 
@@ -304,7 +305,7 @@ func addSelectorCase(selectorTerm, caseTerm *term) {
 func (parser *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) {
 	var caseTerm *term
 	tk := scanner.makeToken(SymSelector, '?')
-	if selectorTerm, err = tree.addToken2(tk); err != nil {
+	if selectorTerm, err = tree.addToken(tk); err != nil {
 		return
 	}
 
@@ -342,13 +343,14 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 	var selectorTerm *term = nil
 	var currentTerm *term = nil
 	var tk *Token
+
 	tree = NewAst()
 	firstToken := true
 	// lastSym := SymUnknown
 	for tk = parser.Next(scanner); err == nil && tk != nil && !tk.IsTerm(termSymbols); /*&& !areSymbolsOutOfCtx(tk, selectorTerm, SymColon, SymDoubleColon)*/ tk = parser.Next(scanner) {
-		if tk.Sym == SymComment {
-			continue
-		}
+		// if tk.Sym == SymComment {
+		// 	continue
+		// }
 
 		if tk.Sym == SymSemiColon {
 			if allowForest {
@@ -414,7 +416,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 			}
 		case SymEqual:
 			// if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 			// }
 		case SymFuncDef:
 			var funcDefTerm *term
@@ -432,7 +434,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 			if tk.source[0] == '@' && !allowVarRef {
 				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
 		case SymQuestion:
 			if selectorTerm, err = parser.parseSelector(scanner, tree, allowVarRef); err == nil {
@@ -449,14 +451,16 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 					}
 				}
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
 			if tk.IsSymbol(SymColon) {
 				// Colon outside a selector term acts like a separator
 				firstToken = true
 			}
+		case SymPlusEqual, SymMinusEqual, SymStarEqual:
+			currentTerm, err = parser.expandOpAssign(scanner, tree, tk, allowVarRef)
 		default:
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 		}
 
 		if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
@@ -465,6 +469,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 		}
 		// lastSym = tk.Sym
 	}
+
 	if err == nil {
 		err = tk.Error()
 	}
@@ -477,3 +482,49 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 // 	}
 // 	return
 // }
+
+func (parser *parser) expandOpAssign(scanner * scanner, tree *ast, tk *Token, allowVarRef bool) (t *term, err error) {
+	var opSym Symbol
+	var opString string
+
+	if tree.root != nil {
+		switch tk.Sym {
+		case SymPlusEqual:
+			opString = "+"
+			opSym = SymPlus
+		case SymMinusEqual:
+			opString = "-"
+			opSym = SymMinus
+		case SymStarEqual:
+			opString = "*"
+			opSym = SymStar
+		default:
+			err = tk.Errorf("unsopported operator %q", tk.source)
+			return
+		}
+		leftExpr := tree.root.Clone()
+		leftExpr.setParent(nil)
+		if t, err = tree.addToken(NewToken(tk.row, tk.col, SymEqual, "=")); err == nil {
+			t = leftExpr
+			if err = tree.addTerm(leftExpr); err == nil {
+				if t, err = tree.addToken(NewToken(tk.row, tk.col, opSym, opString)); err == nil {
+
+					var subTree *ast
+					if subTree, err = parser.parseGeneral(scanner, false, allowVarRef, SymSemiColon, SymClosedRound); err == nil {
+						if scanner.Previous().IsOneOfA(SymSemiColon, SymClosedRound) {
+							if err = scanner.UnreadToken(); err != nil {
+								return
+							}
+						}
+						subTree.root.priority = priValue
+						err = tree.addTerm(newExprTerm(subTree.root))
+						t = subTree.root
+					}
+				}
+			}
+		}
+	} else {
+		err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
+	}
+	return
+}