CMakeLists.txt

@@ -31,14 +31,12 @@ add_library(calculator_lib
     src/lexer.c
     src/parser.c
     src/evaluator.c
-    src/ASTNodeArray.c
 )
 
 target_include_directories(calculator_lib
     PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 
-# 🔥 aquí está la magia
 target_link_libraries(calculator_lib
     PUBLIC arena
     PUBLIC arraylist

src/main.c

@@ -1,4 +1,3 @@
-#include "arena.h"
 #include "evaluator.h"
 #include "lexer.h"
 #include "parser.h"

test/test_ASTNodeArray.c

@@ -1,86 +0,0 @@
-#include "lexer.h"
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <setjmp.h>
-#include <cmocka.h>
-
-static void test_array_push(void **state) {
-    (void) state;
-
-    // We use 2 to force resize and checking anything wrong with malloc
-    ASTNodeArray arr = ASTNodeArray_init(2);
-    ASTNode node1 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 90 }
-    };
-
-    ASTNode node2 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 80 }
-    };
-
-    ASTNode node3 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 70 }
-    };
-
-    assert_int_equal(ASTNodeArray_push(&arr, node1), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 1);
-
-    assert_int_equal(ASTNodeArray_push(&arr, node2), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 2);
-
-    assert_int_equal(ASTNodeArray_push(&arr, node3), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 3);
-
-    ASTNodeArray_free(&arr);
-}
-
-static void test_array_pop(void **state) {
-    (void) state;
-
-    // Set to force desize
-    ASTNodeArray arr = ASTNodeArray_init(16);
-    ASTNode node1 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 90 }
-    };
-
-    ASTNode node2 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 80 }
-    };
-
-    ASTNode node3 = {
-        .type = NODE_INTEGER,
-        .data = { .integer = 70 }
-    };
-
-    assert_int_equal(ASTNodeArray_push(&arr, node1), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 1);
-
-    assert_int_equal(ASTNodeArray_push(&arr, node2), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 2);
-
-    assert_int_equal(ASTNodeArray_push(&arr, node3), ARRAY_OK);
-    assert_int_equal(ASTNodeArray_len(&arr), 3);
-
-    ASTNode node4;
-    assert_int_equal(ASTNodeArray_pop(&arr, 1, &node4), ARRAY_OK);
-    assert_int_equal(node4.type, NODE_INTEGER);
-    assert_int_equal(node4.data.integer, 80);
-
-    ASTNodeArray_free(&arr);
-}
-
-
-int main(void) {
-    const struct CMUnitTest tests[] = {
-        cmocka_unit_test(test_array_push),
-        cmocka_unit_test(test_array_pop),
-    };
-
-    return cmocka_run_group_tests(tests, NULL, NULL);
-}

test/test_lexer.c

@@ -1,3 +1,4 @@
+#include "arraylist.h"
 #include "lexer.h"
 #include <stdarg.h>
 #include <stdbool.h>
@@ -10,37 +11,37 @@ static void test_tokenize_normal_expresion(void **state) {
     (void) state;
 
     char expr[256] = "2 + 3 / 66 * 789";
-    ASTNodeArray tokens;
     ASTNode node;
-    
+    TokenizeResult tokens = tokenize(expr);
-    assert_int_equal(tokenize(expr, &tokens), LEXER_OK);
-    assert_int_equal(tokens.len, 7);
 
-    ASTNodeArray_get(&tokens, 0, &node);
+    assert_true(tokens.is_valid);
+    assert_int_equal(arraylist_size(tokens.arr), 7);
+
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 2);
 
-    ASTNodeArray_get(&tokens, 1, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_ADD);
 
-    ASTNodeArray_get(&tokens, 2, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 3);
 
-    ASTNodeArray_get(&tokens, 3, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_DIV);
 
-    ASTNodeArray_get(&tokens, 4, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 66);
 
-    ASTNodeArray_get(&tokens, 5, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_BINARY_OP);
     assert_int_equal(node.data.binary.op, OP_MUL);
 
-    ASTNodeArray_get(&tokens, 6, &node);
+    arraylist_get(tokens.arr, 0, &node);
     assert_int_equal(node.type, NODE_INTEGER);
     assert_int_equal(node.data.integer, 789);
 }
@@ -49,28 +50,20 @@ static void test_tokenize_unrecognized_symbol(void **state) {
     (void) state;
 
     char expr[256] = " 2 j 3 / 66 } 789";
-    ASTNodeArray tokens = {
+    TokenizeResult tokens = tokenize(expr);
-        .len = 0,
-        .cap = 0,
-    };
 
-    assert_int_equal(tokenize(expr, &tokens), LEXER_NOT_RECOGNIZED_SYMBOL);
+    assert_false(tokens.is_valid);
-    assert_int_equal(tokens.len, 0);
+    assert_uint_equal(tokens.err, LEXER_WRONG_SYNTAX);
-    assert_int_equal(tokens.cap, 0);
 }
 
 static void test_tokenize_wrong_sintax(void **state) {
     (void) state;
 
     char expr[256] = "2 3 / 66 789";
-    ASTNodeArray tokens = {
+    TokenizeResult tokens = tokenize(expr);
-        .len = 0,
-        .cap = 0,
-    };
 
-    assert_int_equal(tokenize(expr, &tokens), LEXER_WRONG_SYNTAX);
+    assert_false(tokens.is_valid);
-    assert_int_equal(tokens.len, 0);
+    assert_uint_equal(tokens.err, LEXER_WRONG_SYNTAX);
-    assert_int_equal(tokens.cap, 0);
 }
 
 static void test_string_to_number_normal(void **state) {
@@ -78,13 +71,13 @@ static void test_string_to_number_normal(void **state) {
 
     char num[16] = "2333t55";
     size_t offset = 0;
-    ASTNode result;
+    ASTNodeResult result = tokenize_number(num, &offset);
 
-    assert_int_equal(tokenize_number(num, &offset, &result), LEXER_OK);
+    assert_true(result.is_valid);
 
     assert_int_equal(offset, 4); // equal to t position in string
-    assert_int_equal(result.type, NODE_INTEGER);
+    assert_int_equal(result.node.type, NODE_INTEGER);
-    assert_int_equal(result.data.integer, 2333);
+    assert_int_equal(result.node.data.integer, 2333);
 }
 
 static void test_string_to_number_overflow(void **state) {
@@ -93,8 +86,9 @@ static void test_string_to_number_overflow(void **state) {
     // Number is INT64_MAX but with a extra 8 at the end
     char num[32] = "92233720368547758078yy7";
     size_t offset = 0;
-    ASTNode result;
+    ASTNodeResult result = tokenize_number(num, &offset);
-    assert_int_equal(tokenize_number(num, &offset, &result), LEXER_INT_OVERFLOW);
+    assert_false(result.is_valid);
+    assert_uint_equal(result.err, LEXER_INT_OVERFLOW);
     // Technically it can trigger a buf overflow error but obvioulsy 
     // it will trigger int overflow error first
 }