stable commit

Author: jungleedevansh

eval.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"errors"
+	"math"
 	"strconv"
 )
 
@@ -15,6 +16,20 @@ func evalNumber(ast *astNode) (any, error) {
 	return strconv.ParseFloat(string(ast.token.val), 64)
 }
 
+func evalUnary(ast *astNode) (any, error) {
+	right, err := eval(ast.right)
+	if err != nil {
+		return nil, err
+	}
+	switch ast.token.tokenType {
+	case Minus:
+		return -right.(float64), nil
+	case Not:
+		return !right.(bool), nil
+	}
+	return nil, nil
+}
+
 func evalInfix(ast *astNode) (any, error) {
 	var left, right any
 	left, err := eval(ast.left)
@@ -43,6 +58,9 @@ func evalInfix(ast *astNode) (any, error) {
 	case Mod:
 		return float64(int64(leftF) % int64(rightF)), nil
 
+	case RaisePower:
+		return math.Pow(leftF, rightF), nil
+
 	case LT:
 		return leftF < rightF, nil
 	case GT:
@@ -53,7 +71,9 @@ func evalInfix(ast *astNode) (any, error) {
 		return leftF >= rightF, nil
 	case Eq:
 		return leftF == rightF, nil
+	case NotEq:
+		return leftF != rightF, nil
 
 	}
-	return 0, nil // Need to take care of this
+	return nil, nil // Need to take care of this
 }

eval_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestEval(t *testing.T) {
-	lexer := NewLexer(bytes.NewReader([]byte("(2*3*2+32) == 8")))
+	lexer := NewLexer(bytes.NewReader([]byte("(2+3)*(6/2)*(4**4**(4-3))")))
 
 	err := lexer.Analyze()
 	if err != nil {
@@ -22,7 +22,7 @@ func TestEval(t *testing.T) {
 		t.Error("error occured while evaluting ast: ", err)
 		return
 	}
-	expectedVal := false
+	expectedVal := 65536.0
 	if actualResult != expectedVal {
 		t.Errorf("Wrong Evaluation Actual: %v, Expected: %v", actualResult, expectedVal)
 	}

lexer.go

@@ -27,92 +27,84 @@ func (lexer *Lexer) addT(token Token) {
 	lexer.tokenList = append(lexer.tokenList, token)
 }
 
-func (lexer *Lexer) retriveByte() byte {
-	bytes, err := lexer.reader.Peek(lexer.unProcessedBytes)
-	if err != nil {
-		lexer.lastErr = err
-		return 0
-	}
-	if lexer.unProcessedBytes > 0 {
-		return bytes[lexer.unProcessedBytes-1]
-	}
-	return 0
-}
-
 func (lexer *Lexer) eof() bool {
 	return lexer.lastErr != nil && lexer.lastErr == io.EOF
 }
 
-func (lexer *Lexer) nextByte() byte {
-	lexer.unProcessedBytes++
-	return lexer.retriveByte()
-}
-func (lexer *Lexer) prevByte() byte {
-	lexer.unProcessedBytes--
-	return lexer.retriveByte()
+func (lexer *Lexer) next() byte {
+	by, err := lexer.reader.ReadByte()
+	if err != nil {
+		lexer.lastErr = err
+		return 0
+	}
+	return by
 }
 
-func (lexer *Lexer) drain() {
-	_, lexer.lastErr = lexer.reader.Discard(lexer.unProcessedBytes)
-	lexer.unProcessedBytes = 0
+func (lexer *Lexer) peek() byte {
+	by, err := lexer.reader.Peek(1)
+	if err != nil {
+		lexer.lastErr = err
+		return 0
+	}
+	return by[0]
 }
 
 func (lexer *Lexer) anaEq() {
-	nextByte := lexer.nextByte()
+	nextByte := lexer.peek()
 	if !lexer.eof() && nextByte == '=' {
+		lexer.next() // consume
 		lexer.addT(NewToken(Eq, '=', '='))
 		return
 	}
 	lexer.addT(NewToken(Assign, '='))
-	lexer.prevByte()
 }
 
 func (lexer *Lexer) anaAsterisk() {
-	nextByte := lexer.nextByte()
+	nextByte := lexer.peek()
 	if !lexer.eof() && nextByte == '*' {
+		lexer.next() // consume
 		lexer.addT(NewToken(RaisePower, '*', '*'))
 		return
 	}
 	lexer.addT(NewToken(Asterisk, '*'))
-	lexer.prevByte()
 }
 
 func (lexer *Lexer) anaNot() {
-	nextByte := lexer.nextByte()
+	nextByte := lexer.peek()
 	if !lexer.eof() && nextByte == '=' {
+		lexer.next() // consume
 		lexer.addT(NewToken(NotEq, '!', '='))
 		return
 	}
 	lexer.addT(NewToken(Not, '!'))
-	lexer.prevByte()
 }
 
 func (lexer *Lexer) anaLT() {
-	nextByte := lexer.nextByte()
+	nextByte := lexer.peek()
 	if !lexer.eof() && nextByte == '=' {
+		lexer.next() //consume
 		lexer.addT(NewToken(LTEQ, '<', '='))
 		return
 	}
 	lexer.addT(NewToken(LT, '<'))
-	lexer.prevByte()
 
 }
 
 func (lexer *Lexer) anaGT() {
-	nextByte := lexer.nextByte()
+	nextByte := lexer.peek()
 	if !lexer.eof() && nextByte == '=' {
+		lexer.next() //consume
 		lexer.addT(NewToken(GTEQ, '>', '='))
 		return
 	}
 	lexer.addT(NewToken(GT, '>'))
-	lexer.prevByte()
 
 }
 
 func (lexer *Lexer) anaComment() {
 	lexer.addT(NewToken(CommentHash, '#'))
 	for {
-		nextByte := lexer.nextByte()
+		nextByte := lexer.next()
 		if lexer.eof() || nextByte == '\n' { // Read until next line
 			return
 		}
@@ -124,10 +116,12 @@ func (lexer *Lexer) anaDigits(startingDigit byte) error {
 	var fractionStarted bool
 
 	for {
-		nextByte := lexer.nextByte()
+		nextByte := lexer.peek()
 		if isDigit(nextByte) {
+			lexer.next() // consume
 			number = append(number, nextByte)
 		} else if nextByte == '.' {
+			lexer.next() //consume
 			if fractionStarted {
 				return illegalToken
 			}
@@ -136,7 +130,6 @@ func (lexer *Lexer) anaDigits(startingDigit byte) error {
 
 		} else {
 			lexer.addT(NewToken(Number, number...))
-			lexer.prevByte()
 			return nil
 		}
 	}
@@ -152,8 +145,7 @@ func isWhiteSpace(b byte) bool {
 }
 
 func (lexer *Lexer) Analyze() error {
-	for ; lexer.lastErr == nil; lexer.drain() {
-		nextByte := lexer.nextByte()
+	for nextByte := lexer.next(); lexer.lastErr == nil; nextByte = lexer.next() {
 
 		switch nextByte {
 		case '+':
@@ -180,6 +172,8 @@ func (lexer *Lexer) Analyze() error {
 			lexer.anaLT()
 		case '>':
 			lexer.anaGT()
+		case '!':
+			lexer.anaNot()
 		default:
 			if isDigit(nextByte) {
 				err := lexer.anaDigits(nextByte)

lexer_test.go

@@ -12,7 +12,7 @@ func TestLexer(t *testing.T) {
 			NewToken(Plus, '+'),
 			NewToken(Number, []byte("2.343")...),
 		},
-		"(<><=>= ===> =)": {
+		"(<><=>= ===> = != !)": {
 			NewToken(LeftBrace, '('),
 			NewToken(LT, '<'),
 			NewToken(GT, '>'),
@@ -22,6 +22,8 @@ func TestLexer(t *testing.T) {
 			NewToken(Assign, '='),
 			NewToken(GT, '>'),
 			NewToken(Assign, '='),
+			NewToken(NotEq, '!', '='),
+			NewToken(Not, '!'),
 			NewToken(RightBrace, ')'),
 		},
 	}

parser_combinators.go

@@ -27,40 +27,59 @@ func parsePrimary(pr *parser) *astNode {
 	return nil
 }
 
-// unary -> (-) unary | priamry
+// unary -> (- | !) unary | priamry
 func parseUnary(pr *parser) *astNode {
 	log.Print("inside unary")
 	token := pr.peek()
 	if pr.eof() {
 		return nil
 	}
-	if token.tokenType == Minus { // (-) unary
-		pr.next() // consuming minus
-		// not checking for eof as we have checked while calling peek()
-		return newASTNode(token, newASTNode(NewToken(Number, '0'), nilASTNode, nilASTNode, evalNumber), parseUnary(pr), evalInfix)
+	if token.tokenType == Minus || token.tokenType == Not {
+		pr.next() // consume minus or not
+		return newASTNode(token, nilASTNode, parseUnary(pr), evalUnary)
 	}
 
 	return parsePrimary(pr)
 
 }
 
-// factor -> unary ( ( "/" | "*" | "%" ) unary)*
-func parseFactor(pr *parser) *astNode {
-	log.Print("inside factor")
+func parseExponent(pr *parser) *astNode {
+	log.Print("inside exponent")
 
 	leftUnary := parseUnary(pr) // consume first unary
 	var parent = leftUnary
 
+	for token := pr.peek(); token.tokenType == RaisePower; token = pr.peek() {
+
+		if pr.eof() {
+			break // we are just breaking the rule as we in the recusrive expansion of (**) unary
+		}
+		pr.next() // consume  **
+		// not checkig for eof as we have checked while calling peek()
+		rightUnary := parseExponent(pr)
+
+		parent = newASTNode(token, parent, rightUnary, evalInfix) // exponent is right associated operation for us
+	}
+	return parent
+}
+
+// factor -> exponent ( ( "/" | "*" | "%" ) exponent)*
+func parseFactor(pr *parser) *astNode {
+	log.Print("inside factor")
+
+	leftExponent := parseExponent(pr) // consume first unary
+	var parent = leftExponent
+
 	for token := pr.peek(); token.tokenType == Mod || token.tokenType == Asterisk || token.tokenType == Slash; token = pr.peek() {
 
 		if pr.eof() {
 			break // we are just breaking the rule as we in the recusrive expansion of (*|/) unary
 		}
 		pr.next() // consume  * or /
 		// not checkig for eof as we have checked while calling peek()
-		rightUnary := parseUnary(pr)
+		rightExponent := parseFactor(pr) // Makr
 
-		parent = newASTNode(token, parent, rightUnary, evalInfix)
+		parent = newASTNode(token, parent, rightExponent, evalInfix)
 	}
 	return parent
 }
@@ -78,7 +97,7 @@ func parseTerm(pr *parser) *astNode {
 		}
 
 		pr.next() // consume + or -
-		rightUnary := parseFactor(pr)
+		rightUnary := parseTerm(pr)
 
 		parent = newASTNode(token, parent, rightUnary, evalInfix)
 
@@ -102,7 +121,7 @@ func parseComp(pr *parser) *astNode {
 		switch token.tokenType {
 		case LT, GT, LTEQ, GTEQ:
 			pr.next() // consume  > or >= or < or <=
-			rightUnary := parseTerm(pr)
+			rightUnary := parseComp(pr)
 
 			parent = newASTNode(token, parent, rightUnary, evalInfix)
 		default:
@@ -114,20 +133,20 @@ func parseComp(pr *parser) *astNode {
 	return parent
 }
 
-// expr -> comparison ( ( "==" ) comparison )*
+// expr -> comparison ( ( "==" | "!=" ) comparison )*
 func parseExpr(pr *parser) *astNode {
 	log.Print("inside expr")
 
 	leftUnary := parseComp(pr) // consume first unary
 	var parent = leftUnary
 
-	for token := pr.peek(); token.tokenType == Eq; token = pr.peek() {
+	for token := pr.peek(); token.tokenType == Eq || token.tokenType == NotEq; token = pr.peek() {
 		if pr.eof() {
-			break // we are just breaking the rule as we in the recusrive expansion of (==) comparison
+			break // we are just breaking the rule as we in the recusrive expansion of (== or !=) comparison
 		}
 
-		pr.next() // consume ==
-		rightUnary := parseComp(pr)
+		pr.next() // consume == or !=
+		rightUnary := parseExpr(pr)
 
 		parent = newASTNode(token, parent, rightUnary, evalInfix)