From e4ec102cb99a90278800e580b262e1ab546dbcdf Mon Sep 17 00:00:00 2001 From: laentropia Date: Mon, 13 Apr 2026 07:57:36 -0600 Subject: [PATCH 1/2] rework: AST now uses an arena for allocation For now it works but i dont really like that i use ParseResult, i mean is necessary but i think i will try to make it cleaner so that i can just directly use like parse and pass tath into evaluate, that would require to move the main evaluate funciton into evaluate_tree or something and evaluate takes the arena, uses evaluate_tree and frees the arena, will try that the next commit but for now this version works perfectly. --- include/evaluator.h | 1 - include/parser.h | 9 +++++++-- src/evaluator.c | 5 +---- src/main.c | 5 ++++- src/parser.c | 27 +++++++++++++++++++++------ test/CMakeLists.txt | 7 +++++++ test/test_evaluator.c | 3 ++- test/test_parser.c | 5 ++++- 8 files changed, 46 insertions(+), 16 deletions(-) diff --git a/include/evaluator.h b/include/evaluator.h index d176bd2..78c5730 100644 --- a/include/evaluator.h +++ b/include/evaluator.h @@ -2,7 +2,6 @@ #define EVALUATOR_H #include "lexer.h" -#include "arena.h" #include int64_t evaluate(ASTNode *tree); diff --git a/include/parser.h b/include/parser.h index 03d5443..edae5fb 100644 --- a/include/parser.h +++ b/include/parser.h @@ -14,6 +14,11 @@ typedef struct { size_t pos; } ASTNodeSlice; +typedef struct { + Arena *arena; + AST tree; +} ParseResult; + ASTNode ASTNodeSlice_peek(ASTNodeSlice *slice); ASTNode ASTNodeSlice_next(ASTNodeSlice *slice); bool ASTNodeSlice_is_valid(ASTNodeSlice *slice); @@ -24,7 +29,7 @@ ASTNode *led(ASTNodeSlice *slice, size_t right_precedence); uint8_t node_lbp(ASTNode node); uint8_t node_rbp(ASTNode node); -AST parse(ASTNodeArray *arr); -ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp); +ParseResult parse(ASTNodeArray *arr); +ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp); #endif // !PARSER_H diff --git a/src/evaluator.c b/src/evaluator.c index 219f854..754fefd 100644 --- a/src/evaluator.c +++ b/src/evaluator.c @@ -1,7 +1,7 @@ #include "evaluator.h" #include "lexer.h" #include -#include + int64_t evaluate(ASTNode *tree) { if (tree->type == NODE_BINARY_OP) { @@ -9,8 +9,6 @@ int64_t evaluate(ASTNode *tree) { ASTNode *left = tree->data.binary.left; ASTNode *right = tree->data.binary.right; - free(tree); - switch (op) { case OP_ADD: return evaluate(left) + evaluate(right); @@ -24,7 +22,6 @@ int64_t evaluate(ASTNode *tree) { } } else { int64_t return_val = tree->data.integer; - free(tree); return return_val; } } diff --git a/src/main.c b/src/main.c index 26053e9..b85197e 100644 --- a/src/main.c +++ b/src/main.c @@ -1,3 +1,4 @@ +#include "arena.h" #include "evaluator.h" #include "lexer.h" #include "parser.h" @@ -21,8 +22,10 @@ int main(void) { ASTNodeArray context; tokenize(buf, &context); - AST tree = parse(&context); + ParseResult par = parse(&context); + AST tree = par.tree; int64_t result = evaluate(tree.head); + arena_destroy(par.arena); printf("El resultado es: %" PRIi64 "\n", result); diff --git a/src/parser.c b/src/parser.c index 6803508..4d42001 100644 --- a/src/parser.c +++ b/src/parser.c @@ -1,6 +1,7 @@ #include "parser.h" #include "lexer.h" #include "arena.h" +#include #include #include #include @@ -61,19 +62,33 @@ bool ASTNodeSlice_is_valid(ASTNodeSlice *slice) { return true; } -AST parse(ASTNodeArray *arr) { +ParseResult parse(ASTNodeArray *arr) { AST tree; ASTNodeSlice context = { .arr = arr, .pos = 0, }; + Arena arena = arena_init(sizeof(ASTNode) * arr->len).arena; - tree.head = parse_expr(&context, 0); - return tree; + tree.head = parse_expr(&context, &arena, 0); + return (ParseResult) {.arena = &arena, .tree = tree}; } -ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp) { - ASTNode *left_side = malloc(sizeof(ASTNode)); +ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) { + arena_ensure_capacity( + 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) { @@ -90,7 +105,7 @@ ASTNode *parse_expr(ASTNodeSlice *slice, uint8_t min_bp) { } ASTNodeSlice_next(slice); - ASTNode *right_side = parse_expr(slice, rbp); + ASTNode *right_side = parse_expr(slice, arena, rbp); ASTNode *new_node = malloc(sizeof(ASTNode)); *new_node = operator; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 62e14d1..b48356f 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,6 +3,7 @@ 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 @@ -19,6 +20,12 @@ 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) diff --git a/test/test_evaluator.c b/test/test_evaluator.c index cf97930..5fe4114 100644 --- a/test/test_evaluator.c +++ b/test/test_evaluator.c @@ -16,7 +16,8 @@ static void test_basic_evaluation(void** state) { ASTNodeArray context; tokenize(expr, &context); - AST tree = parse(&context); + ParseResult result = parse(&context); + AST tree = result.tree; uint64_t value = evaluate(tree.head); assert_int_equal(value, 82); diff --git a/test/test_parser.c b/test/test_parser.c index 83a6592..7b1f36c 100644 --- a/test/test_parser.c +++ b/test/test_parser.c @@ -1,3 +1,4 @@ +#include "arena.h" #include "lexer.h" #include "parser.h" #include @@ -17,7 +18,8 @@ static void test_parsing_basic_expression(void **state) { assert_int_equal(tokenize(expr, &tokens), LEXER_OK); assert_int_equal(tokens.len, 7); - AST tree = parse(&tokens); + ParseResult result = parse(&tokens); + AST tree = result.tree; // Assert head is + assert_int_equal(tree.head->type, NODE_BINARY_OP); assert_int_equal(tree.head->data.binary.op, OP_ADD); @@ -68,6 +70,7 @@ static void test_parsing_basic_expression(void **state) { tree.head->data.binary.right->data.binary.left->data.binary.left->data.integer, 3 ); + arena_destroy(result.arena); } int main(void) { -- 2.51.0 From 7ad4eba1234763675ce3e97f9de0ab549057d44f Mon Sep 17 00:00:00 2001 From: laentropia Date: Mon, 13 Apr 2026 08:44:30 -0600 Subject: [PATCH 2/2] fix/refactor: Modified evaluate and changed it to evaluate_tree So i did what the last commit said, also fixed parse_expr because it was still using malloc for allocating new nodes so i made it use arena_alloc like it should, did the very first tests so it's all good, i think is readdy to merge. --- include/evaluator.h | 4 +++- include/parser.h | 4 ++-- src/evaluator.c | 24 ++++++++++++++++-------- src/main.c | 4 +--- src/parser.c | 18 ++++++++++++++---- test/test_evaluator.c | 3 +-- test/test_parser.c | 31 +++++++++++++++---------------- 7 files changed, 52 insertions(+), 36 deletions(-) diff --git a/include/evaluator.h b/include/evaluator.h index 78c5730..7b34e2b 100644 --- a/include/evaluator.h +++ b/include/evaluator.h @@ -2,8 +2,10 @@ #define EVALUATOR_H #include "lexer.h" +#include "parser.h" #include -int64_t evaluate(ASTNode *tree); +int64_t evaluate(ParseResult context); +int64_t evaluate_tree(ASTNode *tree); #endif // !EVALUATOR_H diff --git a/include/parser.h b/include/parser.h index edae5fb..7c2fa4f 100644 --- a/include/parser.h +++ b/include/parser.h @@ -15,8 +15,8 @@ typedef struct { } ASTNodeSlice; typedef struct { - Arena *arena; - AST tree; + Arena arena; + ASTNode *tree; } ParseResult; ASTNode ASTNodeSlice_peek(ASTNodeSlice *slice); diff --git a/src/evaluator.c b/src/evaluator.c index 754fefd..36d9fb1 100644 --- a/src/evaluator.c +++ b/src/evaluator.c @@ -1,9 +1,11 @@ #include "evaluator.h" +#include "arena.h" #include "lexer.h" +#include "parser.h" #include -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; @@ -11,18 +13,24 @@ int64_t evaluate(ASTNode *tree) { switch (op) { case OP_ADD: - return evaluate(left) + evaluate(right); + return evaluate_tree(left) + evaluate_tree(right); case OP_SUB: - return evaluate(left) - evaluate(right); + return evaluate_tree(left) - evaluate_tree(right); case OP_MUL: - return evaluate(left) * evaluate(right); + return evaluate_tree(left) * evaluate_tree(right); case OP_DIV: - return evaluate(left) / evaluate(right); + return evaluate_tree(left) / evaluate_tree(right); } - } else { - int64_t return_val = tree->data.integer; - 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; +} diff --git a/src/main.c b/src/main.c index b85197e..9cc1240 100644 --- a/src/main.c +++ b/src/main.c @@ -23,9 +23,7 @@ int main(void) { tokenize(buf, &context); ParseResult par = parse(&context); - AST tree = par.tree; - int64_t result = evaluate(tree.head); - arena_destroy(par.arena); + int64_t result = evaluate(par); printf("El resultado es: %" PRIi64 "\n", result); diff --git a/src/parser.c b/src/parser.c index 4d42001..2e417c5 100644 --- a/src/parser.c +++ b/src/parser.c @@ -63,15 +63,15 @@ bool ASTNodeSlice_is_valid(ASTNodeSlice *slice) { } ParseResult parse(ASTNodeArray *arr) { - AST tree; ASTNodeSlice context = { .arr = arr, .pos = 0, }; Arena arena = arena_init(sizeof(ASTNode) * arr->len).arena; - tree.head = parse_expr(&context, &arena, 0); - return (ParseResult) {.arena = &arena, .tree = tree}; + return (ParseResult) { + .arena = arena, + .tree = parse_expr(&context, &arena, 0)}; } ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) { @@ -107,7 +107,17 @@ ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) { ASTNodeSlice_next(slice); ASTNode *right_side = parse_expr(slice, arena, rbp); - ASTNode *new_node = malloc(sizeof(ASTNode)); + arena_ensure_capacity( + 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; diff --git a/test/test_evaluator.c b/test/test_evaluator.c index 5fe4114..a8f5bd1 100644 --- a/test/test_evaluator.c +++ b/test/test_evaluator.c @@ -17,8 +17,7 @@ static void test_basic_evaluation(void** state) { tokenize(expr, &context); ParseResult result = parse(&context); - AST tree = result.tree; - uint64_t value = evaluate(tree.head); + int64_t value = evaluate(result); assert_int_equal(value, 82); } diff --git a/test/test_parser.c b/test/test_parser.c index 7b1f36c..0fe3c20 100644 --- a/test/test_parser.c +++ b/test/test_parser.c @@ -19,58 +19,57 @@ static void test_parsing_basic_expression(void **state) { assert_int_equal(tokens.len, 7); ParseResult result = parse(&tokens); - AST tree = result.tree; // Assert head is + - assert_int_equal(tree.head->type, NODE_BINARY_OP); - assert_int_equal(tree.head->data.binary.op, OP_ADD); + assert_int_equal(result.tree->type, NODE_BINARY_OP); + assert_int_equal(result.tree->data.binary.op, OP_ADD); - assert_int_equal(tree.head->data.binary.left->type, NODE_INTEGER); - assert_int_equal(tree.head->data.binary.left->data.integer, 2); + assert_int_equal(result.tree->data.binary.left->type, NODE_INTEGER); + assert_int_equal(result.tree->data.binary.left->data.integer, 2); assert_int_equal( - tree.head->data.binary.right->type, + result.tree->data.binary.right->type, NODE_BINARY_OP ); assert_int_equal( - tree.head->data.binary.right->data.binary.op, + result.tree->data.binary.right->data.binary.op, OP_MUL ); assert_int_equal( - tree.head->data.binary.right->data.binary.right->type, + result.tree->data.binary.right->data.binary.right->type, NODE_INTEGER); assert_int_equal( - tree.head->data.binary.right->data.binary.right->data.integer, + result.tree->data.binary.right->data.binary.right->data.integer, 789); assert_int_equal( - tree.head->data.binary.right->data.binary.left->type, + result.tree->data.binary.right->data.binary.left->type, NODE_BINARY_OP ); assert_int_equal( - tree.head->data.binary.right->data.binary.left->data.binary.op, + result.tree->data.binary.right->data.binary.left->data.binary.op, OP_DIV ); assert_int_equal( - tree.head->data.binary.right->data.binary.left->data.binary.right->type, + result.tree->data.binary.right->data.binary.left->data.binary.right->type, NODE_INTEGER ); assert_int_equal( - tree.head->data.binary.right->data.binary.left->data.binary.right->data.integer, + result.tree->data.binary.right->data.binary.left->data.binary.right->data.integer, 66 ); assert_int_equal( - tree.head->data.binary.right->data.binary.left->data.binary.left->type, + result.tree->data.binary.right->data.binary.left->data.binary.left->type, NODE_INTEGER ); assert_int_equal( - tree.head->data.binary.right->data.binary.left->data.binary.left->data.integer, + result.tree->data.binary.right->data.binary.left->data.binary.left->data.integer, 3 ); - arena_destroy(result.arena); + arena_destroy(&result.arena); } int main(void) { -- 2.51.0