From 138b466b897f94ea6a29a7b62c39caa717efafec Mon Sep 17 00:00:00 2001
From: Bad Diode <bd@badd10de.dev>
Date: Wed, 30 Mar 2022 14:44:31 +0200
Subject: Use Node refs as return arguments from parsing

---
 src/parser.c | 74 ++++++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 47 insertions(+), 27 deletions(-)

(limited to 'src/parser.c')

diff --git a/src/parser.c b/src/parser.c
index e784a0c..a82a97f 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -1,6 +1,15 @@
 #include "parser.h"
 #include "darray.h"
 
+Node *
+alloc_node(NodeType type) {
+    // TODO: Use a bump allocator?
+    // TODO: Free memory!
+    Node *node = malloc(sizeof(Node));
+    node->type = type;
+    return node;
+}
+
 Token
 next_token(Parser *parser) {
     return parser->tokens[parser->current++];
@@ -16,7 +25,7 @@ has_next(Parser *parser) {
     return parser->current < array_size(parser->tokens);
 }
 
-Node
+Node *
 parse_number(Parser *parser) {
     Token tok = next_token(parser);
 
@@ -40,7 +49,7 @@ parse_number(Parser *parser) {
             c = sv_next(&tok.value);
         } else if (!(c >= '0' && c <= '9')){
             push_error(ERR_TYPE_PARSER, ERR_MALFORMED_NUMBER, tok.line, tok.col);
-            return (Node){.type = NODE_ERR};
+            return NULL;
         }
     }
 
@@ -59,7 +68,7 @@ parse_number(Parser *parser) {
             break;
         } else {
             push_error(ERR_TYPE_PARSER, ERR_MALFORMED_NUMBER, tok.line, tok.col);
-            return (Node){.type = NODE_ERR};
+            return NULL;
         }
         integral = integral * base + current;
         c = sv_next(&tok.value);
@@ -77,21 +86,33 @@ parse_number(Parser *parser) {
             current = (c - '0');
         } else {
             push_error(ERR_TYPE_PARSER, ERR_MALFORMED_NUMBER, tok.line, tok.col);
-            return (Node){.type = NODE_ERR};
+            return NULL;
         }
         fractional = fractional * base + current;
         c = sv_next(&tok.value);
     }
 
-    return (Node){
-        .type = NODE_NUMBER,
-        .number.negative = negative,
-        .number.integral = integral,
-        .number.fractional = fractional,
-    };
+    Node * node = alloc_node(NODE_NUMBER);
+    node->number.negative = negative;
+    node->number.integral = integral;
+    node->number.fractional = fractional;
+    return node;
 }
 
-Node
+Node *
+parse_string(Parser *parser) {
+    Token tok = next_token(parser);
+    Node *node = alloc_node(NODE_STRING);
+    node->string = tok.value;
+    return node;
+}
+
+Node *
+parse_paren(Parser *parser) {
+    return NULL; // TODO: Not implemented
+}
+
+Node *
 parse_next(Parser *parser) {
     Token tok = peek_token(parser);
     switch (tok.type) {
@@ -99,37 +120,36 @@ parse_next(Parser *parser) {
             return parse_number(parser);
         } break;
         case TOKEN_STRING: {
-            // TODO: return parse_string(parser);
-            next_token(parser);
-            return (Node){.type = NODE_STRING, .string = tok.value};
+            return parse_string(parser);
         } break;
         case TOKEN_LPAREN: {
-            // TODO: return parse_paren(parser);
-            push_error(ERR_TYPE_PARSER, ERR_UNIMPLEMENTED, tok.line, tok.col);
-            return (Node){.type = NODE_ERR};
+            return parse_paren(parser);
+        } break;
+        case TOKEN_EOF: {
+            return NULL;
         } break;
         default: {
             push_error(ERR_TYPE_PARSER, ERR_UNKNOWN_TOK_TYPE, tok.line, tok.col);
-            return (Node){.type = NODE_ERR};
+            return NULL;
         } break;
     }
 }
 
 void
-print_node(Node node) {
-    switch (node.type) {
+print_node(Node *node) {
+    switch (node->type) {
         case NODE_NUMBER: {
-            if (node.number.negative) {
+            if (node->number.negative) {
                 printf("-");
             }
-            if (node.number.fractional != 0) {
-                printf("%zu.%zu\n", node.number.integral, node.number.fractional);
+            if (node->number.fractional != 0) {
+                printf("%zu.%zu\n", node->number.integral, node->number.fractional);
             } else {
-                printf("%zu\n", node.number.integral);
+                printf("%zu\n", node->number.integral);
             }
         } break;
         case NODE_STRING: {
-            sv_write(&node.string);
+            sv_write(&node->string);
             printf("\n");
         } break;
         default: { printf("{#unk}"); } break;
@@ -149,8 +169,8 @@ parse(Token *tokens) {
     }
 
     while (has_next(&parser)) {
-        Node node = parse_next(&parser);
-        if (node.type == NODE_ERR) {
+        Node *node = parse_next(&parser);
+        if (node == NULL) {
             return;
         }
         print_node(node);
-- 
cgit v1.2.1