begin expression parsing

src/zelkelc/__main__.py

@@ -13,8 +13,7 @@ class MyClass {
 }
 
 static fn main() -> i64 {
-    println("Hello, world!")
-    return 0
+    return 0 + 0 + 1
 }
 """
 

src/zelkelc/ast/parser.py

@@ -169,7 +169,7 @@ class Parser:
         self.expect(token.Identifier("return"))
         # if there is an expression then check for add it?
         
-        expr = None
+        expr = self.parse_expression()
         
         return nodes.ReturnStatement(
             expr
@@ -197,4 +197,58 @@ class Parser:
             mutable,
             typ,
             expr,
-        )
+        )
+    
+    def parse_expression(self) -> nodes.Expression:
+        if self.current_type(token.Operator) == True:
+            self.parse_unary_expression()
+        
+        left = self.parse_primary_expression()
+        if self.current_type(token.Operator) == True:
+            self.cursor -= 1
+            return self.parse_binary_expression()
+        
+        return left
+    
+    def parse_binary_expression(self) -> nodes.BinaryExpression:
+        left = self.parse_expressio        kjkfksdfkjdsafkljdsflkjdsalkfjdslkfs
+        
+        
+        
+        
+        
+        
+        
+        jfkjdsfkjdslkjdsfkjdsflkjdskw
+        op = self.expect_type(token.Operator).value
+        right = self.parse_expression()
+        return nodes.BinaryExpression(
+            left,
+            op,
+            right,
+        )
+    
+    def parse_unary_expression(self) -> nodes.UnaryExpression:
+        pass
+    
+    def parse_primary_expression(self) -> nodes.PrimaryExpression:
+        t = self.tokens[self.cursor]
+        
+        match t:
+            case token.Identifier():
+                self.cursor += 1
+                return nodes.PrimaryExpression(
+                    value = values.Variable(t.value)
+                )
+            case token.Integer():
+                self.cursor += 1
+                return nodes.PrimaryExpression(
+                    value = values.Integer(t.value)
+                )
+            case token.String():
+                self.cursor += 1
+                return nodes.PrimaryExpression(
+                    value = values.String(t.value)
+                )
+            case _:
+                return None

src/zelkelc/ast/values.py

@@ -12,4 +12,8 @@ class String:
 class Void:
     pass
 
-Value = Integer | String | Void
+@dataclass
+class Variable:
+    name: str
+
+Value = Integer | String | Void | Variable

src/zelkelc/lexer/token.py

@@ -49,23 +49,7 @@ class Equals:
     pass
 
 @dataclass
-class Plus:
-    pass
-
-@dataclass
-class Minus:
-    pass
-
-@dataclass
-class Star:
-    pass
-
-@dataclass
-class Slash:
-    pass
-
-@dataclass
-class Ampersand:
-    pass
+class Operator:
+    value: str
 
-Token = Identifier | String | Integer | LParen | RParen | LBrace | RBrace | Period | Comma | Arrow | Colon | Equals | Plus | Minus | Star | Slash | Ampersand
+Token = Identifier | String | Integer | LParen | RParen | LBrace | RBrace | Period | Comma | Arrow | Colon | Equals | Operator

src/zelkelc/lexer/tokenizer.py

@@ -78,16 +78,16 @@ def lex(source: str) -> list[token.Token]:
                     tokens.append(token.Equals())
                     i += 1
                 case '+':
-                    tokens.append(token.Plus())
+                    tokens.append(token.Operator('+'))
                     i += 1
                 case '-':
-                    tokens.append(token.Minus())
+                    tokens.append(token.Operator('-'))
                     i += 1
                 case '*':
-                    tokens.append(token.Star())
+                    tokens.append(token.Operator('*'))
                     i += 1
                 case '/':
-                    tokens.append(token.Slash())
+                    tokens.append(token.Operator('/'))
                     i += 1
                 case _:
                     print(f"Unknown character found during lexing: '{c}' at {i}")