fix: updating arena and arraylist use

Reviewed-on: #12

.gitignore

@@ -9,6 +9,7 @@ out/Release/
 
 # Cmake files
 CMakeCache.txt
+cmake
 CMakeFiles/
 cmake_install.cmake
 CTestTestfile.cmake

CMakeLists.txt

@@ -4,7 +4,7 @@ project(calculator VERSION 1.0 LANGUAGES C)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
-# Export compile_commands.json (para clangd)
+# clangd
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 add_compile_options(
@@ -13,24 +13,38 @@ add_compile_options(
     -Wpedantic
 )
 
+include(cmake/CPM.cmake)
 
-include_directories(include)
+CPMAddPackage(
+    NAME arena
+    GIT_REPOSITORY https://laentropia-homelab.tail7368da.ts.net/laentropia/Arena.git
+    GIT_TAG main
+)
+
+CPMAddPackage(
+    NAME arraylist
+    GIT_REPOSITORY https://laentropia-homelab.tail7368da.ts.net/laentropia/ArrayList.git
+    GIT_TAG main
+)
 
 add_library(calculator_lib
     src/lexer.c
     src/parser.c
-    src/ast.c
     src/evaluator.c
 )
 
+target_include_directories(calculator_lib
+    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+target_link_libraries(calculator_lib
+    PUBLIC arena
+    PUBLIC arraylist
+    PRIVATE m
+)
+
 add_executable(calculator src/main.c)
-
 target_link_libraries(calculator calculator_lib)
 
-# ------------------------
-# Testing
-# ------------------------
-
 enable_testing()
 add_subdirectory(test)
-

include/evaluator.h

@@ -0,0 +1,29 @@
+#ifndef EVALUATOR_H
+#define EVALUATOR_H
+
+#include "parser.h"
+#include <stdint.h>
+
+typedef enum {
+    EVALUATOR_OK,
+    EVALUATOR_MATH_ERR,
+    EVALUATOR_DIVISION_BY_ZERO,
+    EVALUATOR_INVALID_PARSING,
+    EVALUATOR_INVALID_TREE, // just to shut up the compiler with the swithces
+} EvaluatorErr;
+
+typedef struct {
+    bool is_valid;
+    union {
+        int64_t val;
+        EvaluatorErr err;
+    };
+} EvaluatorResult;
+
+EvaluatorResult evaluate_binary(Node *tree);
+EvaluatorResult evaluate_unary(Node *tree);
+
+EvaluatorResult evaluate(ParserResult context);
+EvaluatorResult evaluate_tree(Node *tree);
+
+#endif // !EVALUATOR_H

include/lexer.h

@@ -0,0 +1,76 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include "arraylist.h"
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+// For identifing
+typedef enum {
+    TOKEN_INTEGER,
+    TOKEN_OPERATOR,
+} TokenType;
+// For classify operators
+typedef enum {
+    OP_ADD,
+    OP_SUB,
+    OP_MUL,
+    OP_DIV,
+    OP_POW,
+    OP_FACTORIAL,
+    OP_START_PAR,
+    OP_END_PAR,
+} Operator;
+
+typedef enum {
+    LEXER_OK = 0,
+    LEXER_INT_OVERFLOW,
+    LEXER_FAILED_NUMBER_CONVERSION,
+    LEXER_NOT_RECOGNIZED_SYMBOL,
+    LEXER_EMPTY_INPUT,
+    LEXER_BUF_OVERFLOW,
+} LexerErr;
+
+// Can be thought as tokens, they will be used by the parser.
+typedef struct {
+    TokenType type;
+    union {
+        int64_t num;
+        Operator op;
+    };
+} Token;
+
+typedef struct {
+    bool is_valid;
+    union {
+        LexerErr err;
+        ArrayList *arr;
+    };
+} TokenizeResult;
+
+typedef struct {
+    bool is_valid;
+    union {
+        LexerErr err;
+        Token token;
+    };
+} TokenResult;
+
+typedef struct {
+    bool is_valid;
+    union {
+        LexerErr err;
+        int64_t num;
+    };
+} LexerI64Result;
+
+// Lexer funtions as well as few functionality
+TokenizeResult tokenize(const char* input);
+TokenResult tokenize_number(const char* input, size_t *offset);
+LexerI64Result string_to_integer(const char buf[]);
+bool isoperator(int c);
+Operator char_to_operator(int c);
+char operator_to_char(Operator op);
+
+#endif // !LEXER_H

include/parser.h

@@ -0,0 +1,89 @@
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "lexer.h"
+#include "arena.h"
+#include "arraylist.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef enum {
+    NODE_INT,
+    NODE_BINARY_OP,
+    NODE_UNARY_OP,
+} NodeType;
+
+typedef struct Node {
+    NodeType type;
+    union {
+        int64_t num;
+        struct {
+            Operator op;
+            struct Node *left;
+            struct Node *right;
+        }binary;
+        struct {
+            Operator op;
+            struct Node *to;
+        }unary;
+        Operator par;
+    };
+} Node;
+
+typedef enum {
+    PARSER_OK = 0,
+    PARSER_UNEXPECTED_TOKEN,
+    PARSER_MISSING_OPERAND,
+    PARSER_UNMATCHED_PAREN,
+    PARSER_OUT_OF_MEMORY,
+    PARSER_INVALID_TOKENIZE,
+    PARSER_UNEXPECTED_EOF,
+} ParserErr;
+
+typedef struct {
+    bool is_valid;
+    union {
+        ParserErr err;
+        struct {
+            Arena *arena;
+            Node *tree;
+        };
+    };
+} ParserResult;
+
+typedef struct  {
+    bool is_valid;
+    union {
+        ParserErr err;
+        Node *node;
+    };
+} TreeResult;
+
+typedef struct {
+    bool is_valid;
+    union {
+        ParserErr err;
+        Node node;
+    };
+} NodeResult;
+
+typedef struct {
+    bool is_valid;
+    union {
+        ParserErr err;
+        uint8_t num;
+    };
+} ParserU8Result;
+
+TreeResult nud(ArraySlice *slice, Arena *arena, Token token); // Null denotation
+TreeResult led(ArraySlice *slice, Arena *arena, Node *left, Token token); // Left denotation
+
+ParserU8Result prefix_rbp(Token token);
+ParserU8Result postfix_lbp(Token token);
+ParserU8Result infix_lbp(Token token);
+ParserU8Result infix_rbp(Token token);
+
+ParserResult parse(TokenizeResult tokens);
+TreeResult parse_expr(ArraySlice *slice, Arena *arena, uint8_t min_bp);
+
+#endif // !PARSER_H

src/evaluator.c

@@ -0,0 +1,115 @@
+#include "evaluator.h"
+#include "arena.h"
+#include "lexer.h"
+#include "parser.h"
+#include <stdbool.h>
+#include <stdint.h>
+#include <math.h>
+
+
+EvaluatorResult evaluate_tree(Node *tree) {
+    if (tree->type == NODE_BINARY_OP) {
+        return evaluate_binary(tree);
+    } else if (tree->type == NODE_UNARY_OP) {
+        return evaluate_unary(tree);
+    }
+
+    return (EvaluatorResult) {
+        .is_valid = true,
+        .val = tree->num,
+    };
+}
+
+EvaluatorResult evaluate_binary(Node *tree) {
+    Operator op = tree->binary.op;
+    Node *left = tree->binary.left;
+    Node *right = tree->binary.right;
+    
+    EvaluatorResult left_result = evaluate_tree(left);
+    EvaluatorResult right_result = evaluate_tree(right);
+    if (!left_result.is_valid) {
+        return left_result;
+    }
+
+    if (!left_result.is_valid) {
+        return left_result;
+    }
+
+    switch (op) {
+        case OP_ADD:
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = left_result.val + right_result.val,
+            };
+        case OP_SUB:
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = left_result.val - right_result.val,
+            };
+        case OP_MUL:
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = left_result.val * right_result.val,
+            };
+        case OP_DIV: 
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = left_result.val / right_result.val,
+            };
+        case OP_POW: 
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = pow(left_result.val, right_result.val),
+            };
+        default:
+            return (EvaluatorResult) {
+                .is_valid = false,
+                .err = EVALUATOR_INVALID_TREE,
+            };
+    }
+}
+
+EvaluatorResult evaluate_unary(Node *tree) {
+    Operator op = tree->unary.op;
+    Node *to = tree->unary.to;
+
+    EvaluatorResult result = evaluate_tree(to);
+    if (!result.is_valid) {
+        return result;
+    }
+
+    switch (op) {
+        case OP_ADD:
+            return result;
+        case OP_SUB:
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = -result.val,
+            };
+        case OP_FACTORIAL:
+            return (EvaluatorResult) {
+                .is_valid = true,
+                .val = tgamma(result.val + 1),
+            };
+        default:
+            return (EvaluatorResult) {
+                .is_valid = false,
+                .err = EVALUATOR_INVALID_TREE,
+            };
+    }
+}
+
+EvaluatorResult evaluate(ParserResult context) {
+    if (!context.is_valid) {
+        return (EvaluatorResult) {
+            .is_valid = false,
+            .err = EVALUATOR_INVALID_PARSING,
+        };
+    }
+
+    EvaluatorResult result = evaluate_tree(context.tree);
+
+    arena_destroy(&context.arena);
+
+    return result;
+}

