Merge pull request 'feature-AST-using-arena' (#5) from feature-AST-using-arena into main

Reviewed-on: #5

include/evaluator.h

@@ -2,10 +2,9 @@
 #define EVALUATOR_H
 
 #include "lexer.h"
-#include "parser.h"
+#include "arena.h"
 #include <stdint.h>
 
-int64_t evaluate(ParseResult context);
+int64_t evaluate(ASTNode *tree);
-int64_t evaluate_tree(ASTNode *tree);
 
 #endif // !EVALUATOR_H

include/parser.h

@@ -14,11 +14,6 @@ typedef struct {
     size_t pos;
 } ASTNodeSlice;
 
-typedef struct {
-    Arena arena;
-    ASTNode *tree;
-} ParseResult;
-
 ASTNode ASTNodeSlice_peek(ASTNodeSlice *slice);
 ASTNode ASTNodeSlice_next(ASTNodeSlice *slice);
 bool ASTNodeSlice_is_valid(ASTNodeSlice *slice);
@@ -29,7 +24,7 @@ ASTNode *led(ASTNodeSlice *slice, size_t right_precedence);
 uint8_t node_lbp(ASTNode node);
 uint8_t node_rbp(ASTNode node);
 
-ParseResult parse(ASTNodeArray *arr);
+AST parse(ASTNodeArray *arr);
-ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp);
+ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp);
 
 #endif // !PARSER_H

src/evaluator.c

@@ -1,36 +1,31 @@
 #include "evaluator.h"
-#include "arena.h"
 #include "lexer.h"
-#include "parser.h"
 #include <stdint.h>
+#include <stdlib.h>
 
