added operator './' (float division) and test

operator-prod.go

@@ -91,8 +91,43 @@ func evalDivide(ctx exprContext, self *term) (v any, err error) {
 	return
 }
 
+//-------- divide as float term
+
+func newDivideAsFloatTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		class:    classOperator,
+		kind:     kindUnknown,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priProduct,
+		evalFunc: evalDivideAsFloat,
+	}
+}
+
+func evalDivideAsFloat(ctx exprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if isNumber(leftValue) && isNumber(rightValue) {
+		d := numAsFloat(rightValue)
+		if d == 0.0 {
+			err = errors.New("division by zero")
+		} else {
+			v = numAsFloat(leftValue) / d
+		}
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
 // init
 func init() {
 	registerTermConstructor(SymStar, newMultiplyTerm)
 	registerTermConstructor(SymSlash, newDivideTerm)
+	registerTermConstructor(SymDotSlash, newDivideAsFloatTerm)
 }

parser_test.go

@@ -106,10 +106,6 @@ func TestParser(t *testing.T) {
 	ctx.SetValue("var2", "abc")
 
 	inputs := []inputType{
-		{`123`, int64(123), nil},
-		{`1.`, float64(1.0), nil},
-		{`1.E-2`, float64(0.01), nil},
-		{`1E2`, float64(100), nil},
 		/*  1 */ {`1+/*5*/2`, int64(3), nil},
 		/*  2 */ {`3 == 4`, false, nil},
 		/*  3 */ {`3 != 4`, true, nil},
@@ -184,6 +180,13 @@ func TestParser(t *testing.T) {
 		/* 72 */ {"4 / 0", nil, errors.New(`division by zero`)},
 		/* 73 */ {"4.0 / 0", nil, errors.New(`division by zero`)},
 		/* 74 */ {"4.0 / \n2", float64(2.0), nil},
+		/* 75 */ {`123`, int64(123), nil},
+		/* 76 */ {`1.`, float64(1.0), nil},
+		/* 77 */ {`1.E-2`, float64(0.01), nil},
+		/* 78 */ {`1E2`, float64(100), nil},
+		/* 79 */ {`1 / 2`, int64(0), nil},
+		/* 80 */ {`1.0 / 2`, float64(0.5), nil},
+		/* 81 */ {`1 ./ 2`, float64(0.5), nil},
 	}
 
 	parser := NewParser(ctx)

scanner.go

@@ -148,6 +148,8 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 		case '.':
 			if next, _ := self.peek(); next >= '0' && next <= '9' {
 				tk = self.parseNumber(ch)
+			} else if next == '/' {
+				tk = self.moveOn(SymDotSlash, ch, next)
 			} else {
 				tk = self.makeToken(SymDot, ch)
 			}

symbol.go

@@ -27,8 +27,9 @@ const (
 	SymColon                             //  16: ':'
 	SymSemiColon                         //  17: ';'
 	SymDot                               //  18: '.'
-	SymQuote                             //  19: '\''
+	SymDotSlash                          //  19: './'
-	SymDoubleQuote                       //  20: '"'
+	SymQuote                             //  20: '\''
+	SymDoubleQuote                       //  21: '"'
 	SymBackTick                          //   0: '`'
 	SymExclamation                       //   0: '!'
 	SymQuestion                          //   0: '?'