src/lexer.c

@@ -0,0 +1,195 @@
+#include "lexer.h"
+#include "arraylist.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+typedef enum {
+    WAIT_FOR_NUMBER,
+    WAIT_FOR_OPERATOR
+} LexerState;
+
+
+TokenizeResult tokenize(const char *input) {
+    ArrayList *arr;
+    arraylist_init(&arr, 64, sizeof(Token));
+    size_t offset = 0;
+
+    while (input[offset] != '\0') {
+
+        if (isdigit(input[offset])) {
+            TokenResult result = tokenize_number(input, &offset);
+
+            if (!result.is_valid) {
+                arraylist_destroy(&arr);
+                return (TokenizeResult) {.is_valid = false, .err = result.err};
+            }
+
+            arraylist_push_back(arr, &result.token);
+        } else if (isoperator(input[offset])) {
+            Token op_node = {
+                .type = TOKEN_OPERATOR,
+                .op = char_to_operator(input[offset]),
+            };
+            
+            arraylist_push_back(arr, &op_node);
+        } else if (isspace(input[offset])) {
+            // Nothing...
+        } else {
+            arraylist_destroy(&arr);
+            return (TokenizeResult) {
+                .is_valid = false,
+                .err = LEXER_NOT_RECOGNIZED_SYMBOL};
+        }
+
+        offset++;
+    }
+
+    if (arraylist_size(arr) < 1) {
+        arraylist_destroy(&arr);
+        return (TokenizeResult) {.is_valid = false, .err = LEXER_EMPTY_INPUT};
+    }
+
+    return (TokenizeResult) {.is_valid = true, .arr = arr};
+}
+
+// CURRENTLY, it only supports ints, not clear how floating
+// point is implemented but i'll figure it out
+TokenResult tokenize_number(const char *input, size_t *offset) {
+    char buf[64] = { '\0' };
+    size_t buf_pos = 0;
+    bool is_integer = true; // Will later be used to differentiate fractions
+
+    // read number
+    size_t current = *offset;
+    while (isdigit(input[current])) {
+        if (buf_pos >= sizeof(buf) - 1) {
+            return (TokenResult) {
+                .is_valid = false,
+                .err = LEXER_BUF_OVERFLOW};
+        }
+
+        buf[buf_pos] = input[current];
+
+        current++;
+        buf_pos++;
+    }
+
+    Token new_token;
+    if (is_integer) {
+        new_token.type = TOKEN_INTEGER;
+        LexerI64Result result = string_to_integer(buf);
+
+
+        if (!result.is_valid) {
+            return (TokenResult) {.is_valid = false, .err = result.err};
+        }
+
+        new_token.num = result.num;
+
+        *offset = current - 1;
+        return (TokenResult) {.is_valid = true, .token = new_token};
+    }
+
+    return (TokenResult) {
+        .is_valid = false,
+        .err = LEXER_FAILED_NUMBER_CONVERSION};
+}
+
+LexerI64Result string_to_integer(const char *buf) {
+    int c = 0;
+    int64_t count = 0;
+
+    while (buf[c] != '\0') {
+
+        // Extracts number from char
+        int digit = buf[c] - '0';
+
+        if (count > (INT64_MAX - digit) / 10) {
+            return (LexerI64Result) {
+                .is_valid = false,
+                .err = LEXER_INT_OVERFLOW};
+        }
+
+        count = count * 10;
+        count += digit;
+        
+        c++;
+    }
+
+    return (LexerI64Result) {.is_valid = true, .num = count};
+}
+
+bool isoperator(int c) {
+    switch (c) {
+        case '+':
+        case '-':
+        case '/':
+        case '*':
+        case '^':
+        case '!':
+        case '(':
+        case ')':
+            return true;
+        default:
+            return false;
+    }
+}
+
+Operator char_to_operator(int c) {
+    switch (c) {
+        case '+':
+            return OP_ADD;
+            break;
+        case '-':
+            return OP_SUB;
+            break;
+        case '*':
+            return OP_MUL;
+            break;
+        case '/':
+            return OP_DIV;
+            break;
+        case '^':
+            return OP_POW;
+            break;
+        case '!':
+            return OP_FACTORIAL;
+            break;
+        case '(':
+            return OP_START_PAR;
+            break;
+        case ')':
+            return OP_END_PAR;
+            break;
+        default: // I mean shouldn't be used, we assume
+            return -1;
+    }
+}
+
+char operator_to_char(Operator op) {
+    switch (op) {
+        case OP_ADD:
+            return '+';
+        case OP_SUB:
+            return '-';
+        case OP_MUL:
+            return '*';
+        case OP_DIV:
+            return '/';
+        case OP_POW:
+            return '^';
+        case OP_FACTORIAL:
+            return '!';
+        case OP_START_PAR:
+            return '(';
+        case OP_END_PAR:
+            return ')';
+        default:
+            return EOF;
+    }
+}

