fix: now we're able to add complex arithmetic expressions

Author: ProgrammingMuffin

ast/ast.go

@@ -38,7 +38,15 @@ type Block struct {
 	Stmts  []Stmt
 }
 
+type Term struct {
+	LParen   int
+	RParen   int
+	ExprStmt Stmt
+}
+
 func (*BasicLit) Expr() {}
+func (*Term) Expr()     {}
+func (*Term) Stmt()     {}
 
 type ExprStmt interface {
 	Expr()

gen/gen.go

@@ -0,0 +1,55 @@
+package _gen
+
+import (
+	"strings"
+
+	_ast "github.com/ProgrammingMuffin/Fig/ast"
+)
+
+var Module strings.Builder
+
+func VisitTree(node _ast.Node) string {
+	switch x := node.(type) {
+	case *_ast.FuncDecl:
+		Module.WriteString("void " + x.FuncName.Value + "()")
+		VisitBlock(x.Block)
+	}
+	return Module.String()
+}
+
+func VisitBlock(node _ast.Block) {
+	Module.WriteString("{")
+	for _, stmt := range node.Stmts {
+		VisitStatement(stmt)
+		Module.WriteString(";")
+	}
+	Module.WriteString("}\n")
+}
+
+func VisitStatement(node _ast.Stmt) {
+	switch x := node.(type) {
+	case *_ast.AssignStmt:
+		Module.WriteString("int " + x.Lhs.Value + " = ")
+		VisitStatement(x.Rhs)
+	case *_ast.BinaryExpr:
+		switch y := x.Lhs.(type) {
+		case *_ast.BasicLit:
+			Module.WriteString(y.Value + " " + x.Op.Type + " ")
+		case *_ast.BinaryExpr:
+			VisitStatement(y)
+		case *_ast.Term:
+			Module.WriteString("( ")
+			switch z := y.ExprStmt.(type) {
+			case *_ast.BinaryExpr:
+				VisitStatement(z)
+			}
+			Module.WriteString(" ) " + x.Op.Type + " ")
+		}
+		switch y := x.Rhs.(type) {
+		case *_ast.BasicLit:
+			Module.WriteString(y.Value)
+		case *_ast.BinaryExpr:
+			VisitStatement(y)
+		}
+	}
+}

go.mod

@@ -5,8 +5,17 @@ go 1.21.5
 require (
 	github.com/k0kubun/pp v3.0.1+incompatible // indirect
 	github.com/k0kubun/pp/v3 v3.2.0 // indirect
+	github.com/kr/pretty v0.2.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/llir/ll v0.0.0-20220802044011-65001c0fb73c // indirect
+	github.com/llir/llvm v0.3.6 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.16 // indirect
+	github.com/mewmew/float v0.0.0-20201204173432-505706aa38fa // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	golang.org/x/mod v0.4.2 // indirect
 	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
 	golang.org/x/text v0.3.7 // indirect
+	golang.org/x/tools v0.1.4 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )

lex/lex.go

@@ -23,6 +23,18 @@ type RBrace struct {
 	End int
 }
 
+type LParen struct {
+	Token
+	Pos int
+	End int
+}
+
+type RParen struct {
+	Token
+	Pos int
+	End int
+}
+
 type DoubleQuote struct {
 	Token
 	Pos int
@@ -122,11 +134,15 @@ func LexSourceFile(sourceFile string) []Token {
 					tokens = append(tokens, Number{Pos: pos, End: end, Value: numberValue.String()})
 					numberValue.Reset()
 				}
-			} else if isSymbol(char) && (unicode.IsLetter(rune(data[index+1])) || unicode.IsNumber(rune(data[index+1])) || data[index+1] == ' ' || data[index+1] == '\t' || data[index+1] == '\n') && !isSymbol(data[index+1]) {
+			} else if isSymbol(char) && (unicode.IsLetter(rune(data[index+1])) || unicode.IsNumber(rune(data[index+1])) || data[index+1] == '(' || data[index+1] == ')' || data[index+1] == ' ' || data[index+1] == '\t' || data[index+1] == '\n') {
 				if symbol.Len() != 0 {
 					pos := index - len(symbol.String())
 					end := index
 					switch symbol.String() {
+					case "(":
+						tokens = append(tokens, LParen{Pos: pos, End: end})
+					case ")":
+						tokens = append(tokens, RParen{Pos: pos, End: end})
 					case "{":
 						tokens = append(tokens, LBrace{Pos: pos, End: end})
 					case "}":

main.fig

@@ -1,5 +1,5 @@
 func Test {
-    x = 1 + 2 * 3
+    x = ((1 + 2) * (1 + (3 + 5)))
 }
 
 func Test2 {

main.go

@@ -1,11 +1,20 @@
 package main
 
 import (
+	"fmt"
+
+	_gen "github.com/ProgrammingMuffin/Fig/gen"
 	_lex "github.com/ProgrammingMuffin/Fig/lex"
 	_parse "github.com/ProgrammingMuffin/Fig/parse"
+	"github.com/k0kubun/pp/v3"
 )
 
 func main() {
 	tokens := _lex.LexSourceFile("main.fig")
-	_ = _parse.ParseTokens(tokens)
+	ast := _parse.ParseTokens(tokens)
+	pp.Println(ast)
+	for _, astVal := range ast {
+		_gen.VisitTree(astVal)
+	}
+	fmt.Println(_gen.Module.String())
 }

parse/parse.go

@@ -7,7 +7,6 @@ import (
 
 	_ast "github.com/ProgrammingMuffin/Fig/ast"
 	_lex "github.com/ProgrammingMuffin/Fig/lex"
-	"github.com/k0kubun/pp/v3"
 )
 
 var Scan int = 0
@@ -123,15 +122,26 @@ OUTSIDE:
 }
 
 func ParseStatement() (_ast.Stmt, error) {
+	switch Tokens[Scan].(type) {
+	case _lex.LParen:
+		term, err := ParseTerm()
+		if err != nil {
+			return nil, err
+		}
+		expr, err := ParseStatement()
+		switch x := expr.(type) {
+		case *_ast.BinaryExpr:
+			x.Lhs = term
+		}
+		return expr, nil
+	}
 	if (Scan + 1) < len(Tokens) {
 		switch x := Tokens[Scan+1].(type) {
 		case _lex.Operator:
 			if x.Kind == "=" {
 				return ParseAssignStatement()
 			} else if x.Kind == "+" || x.Kind == "-" || x.Kind == "*" || x.Kind == "/" {
-				stmt, err := ParseBinaryExpr(nil, 1)
-				pp.SetDefaultMaxDepth(-1)
-				pp.Println(stmt)
+				stmt, err := ParseBinaryExpr(nil, nil, 1)
 				return stmt, err
 			}
 		default:
@@ -163,19 +173,57 @@ func ParseAssignStatement() (_ast.Stmt, error) {
 	switch Tokens[Scan].(type) {
 	case _lex.Ident:
 		return ParseStatement()
+	case _lex.LParen:
+		term, err := ParseTerm()
+		if err != nil {
+			return nil, err
+		}
+		_, err = ParseBinaryExpr(nil, term, 0)
+		if err != nil {
+			return nil, err
+		}
+		stmt.Rhs = term
+		return &stmt, nil
 	case _lex.Number:
-		return ParseStatement()
+		nextStmt, err := ParseStatement()
+		if err != nil {
+			return nil, err
+		}
+		stmt.Rhs = nextStmt
+		return &stmt, nil
 	}
 	fmt.Println("error parsing assignment statement")
 	return nil, nil
 }
 
-func ParseBinaryExpr(prev *_ast.BinaryExpr, prec int) (*_ast.BinaryExpr, error) {
+func ParseTerm() (*_ast.Term, error) {
+	term := _ast.Term{}
+	err := SafeInc()
+	if err != nil {
+		return nil, err
+	}
+	stmt, err := ParseStatement()
+	if err != nil {
+		return nil, err
+	}
+	SafeInc()
+	switch Tokens[Scan].(type) {
+	case _lex.RParen:
+		term.ExprStmt = stmt
+		return &term, nil
+	default:
+		return nil, nil
+	}
+}
+
+func ParseBinaryExpr(prev *_ast.BinaryExpr, prevTerm _ast.ExprStmt, prec int) (*_ast.BinaryExpr, error) {
 	binaryExpr := _ast.BinaryExpr{}
 	if Scan+2 < len(Tokens) {
 		switch x := Tokens[Scan+1].(type) {
 		case _lex.RBrace:
 			return nil, nil
+		case _lex.RParen:
+			return nil, nil
 		case _lex.Operator:
 			fmt.Println("operator is: ", x)
 			prec := 1
@@ -190,11 +238,21 @@ func ParseBinaryExpr(prev *_ast.BinaryExpr, prec int) (*_ast.BinaryExpr, error)
 			}
 			if prev != nil {
 				prev.Rhs = &binaryExpr
+			} else if prevTerm != nil {
+				binaryExpr.Lhs = prevTerm
 			}
 			binaryExpr.Op = _ast.Operator{Type: x.Kind}
 			SafeInc()
 			SafeInc()
-			expr, err := ParseBinaryExpr(&binaryExpr, prec)
+			switch Tokens[Scan].(type) {
+			case _lex.LParen:
+				term, err := ParseTerm()
+				if err != nil {
+					return nil, err
+				}
+				binaryExpr.Rhs = term
+			}
+			expr, err := ParseBinaryExpr(&binaryExpr, nil, prec)
 			if err != nil {
 				return nil, err
 			}