From 167ac3d09dc2aafbe9ea9b849b9d316190df54d5 Mon Sep 17 00:00:00 2001
From: SimonFJ20 <simonfromjakobsen@gmail.com>
Date: Mon, 20 Feb 2023 01:22:17 +0100
Subject: [PATCH] burh

---
 parser.c | 47 ++++++++++++++++++++++++++-
 parser.h | 97 +++++++++++++++++++++++++++++++-------------------------
 2 files changed, 100 insertions(+), 44 deletions(-)

diff --git a/parser.c b/parser.c
index b0ece9a..2e0b8df 100644
--- a/parser.c
+++ b/parser.c
@@ -1,5 +1,14 @@
 #include "parser.h"
 #include "lexer.h"
+#include <stdlib.h>
+#include <string.h>
+
+inline char* allocate_string(const char* source)
+{
+    char* destination = malloc(strlen(source) + 1);
+    strcpy(destination, source);
+    return destination;
+}
 
 void parser_create(Parser* parser, Lexer* lexer)
 {
@@ -9,4 +18,40 @@ void parser_create(Parser* parser, Lexer* lexer)
     };
 }
 
-void parser_parse_expression(Parser* parser) { }
+ParsedExpr* parser_parse_expression(Parser* parser) { return NULL; }
+
+ParsedExpr* parser_parse_operand(Parser* parser)
+{
+    Token current_token = parser_current(parser);
+    if (!parser_done(parser) && parser_current(parser).type == TokenTypeId) {
+
+    } else {
+        parser_step(parser);
+        return parsed_expr_allocate(&(ParsedExpr) {
+            .type = ParsedExprTypeError,
+            .error = {
+                .position = current_token.position,
+                .message = allocate_string("expected value"),
+            },
+        });
+    }
+}
+
+bool parser_done(const Parser* parser)
+{
+    return parser->current.type == TokenTypeEof;
+}
+
+Token parser_current(const Parser* parser) { return parser->current; }
+
+void parser_step(Parser* parser)
+{
+    parser->current = lexer_next(parser->lexer);
+}
+
+ParsedExpr* parsed_expr_allocate(const ParsedExpr* source)
+{
+    ParsedExpr* destination = malloc(sizeof(ParsedExpr));
+    *destination = *source;
+    return destination;
+}
diff --git a/parser.h b/parser.h
index c81c5ee..23ab782 100644
--- a/parser.h
+++ b/parser.h
@@ -7,28 +7,28 @@
 #include <stdint.h>
 
 typedef enum {
-    ParsedNodeTypeError,
-    ParsedNodeTypeInt,
-    ParsedNodeTypeFloat,
-    ParsedNodeTypeChar,
-    ParsedNodeTypeString,
-    ParsedNodeTypeBool,
-    ParsedNodeTypeArray,
-    ParsedNodeTypeDict,
-    ParsedNodeTypeIf,
-    ParsedNodeTypeWhile,
-    ParsedNodeTypeLoop,
-    ParsedNodeTypeFor,
-    ParsedNodeTypeCall,
-    ParsedNodeTypeAccess,
-    ParsedNodeTypeIndex,
-    ParsedNodeTypeUnary,
-    ParsedNodeTypeBinary,
-    ParsedNodeTypeAssign,
-    ParsedNodeTypeRangeFrom,
-    ParsedNodeTypeRangeTo,
-    ParsedNodeTypeRangeFromTo,
-} ParsedNodeType;
+    ParsedExprTypeError,
+    ParsedExprTypeInt,
+    ParsedExprTypeFloat,
+    ParsedExprTypeChar,
+    ParsedExprTypeString,
+    ParsedExprTypeBool,
+    ParsedExprTypeArray,
+    ParsedExprTypeDict,
+    ParsedExprTypeIf,
+    ParsedExprTypeWhile,
+    ParsedExprTypeLoop,
+    ParsedExprTypeFor,
+    ParsedExprTypeCall,
+    ParsedExprTypeAccess,
+    ParsedExprTypeIndex,
+    ParsedExprTypeUnary,
+    ParsedExprTypeBinary,
+    ParsedExprTypeAssign,
+    ParsedExprTypeRangeFrom,
+    ParsedExprTypeRangeTo,
+    ParsedExprTypeRangeFromTo,
+} ParsedExprType;
 
 typedef enum {
     ParsedBinaryTypeAdd,
@@ -59,11 +59,15 @@ typedef enum {
 } ParsedAssignType;
 
 typedef struct KeyValuePair KeyValuePair;
-typedef struct ParsedNode ParsedNode;
+typedef struct ParsedExpr ParsedExpr;
 
-struct ParsedNode {
-    ParsedNodeType type;
+struct ParsedExpr {
+    ParsedExprType type;
     union {
+        struct {
+            Position position;
+            char* message;
+        } error;
         int64_t int_value;
         double float_value;
         char char_value;
@@ -73,7 +77,7 @@ struct ParsedNode {
         } string;
         bool bool_value;
         struct {
-            ParsedNode* values;
+            ParsedExpr* values;
             size_t length;
         } array;
         struct {
@@ -81,42 +85,44 @@ struct ParsedNode {
             size_t length;
         } dict;
         struct {
-            ParsedNode* condition;
-            ParsedNode* truthy;
-            ParsedNode* falsy;
+            ParsedExpr* condition;
+            ParsedExpr* truthy;
+            ParsedExpr* falsy;
         } if_node;
         struct {
-            ParsedNode* condition;
-            ParsedNode* body;
+            ParsedExpr* condition;
+            ParsedExpr* body;
         } while_node;
         struct {
-            ParsedNode* body;
+            ParsedExpr* body;
         } loop;
         struct {
-            ParsedNode* subject;
-            ParsedNode* value;
-            ParsedNode* body;
+            ParsedExpr* subject;
+            ParsedExpr* value;
+            ParsedExpr* body;
         } for_node;
         struct {
-            ParsedNode* subject;
-            ParsedNode* arguments;
+            ParsedExpr* subject;
+            ParsedExpr* arguments;
             size_t arguments_length;
         } call;
         struct {
-            ParsedNode* subject;
-            ParsedNode* value;
+            ParsedExpr* subject;
+            ParsedExpr* value;
         } access;
         struct {
-            ParsedNode* subject;
-            ParsedNode* value;
+            ParsedExpr* subject;
+            ParsedExpr* value;
         } index;
     };
 };
 
+ParsedExpr* parsed_expr_allocate(const ParsedExpr* source);
+
 struct KeyValuePair {
     char* key;
     size_t key_length;
-    ParsedNode* value;
+    ParsedExpr* value;
 };
 
 typedef struct {
@@ -125,6 +131,11 @@ typedef struct {
 } Parser;
 
 void parser_create(Parser* parser, Lexer* lexer);
-void parser_parse_expression(Parser* parser);
+ParsedExpr* parser_parse_expression(Parser* parser);
+ParsedExpr* parser_parse_operand(Parser* parser);
+
+bool parser_done(const Parser* parser);
+Token parser_current(const Parser* parser);
+void parser_step(Parser* parser);
 
 #endif