-
+int64_t evaluate(ASTNode *tree) {
-int64_t evaluate_tree(ASTNode *tree) {
     if (tree->type == NODE_BINARY_OP) {
         Operator op = tree->data.binary.op;
         ASTNode *left = tree->data.binary.left;
         ASTNode *right = tree->data.binary.right;
         
+        free(tree);
+
         switch (op) {
             case OP_ADD:
-                return evaluate_tree(left) + evaluate_tree(right);
+                return evaluate(left) + evaluate(right);
             case OP_SUB:
-                return evaluate_tree(left) - evaluate_tree(right);
+                return evaluate(left) - evaluate(right);
             case OP_MUL:
-                return evaluate_tree(left) * evaluate_tree(right);
+                return evaluate(left) * evaluate(right);
             case OP_DIV:
-                return evaluate_tree(left) / evaluate_tree(right);
+                return evaluate(left) / evaluate(right);
 
         }
+    } else {
+        int64_t return_val = tree->data.integer;
+        free(tree);
+        return return_val;
     }
-
-    int64_t return_val = tree->data.integer;
-    return return_val;
 }
 
-int64_t evaluate(ParseResult context) {
-    int64_t result = evaluate_tree(context.tree);
-    arena_destroy(&context.arena);
-
-    return result;
-}

src/main.c

@@ -1,4 +1,3 @@
-#include "arena.h"
 #include "evaluator.h"
 #include "lexer.h"
 #include "parser.h"
@@ -22,8 +21,8 @@ int main(void) {
     ASTNodeArray context;
     tokenize(buf, &context);
 
-    ParseResult par = parse(&context);
+    AST tree = parse(&context);
-    int64_t result = evaluate(par);
+    int64_t result = evaluate(tree.head);
 
 
     printf("El resultado es: %" PRIi64 "\n", result);

src/parser.c

@@ -1,7 +1,6 @@
 #include "parser.h"
 #include "lexer.h"
 #include "arena.h"
-#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -62,33 +61,19 @@ bool ASTNodeSlice_is_valid(ASTNodeSlice *slice) {
     return true;
 }
 
-ParseResult parse(ASTNodeArray *arr) {
+AST parse(ASTNodeArray *arr) {
+    AST tree;
     ASTNodeSlice context = {
         .arr = arr,
         .pos = 0,
     };
-    Arena arena = arena_init(sizeof(ASTNode) * arr->len).arena;
 
-    return (ParseResult) {
+    tree.head = parse_expr(&context, 0);
-        .arena = arena,
+    return tree;
-        .tree = parse_expr(&context, &arena, 0)};
 }
 
-ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) {
+ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp) {
-    arena_ensure_capacity(
+    ASTNode *left_side = malloc(sizeof(ASTNode));
-        arena,
-        sizeof(ASTNode),
-        alignof(ASTNode)
-    );
-
-    ASTNode *left_side = arena_unwrap_pointer(
-        arena_alloc(
-            arena,
-            sizeof(ASTNode),
-            alignof(ASTNode)
-        )
-    );
-
     *left_side = ASTNodeSlice_next(slice);
 
     while (true) {
@@ -105,19 +90,9 @@ ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) {
         }
 
         ASTNodeSlice_next(slice);
-        ASTNode *right_side = parse_expr(slice, arena, rbp);
+        ASTNode *right_side = parse_expr(slice, rbp);
 
-        arena_ensure_capacity(
+        ASTNode *new_node = malloc(sizeof(ASTNode));
-            arena,
-            sizeof(ASTNode),
-            alignof(ASTNode));
-        ASTNode *new_node = arena_unwrap_pointer(
-            arena_alloc(
-                arena, 
-                sizeof(ASTNode), 
-                alignof(ASTNode)
-            )
-        );
         *new_node = operator;
 
         new_node->data.binary.left = left_side;

test/CMakeLists.txt

@@ -3,7 +3,6 @@ find_package(cmocka REQUIRED)
 add_executable(test_nodeArray test_ASTNodeArray.c)
 add_executable(test_lexer test_lexer.c)
 add_executable(test_parser test_parser.c)
-add_executable(test_evaluator test_evaluator.c)
 
 target_link_libraries(test_nodeArray
     calculator_lib
@@ -20,12 +19,6 @@ target_link_libraries(test_parser
     cmocka::cmocka
 )
 
-target_link_libraries(test_evaluator
-    calculator_lib
-    cmocka::cmocka
-)
-
 add_test(NAME nodeArray_tests COMMAND test_nodeArray)
 add_test(NAME lexer_tests COMMAND test_lexer)
 add_test(NAME parser_tests COMMAND test_parser)
-add_test(NAME evaluator_tests COMMAND test_evaluator)

test/test_evaluator.c

@@ -16,8 +16,8 @@ static void test_basic_evaluation(void** state) {
     ASTNodeArray context;
 
     tokenize(expr, &context);
-    ParseResult result = parse(&context);
+    AST tree = parse(&context);
-    int64_t value = evaluate(result);
+    uint64_t value = evaluate(tree.head);
 
     assert_int_equal(value, 82);
 }

test/test_parser.c

@@ -1,4 +1,3 @@
-#include "arena.h"
 #include "lexer.h"
 #include "parser.h"
 #include <stdarg.h>
@@ -18,58 +17,57 @@ static void test_parsing_basic_expression(void **state) {
     assert_int_equal(tokenize(expr, &tokens), LEXER_OK);
     assert_int_equal(tokens.len, 7);
 
-    ParseResult result = parse(&tokens);
+    AST tree = parse(&tokens);
     // Assert head is +
-    assert_int_equal(result.tree->type, NODE_BINARY_OP);
+    assert_int_equal(tree.head->type, NODE_BINARY_OP);
-    assert_int_equal(result.tree->data.binary.op, OP_ADD);
+    assert_int_equal(tree.head->data.binary.op, OP_ADD);
 
-    assert_int_equal(result.tree->data.binary.left->type, NODE_INTEGER);
+    assert_int_equal(tree.head->data.binary.left->type, NODE_INTEGER);
-    assert_int_equal(result.tree->data.binary.left->data.integer, 2);
+    assert_int_equal(tree.head->data.binary.left->data.integer, 2);
 
 
     assert_int_equal(
-            result.tree->data.binary.right->type,
+            tree.head->data.binary.right->type,
             NODE_BINARY_OP
             );
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.op, 
+            tree.head->data.binary.right->data.binary.op, 
             OP_MUL
             );
 
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.right->type,
+            tree.head->data.binary.right->data.binary.right->type,
             NODE_INTEGER);
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.right->data.integer,
+            tree.head->data.binary.right->data.binary.right->data.integer,
             789);
 
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->type, 
+            tree.head->data.binary.right->data.binary.left->type, 
             NODE_BINARY_OP
             );
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->data.binary.op, 
+            tree.head->data.binary.right->data.binary.left->data.binary.op, 
             OP_DIV
             );
 
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->data.binary.right->type, 
+            tree.head->data.binary.right->data.binary.left->data.binary.right->type, 
             NODE_INTEGER
             );
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->data.binary.right->data.integer, 
+            tree.head->data.binary.right->data.binary.left->data.binary.right->data.integer, 
             66
             );
 
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->data.binary.left->type, 
+            tree.head->data.binary.right->data.binary.left->data.binary.left->type, 
             NODE_INTEGER
             );
     assert_int_equal(
-            result.tree->data.binary.right->data.binary.left->data.binary.left->data.integer, 
+            tree.head->data.binary.right->data.binary.left->data.binary.left->data.integer, 
             3
             );
-    arena_destroy(&result.arena);
 }
 
 int main(void) {