initial commit

Author: jungleedevansh

ast.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"io"
+	"log"
+	"strings"
+)
+
+type astNode struct {
+	left, right *astNode
+	token       Token
+	depth       int // depth in the ast, helps in stringify
+	evalr       evaluator
+}
+
+type parserFn func(*parser) *astNode
+
+var nilASTNode *astNode = nil
+
+func newASTNode(token Token, left, right *astNode, evalr evaluator) *astNode {
+	return &astNode{left, right, token, 0, evalr}
+}
+
+type parser struct {
+	tokens         []Token
+	processedToken int
+	lastErr        error
+}
+
+func (ast *astNode) String() string {
+	marginStr := ""
+	var out strings.Builder
+	for leftMargin := ast.depth; leftMargin > 0; leftMargin-- {
+		marginStr += "\t"
+	}
+	out.WriteString("\n")
+	out.WriteString(marginStr)
+	out.WriteString("Token: ")
+	out.WriteString(ast.token.String())
+	if ast.left != nilASTNode {
+		ast.left.depth = ast.depth + 1
+		out.WriteString("\n")
+		out.WriteString(marginStr)
+		out.WriteString("Left: ")
+		out.WriteString(ast.left.String())
+	}
+	if ast.right != nilASTNode {
+		ast.right.depth = ast.depth + 1
+		out.WriteString("\n")
+		out.WriteString(marginStr)
+		out.WriteString("Right: ")
+		out.WriteString(ast.right.String())
+
+	}
+	return out.String()
+}
+
+func (p *parser) next() Token {
+
+	if p.processedToken < len(p.tokens) {
+		token := p.tokens[p.processedToken]
+		p.processedToken++
+		return token
+	}
+	p.lastErr = io.EOF
+	return Token{}
+}
+
+func (p *parser) peek() Token {
+	if p.processedToken < len(p.tokens) {
+		return p.tokens[p.processedToken]
+	}
+	p.lastErr = io.EOF
+	return Token{}
+}
+
+func (p *parser) eof() bool {
+	defer log.Print("LastError: ", p.lastErr)
+	return p.lastErr == io.EOF
+}
+
+func parseTokens(tokens []Token, prsFn parserFn) *astNode {
+	par := parser{
+		tokens: tokens,
+	}
+	return prsFn(&par)
+}

ast_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestAST(t *testing.T) {
+	lexer := NewLexer(bytes.NewReader([]byte("(1)+(2)")))
+
+	err := lexer.Analyze()
+	if err != nil {
+		t.Error("error while doing lexical analysis: ", err)
+		t.Fail()
+		return
+	}
+	t.Logf("Token List: %v", lexer.tokenList)
+	actual := parseTokens(lexer.tokenList, parseExpr)
+	t.Log("Actual: ", actual.String())
+	expected := newASTNode(NewToken(Plus, '+'),
+
+		newASTNode(NewToken(Number, '1'), nil, nil, nil),
+		newASTNode(NewToken(Number, '2'), nil, nil, nil), nil)
+
+	if !compareAST(expected, actual) {
+		t.Error("Expected AST didn't match with Actual AST")
+		t.Error("Expected: ", expected.String())
+	}
+}
+
+func compareAST(x, y *astNode) bool {
+
+	if x == nil && y == nil {
+		return true
+	}
+
+	if x != nil && y != nil {
+		return x.token.Equals(y.token) && compareAST(x.left, y.left) && compareAST(x.right, y.right)
+	}
+	return false
+
+}

eval.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"errors"
+	"strconv"
+)
+
+type evaluator func(*astNode) (any, error)
+
+func eval(ast *astNode) (any, error) {
+	return ast.evalr(ast)
+}
+
+func evalNumber(ast *astNode) (any, error) {
+	return strconv.ParseFloat(string(ast.token.val), 64)
+}
+
+func evalInfix(ast *astNode) (any, error) {
+	var left, right any
+	left, err := eval(ast.left)
+	if err != nil {
+		return nil, err
+	}
+	right, err = eval(ast.right)
+	if err != nil {
+		return 0, nil
+	}
+	leftF := left.(float64)
+	rightF := right.(float64)
+
+	switch ast.token.tokenType {
+	case Minus:
+		return leftF - rightF, nil
+	case Plus:
+		return leftF + rightF, nil
+	case Asterisk:
+		return leftF * rightF, nil
+	case Slash:
+		if rightF == 0 {
+			return 0, errors.New("divided by zero")
+		}
+		return leftF / rightF, nil
+	case Mod:
+		return float64(int64(leftF) % int64(rightF)), nil
+
+	case LT:
+		return leftF < rightF, nil
+	case GT:
+		return leftF > rightF, nil
+	case LTEQ:
+		return leftF <= rightF, nil
+	case GTEQ:
+		return leftF >= rightF, nil
+	case Eq:
+		return leftF == rightF, nil
+
+	}
+	return 0, nil // Need to take care of this
+}

eval_test.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestEval(t *testing.T) {
+	lexer := NewLexer(bytes.NewReader([]byte("(2*3*2+32) == 8")))
+
+	err := lexer.Analyze()
+	if err != nil {
+		t.Error("error while doing lexical analysis: ", err)
+		t.Fail()
+		return
+	}
+	t.Logf("Token List: %v", lexer.tokenList)
+	ast := parseTokens(lexer.tokenList, parseExpr)
+	t.Log("AST: ", ast.String())
+	actualResult, err := eval(ast)
+	if err != nil {
+		t.Error("error occured while evaluting ast: ", err)
+		return
+	}
+	expectedVal := false
+	if actualResult != expectedVal {
+		t.Errorf("Wrong Evaluation Actual: %v, Expected: %v", actualResult, expectedVal)
+	}
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/devansh42/rad
+
+go 1.21.1