src/main.c

@@ -1,7 +1,28 @@
+#include "evaluator.h"
+#include "lexer.h"
+#include "parser.h"
+#include <stdint.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <stdio.h>
 
-int main(int argc, char *argv[]) {
+int main(void) {
-    puts("Hello");
+    char buf[256];
+    printf("Insert a valid mathematical expression: ");
+    
+    int c;
+    int pos = 0;
+    while ((c = getc(stdin)) != '\n' && c != EOF) {
+        buf[pos] = c;
+        pos++;
+    }
+    buf[pos] = '\0';
+
+    EvaluatorResult result = evaluate(parse(tokenize(buf)));
+    if (!result.is_valid) {
+        puts("Error checando expresion");
+    }
+
+    printf("El resultado es: %" PRIi64 "\n", result.val);
     return EXIT_SUCCESS;
 }

src/parser.c

@@ -0,0 +1,394 @@
+#include "parser.h"
+#include "arraylist.h"
+#include "lexer.h"
+#include "arena.h"
+#include <cmocka.h>
+#include <stdalign.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+ParserU8Result prefix_rbp(Token token) {
+    if (token.type == TOKEN_INTEGER) {
+        return (ParserU8Result) {
+            .is_valid = false,
+            .err = PARSER_UNEXPECTED_TOKEN,
+        };
+    }
+    switch (token.op) {
+        case OP_SUB:
+        case OP_ADD:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 30,
+            };
+        default:
+            return (ParserU8Result) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+            };
+    }
+}
+
+ParserU8Result postfix_lbp(Token token) {
+    if (token.type != TOKEN_OPERATOR) {
+        return (ParserU8Result) {
+            .is_valid = false,
+            .err = PARSER_UNEXPECTED_TOKEN,
+        };
+    }
+
+    switch (token.op) {
+        case OP_FACTORIAL:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 40,
+            };
+        default:
+            return (ParserU8Result) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+            };
+    }
+}
+
+ParserU8Result infix_lbp(Token token) {
+    if (token.type != TOKEN_OPERATOR) {
+        return (ParserU8Result) {
+            .is_valid = false,
+            .err = PARSER_UNEXPECTED_TOKEN,
+        };
+    }
+
+    switch (token.op) {
+        case OP_ADD:
+        case OP_SUB:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 10,
+            };
+        case OP_DIV:
+        case OP_MUL:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 20,
+            };
+        case OP_POW:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 51,
+            };
+        default:
+            return (ParserU8Result) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+            };
+    }
+}
+
+ParserU8Result infix_rbp(Token token) {
+    if (token.type != TOKEN_OPERATOR) {
+        return (ParserU8Result) {
+            .is_valid = false,
+            .err = PARSER_UNEXPECTED_TOKEN,
+        };
+    }
+
+    switch (token.op) {
+        case OP_ADD:
+        case OP_SUB:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 11,
+            };
+        case OP_DIV:
+        case OP_MUL:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 21,
+            };
+        case OP_POW:
+            return (ParserU8Result) {
+                .is_valid = true,
+                .num = 50,
+            };
+        default:
+            return (ParserU8Result) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+            };
+    }
+}
+
+TreeResult led(
+    ArraySlice *slice,
+    Arena *arena,
+    Node *left,
+    Token token
+) {
+    arena_ensure_capacity(
+        arena,
+        sizeof(Node),
+        alignof(Node)
+    );
+
+    Node *node = arena_unwrap_pointer(
+        arena_alloc(
+            arena,
+            sizeof(Node),
+            alignof(Node)
+        )
+    );
+
+    switch (token.op) {
+
+        // Binary operators
+        case OP_ADD:
+        case OP_SUB:
+        case OP_MUL:
+        case OP_DIV:
+        case OP_POW: {
+            node->type = NODE_BINARY_OP;
+            node->binary.op = token.op;
+
+            ParserU8Result rbp_result = infix_rbp(token);
+            if (!rbp_result.is_valid) {
+                return (TreeResult) {
+                    .is_valid = false,
+                    .err = rbp_result.err,
+                };
+            }
+
+            TreeResult right = parse_expr(
+                slice,
+                arena,
+                rbp_result.num
+            );
+
+            if (!right.is_valid) {
+                return right;
+            }
+
+            node->binary.left = left;
+            node->binary.right = right.node;
+
+            return (TreeResult) {
+                .is_valid = true,
+                .node = node,
+            };
+        }
+
+        // Postfix operators
+        case OP_FACTORIAL: {
+            node->type = NODE_UNARY_OP;
+            node->unary.op = token.op;
+            node->unary.to = left;
+
+            return (TreeResult) {
+                .is_valid = true,
+                .node = node,
+            };
+        }
+
+        default:
+            return (TreeResult) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+            };
+    }
+}
+
+TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
+    arena_ensure_capacity(
+        arena,
+        sizeof(Node), 
+        alignof(Node)
+    );
+
+    Node *node = arena_unwrap_pointer(
+        arena_alloc(
+            arena, 
+            sizeof(Node),
+            alignof(Node)
+        )
+    );
+
+    if (token.type == TOKEN_INTEGER) {
+        node->type = NODE_INT;
+        node->num = token.num;
+
+        return (TreeResult) {
+            .is_valid = true,
+            .node = node,
+        };
+    }
+
+    switch (token.op) {
+        case OP_START_PAR: {
+            TreeResult expr = parse_expr(slice, arena, 0);
+            if (!expr.is_valid) {
+                return expr;
+            }
+
+            Token end_par;
+            if (arrayslice_next(slice, &end_par) != ARRLIST_OK) {
+                return (TreeResult) {
+                    .is_valid = false,
+                    .err = PARSER_UNMATCHED_PAREN,
+                };
+            }
+
+            if (end_par.type != TOKEN_OPERATOR ||
+                end_par.op != OP_END_PAR) {
+                return (TreeResult) {
+                    .is_valid = false,
+                    .err = PARSER_UNMATCHED_PAREN,
+                };
+            }
+
+            return expr;
+        }
+        case OP_ADD:
+
+        case OP_SUB: {
+            node->type = NODE_UNARY_OP;
+            node->unary.op = token.op;
+
+            ParserU8Result rbp_result = prefix_rbp(token);
+            if (!rbp_result.is_valid) {
+                return (TreeResult) {
+                    .is_valid = false,
+                    .err = rbp_result.err,
+                };
+            }
+
+            TreeResult right = parse_expr(
+                slice,
+                arena,
+                rbp_result.num
+            );
+
+            if (!right.is_valid) {
+                return right;
+            }
+
+            node->unary.to = right.node;
+
+            return (TreeResult) {
+                .is_valid = true,
+                .node = node,
+            };
+        }
+        default:
+            return (TreeResult) {
+                .is_valid = false,
+                .err = PARSER_UNEXPECTED_TOKEN,
+        };
+    }
+}
+
+
+
+ParserResult parse(TokenizeResult tokens) {
+    if (!tokens.is_valid) {
+        return (ParserResult) {
+            .is_valid = false,
+            .err = PARSER_INVALID_TOKENIZE,
+        };
+    }
+
+    ArraySlice *context;
+    arraylist_slice(&context, tokens.arr, 0, arraylist_size(tokens.arr));
+    Arena *arena;
+    arena_init(&arena, sizeof(Node) * arraylist_size(tokens.arr));
+
+    TreeResult result = parse_expr(context, arena, 0);
+    if (!result.is_valid) {
+        arena_destroy(&arena);
+        arraylist_destroy(&tokens.arr);
+        return (ParserResult) {
+            .is_valid = false,
+            .err = result.err,
+        };
+    }
+
+    arraylist_destroy(&tokens.arr);
+    return (ParserResult) {
+        .is_valid = true,
+        .arena = arena,
+        .tree = result.node};
+}
+
+TreeResult parse_expr(ArraySlice *slice, Arena *arena, uint8_t min_bp) {
+    Token current_token;
+
+    if (arrayslice_next(slice, &current_token) != ARRLIST_OK) {
+        return (TreeResult) {
+            .is_valid = false,
+            .err = PARSER_UNEXPECTED_EOF,
+        };
+    }
+
+    TreeResult left_result = nud(slice, arena, current_token);
+
+    if (!left_result.is_valid) {
+        return left_result;
+    }
+
+    Node *left_side = left_result.node;
+
+    while (arrayslice_is_valid(slice)) {
+        Token operator_token;
+        arrayslice_peek(slice, &operator_token);
+
+        if (operator_token.type != TOKEN_OPERATOR) {
+            break;
+        }
+
+        ParserU8Result postfix_lbp_result = postfix_lbp(operator_token);
+
+        if (postfix_lbp_result.is_valid) {
+            if (postfix_lbp_result.num < min_bp) {
+                break;
+            }
+
+            arrayslice_next(slice, NULL);
+
+            TreeResult result = led(slice, arena, left_side, operator_token);
+
+            if (!result.is_valid) {
+                return result;
+            }
+
+            left_side = result.node;
+
+            continue;
+        }
+
+        // Path for infix basically
+        ParserU8Result lbp_result = infix_lbp(operator_token);
+
+        if (!lbp_result.is_valid) {
+            break;
+        }
+
+        if (lbp_result.num < min_bp) {
+            break;
+        }
+
+        arrayslice_next(slice, NULL);
+
+        TreeResult result = led(slice, arena, left_side, operator_token);
+
+        if (!result.is_valid) {
+            return result;
+        }
+
+        left_side = result.node;
+    }
+
+    // Final: return left side
+    return (TreeResult){
+        .is_valid = true,
+        .node = left_side,
+    };
+}

test/CMakeLists.txt

@@ -1,10 +1,24 @@
 find_package(cmocka REQUIRED)
 
+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_lexer
+    calculator_lib
+    cmocka::cmocka
+)
 
 target_link_libraries(test_parser
     calculator_lib
     cmocka::cmocka
 )
 
+target_link_libraries(test_evaluator
+    calculator_lib
+    cmocka::cmocka
+)
+
+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

@@ -0,0 +1,13 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <stdlib.h>
+
+
+
+int main(void) {
+    return EXIT_SUCCESS;
+}

test/test_lexer.c

@@ -0,0 +1,11 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <stdlib.h>
+
+int main(void) {
+    return EXIT_SUCCESS;
+}

test/test_parser.c

@@ -1,5 +1,11 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <setjmp.h>
+#include <cmocka.h>
 #include <stdlib.h>
 
-int main() {
+int main(void) {
     return EXIT_SUCCESS;
 }