laentropia/Calculator
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

refactor: xmake in use, allocator sintaxis #13

Merged
laentropia merged 1 commits from refactor-xmake into main 2026-06-10 16:05:00 -06:00
Conversation 0 Commits 1 Files Changed 9 +444 -578
9 changed files with 444 additions and 578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
.gitignore vendored
View File

@@ -7,6 +7,12 @@ out/
out/Debug/ out/Debug/
out/Release/ out/Release/
# xmake
.xmake
xmake
xmake/
.xmake/
# Cmake files # Cmake files
CMakeCache.txt CMakeCache.txt
cmake cmake

100
CMakeLists.txt
View File

@@ -1,100 +0,0 @@
cmake_minimum_required(VERSION 3.20)
project(
calculator
VERSION 1.0
LANGUAGES C)
# ------------------------------------------------
# C standard — no compiler extensions
# ------------------------------------------------
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)
# Export compile_commands.json (clangd / IDEs)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# ------------------------------------------------
# Options
# ------------------------------------------------
option(CALCULATOR_BUILD_TESTS "Build calculator tests" ON)
option(CALCULATOR_ENABLE_SANITIZERS "Enable Address Sanitizer in tests" ON)
# ------------------------------------------------
# Portable warning flags
# ------------------------------------------------
if(MSVC)
add_compile_options(/W4)
else()
add_compile_options(-Wall -Wextra -Wpedantic)
endif()
# ================================================================
# CPM.cmake bootstrap Descarga CPM solo si no existe; usa caché para builds
# offline.
# ================================================================
set(CPM_DOWNLOAD_VERSION 0.40.2)
set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM.cmake")
if(NOT EXISTS "${CPM_DOWNLOAD_LOCATION}")
message(
STATUS "[calculator] Downloading CPM.cmake v${CPM_DOWNLOAD_VERSION}...")
file(
DOWNLOAD
"https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake"
"${CPM_DOWNLOAD_LOCATION}"
STATUS download_status
TLS_VERIFY ON)
list(GET download_status 0 status_code)
list(GET download_status 1 status_msg)
if(NOT status_code EQUAL 0)
message(
FATAL_ERROR "[calculator] Failed to download CPM.cmake: ${status_msg}")
endif()
endif()
include("${CPM_DOWNLOAD_LOCATION}")
# ================================================================
# Dependencies via CPM
# ================================================================
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)
# ================================================================
# LIBRARY (lógica reutilizable, separada del ejecutable)
# ================================================================
add_library(calculator_lib src/lexer.c src/parser.c src/evaluator.c)
target_include_directories(
calculator_lib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>)
target_compile_features(calculator_lib PUBLIC c_std_11)
target_link_libraries(
calculator_lib
PUBLIC arena
PUBLIC arraylist
PRIVATE m) # libm — solo en el linker interno, no se propaga
# ================================================================
# EXECUTABLE
# ================================================================
add_executable(calculator src/main.c)
target_link_libraries(calculator PRIVATE calculator_lib)
# ================================================================
# TESTS
# ================================================================
if(CALCULATOR_BUILD_TESTS)
enable_testing()
add_subdirectory(test)
endif()

8
include/lexer.h
View File

@@ -1,9 +1,9 @@
#ifndef LEXER_H #ifndef LEXER_H
#define LEXER_H #define LEXER_H
#include "arraylist.h" #include "lae_arraylist.h"
#include <stddef.h>
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
// For identifing // For identifing
@@ -66,8 +66,8 @@ typedef struct {
} LexerI64Result; } LexerI64Result;
// Lexer funtions as well as few functionality // Lexer funtions as well as few functionality
TokenizeResult tokenize(const char* input); TokenizeResult tokenize(const char *input);
TokenResult tokenize_number(const char* input, size_t *offset); TokenResult tokenize_number(const char *input, size_t *offset);
LexerI64Result string_to_integer(const char buf[]); LexerI64Result string_to_integer(const char buf[]);
bool isoperator(int c); bool isoperator(int c);
Operator char_to_operator(int c); Operator char_to_operator(int c);

16
include/parser.h
View File

@@ -1,9 +1,9 @@
#ifndef PARSER_H #ifndef PARSER_H
#define PARSER_H #define PARSER_H
#include "lae_arena.h"
#include "lae_arraylist.h"
#include "lexer.h" #include "lexer.h"
#include "arena.h"
#include "arraylist.h"
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
@@ -21,11 +21,11 @@ typedef struct Node {
Operator op; Operator op;
struct Node *left; struct Node *left;
struct Node *right; struct Node *right;
}binary; } binary;
struct { struct {
Operator op; Operator op;
struct Node *to; struct Node *to;
}unary; } unary;
Operator par; Operator par;
}; };
} Node; } Node;
@@ -51,7 +51,7 @@ typedef struct {
}; };
} ParserResult; } ParserResult;
typedef struct { typedef struct {
bool is_valid; bool is_valid;
union { union {
ParserErr err; ParserErr err;
@@ -76,7 +76,11 @@ typedef struct {
} ParserU8Result; } ParserU8Result;
TreeResult nud(ArraySlice *slice, Arena *arena, Token token); // Null denotation TreeResult nud(ArraySlice *slice, Arena *arena, Token token); // Null denotation
TreeResult led(ArraySlice *slice, Arena *arena, Node *left, Token token); // Left denotation TreeResult
led(ArraySlice *slice,
Arena *arena,
Node *left,
Token token); // Left denotation
ParserU8Result prefix_rbp(Token token); ParserU8Result prefix_rbp(Token token);
ParserU8Result postfix_lbp(Token token); ParserU8Result postfix_lbp(Token token);

105
src/evaluator.c
View File

@@ -1,11 +1,10 @@
#include "evaluator.h" #include "evaluator.h"
#include "arena.h" #include "lae_arena.h"
#include "lexer.h" #include "lexer.h"
#include "parser.h" #include "parser.h"
#include <math.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <math.h>
EvaluatorResult evaluate_tree(Node *tree) { EvaluatorResult evaluate_tree(Node *tree) {
if (tree->type == NODE_BINARY_OP) { if (tree->type == NODE_BINARY_OP) {
@@ -14,7 +13,7 @@ EvaluatorResult evaluate_tree(Node *tree) {
return evaluate_unary(tree); return evaluate_unary(tree);
} }
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = tree->num, .val = tree->num,
}; };
@@ -24,7 +23,7 @@ EvaluatorResult evaluate_binary(Node *tree) {
Operator op = tree->binary.op; Operator op = tree->binary.op;
Node *left = tree->binary.left; Node *left = tree->binary.left;
Node *right = tree->binary.right; Node *right = tree->binary.right;
EvaluatorResult left_result = evaluate_tree(left); EvaluatorResult left_result = evaluate_tree(left);
EvaluatorResult right_result = evaluate_tree(right); EvaluatorResult right_result = evaluate_tree(right);
if (!left_result.is_valid) { if (!left_result.is_valid) {
@@ -36,36 +35,36 @@ EvaluatorResult evaluate_binary(Node *tree) {
} }
switch (op) { switch (op) {
case OP_ADD: case OP_ADD:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = left_result.val + right_result.val, .val = left_result.val + right_result.val,
}; };
case OP_SUB: case OP_SUB:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = left_result.val - right_result.val, .val = left_result.val - right_result.val,
}; };
case OP_MUL: case OP_MUL:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = left_result.val * right_result.val, .val = left_result.val * right_result.val,
}; };
case OP_DIV: case OP_DIV:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = left_result.val / right_result.val, .val = left_result.val / right_result.val,
}; };
case OP_POW: case OP_POW:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = pow(left_result.val, right_result.val), .val = pow(left_result.val, right_result.val),
}; };
default: default:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = false, .is_valid = false,
.err = EVALUATOR_INVALID_TREE, .err = EVALUATOR_INVALID_TREE,
}; };
} }
} }
@@ -79,29 +78,29 @@ EvaluatorResult evaluate_unary(Node *tree) {
} }
switch (op) { switch (op) {
case OP_ADD: case OP_ADD:
return result; return result;
case OP_SUB: case OP_SUB:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = -result.val, .val = -result.val,
}; };
case OP_FACTORIAL: case OP_FACTORIAL:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = true, .is_valid = true,
.val = tgamma(result.val + 1), .val = tgamma(result.val + 1),
}; };
default: default:
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = false, .is_valid = false,
.err = EVALUATOR_INVALID_TREE, .err = EVALUATOR_INVALID_TREE,
}; };
} }
} }
EvaluatorResult evaluate(ParserResult context) { EvaluatorResult evaluate(ParserResult context) {
if (!context.is_valid) { if (!context.is_valid) {
return (EvaluatorResult) { return (EvaluatorResult){
.is_valid = false, .is_valid = false,
.err = EVALUATOR_INVALID_PARSING, .err = EVALUATOR_INVALID_PARSING,
}; };

161
src/lexer.c
View File

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

405
src/parser.c
View File

@@ -1,7 +1,8 @@
#include "parser.h" #include "parser.h"
#include "arraylist.h" #include "lae_allocator.h"
#include "lae_arena.h"
#include "lae_arraylist.h"
#include "lexer.h" #include "lexer.h"
#include "arena.h"
#include <cmocka.h> #include <cmocka.h>
#include <stdalign.h> #include <stdalign.h>
#include <stdbool.h> #include <stdbool.h>
@@ -9,320 +10,292 @@
ParserU8Result prefix_rbp(Token token) { ParserU8Result prefix_rbp(Token token) {
if (token.type == TOKEN_INTEGER) { if (token.type == TOKEN_INTEGER) {
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
switch (token.op) { switch (token.op) {
case OP_SUB: case OP_SUB:
case OP_ADD: case OP_ADD:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 30, .num = 30,
}; };
default: default:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
} }
ParserU8Result postfix_lbp(Token token) { ParserU8Result postfix_lbp(Token token) {
if (token.type != TOKEN_OPERATOR) { if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
switch (token.op) { switch (token.op) {
case OP_FACTORIAL: case OP_FACTORIAL:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 40, .num = 40,
}; };
default: default:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
} }
ParserU8Result infix_lbp(Token token) { ParserU8Result infix_lbp(Token token) {
if (token.type != TOKEN_OPERATOR) { if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
switch (token.op) { switch (token.op) {
case OP_ADD: case OP_ADD:
case OP_SUB: case OP_SUB:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 10, .num = 10,
}; };
case OP_DIV: case OP_DIV:
case OP_MUL: case OP_MUL:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 20, .num = 20,
}; };
case OP_POW: case OP_POW:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 51, .num = 51,
}; };
default: default:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
} }
ParserU8Result infix_rbp(Token token) { ParserU8Result infix_rbp(Token token) {
if (token.type != TOKEN_OPERATOR) { if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
switch (token.op) { switch (token.op) {
case OP_ADD: case OP_ADD:
case OP_SUB: case OP_SUB:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 11, .num = 11,
}; };
case OP_DIV: case OP_DIV:
case OP_MUL: case OP_MUL:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 21, .num = 21,
}; };
case OP_POW: case OP_POW:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = true, .is_valid = true,
.num = 50, .num = 50,
}; };
default: default:
return (ParserU8Result) { return (ParserU8Result){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .err = PARSER_UNEXPECTED_TOKEN,
}; };
} }
} }
TreeResult led( TreeResult led(ArraySlice *slice, Arena *arena, Node *left, Token token) {
ArraySlice *slice, arena_ensure_capacity(arena, sizeof(Node), alignof(Node));
Arena *arena,
Node *left,
Token token
) {
arena_ensure_capacity(
arena,
sizeof(Node),
alignof(Node)
);
Node *node = arena_unwrap_pointer( Node *node =
arena_alloc( arena_unwrap_pointer(arena_alloc(arena, sizeof(Node), alignof(Node)));
arena,
sizeof(Node),
alignof(Node)
)
);
switch (token.op) { switch (token.op) {
// Binary operators // Binary operators
case OP_ADD: case OP_ADD:
case OP_SUB: case OP_SUB:
case OP_MUL: case OP_MUL:
case OP_DIV: case OP_DIV:
case OP_POW: { case OP_POW: {
node->type = NODE_BINARY_OP; node->type = NODE_BINARY_OP;
node->binary.op = token.op; node->binary.op = token.op;
ParserU8Result rbp_result = infix_rbp(token); ParserU8Result rbp_result = infix_rbp(token);
if (!rbp_result.is_valid) { if (!rbp_result.is_valid) {
return (TreeResult) { 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, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .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) { TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
arena_ensure_capacity( arena_ensure_capacity(arena, sizeof(Node), alignof(Node));
arena,
sizeof(Node),
alignof(Node)
);
Node *node = arena_unwrap_pointer( Node *node =
arena_alloc( arena_unwrap_pointer(arena_alloc(arena, sizeof(Node), alignof(Node)));
arena,
sizeof(Node),
alignof(Node)
)
);
if (token.type == TOKEN_INTEGER) { if (token.type == TOKEN_INTEGER) {
node->type = NODE_INT; node->type = NODE_INT;
node->num = token.num; node->num = token.num;
return (TreeResult) { return (TreeResult){
.is_valid = true, .is_valid = true,
.node = node, .node = node,
}; };
} }
switch (token.op) { switch (token.op) {
case OP_START_PAR: { case OP_START_PAR: {
TreeResult expr = parse_expr(slice, arena, 0); TreeResult expr = parse_expr(slice, arena, 0);
if (!expr.is_valid) { 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; return expr;
} }
case OP_ADD:
case OP_SUB: { Token end_par;
node->type = NODE_UNARY_OP; if (arrayslice_next(slice, &end_par) != ARRLIST_OK) {
node->unary.op = token.op; return (TreeResult){
.is_valid = false,
ParserU8Result rbp_result = prefix_rbp(token); .err = PARSER_UNMATCHED_PAREN,
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) { if (end_par.type != TOKEN_OPERATOR || end_par.op != OP_END_PAR) {
return (TreeResult){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN, .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) { ParserResult parse(TokenizeResult tokens) {
if (!tokens.is_valid) { if (!tokens.is_valid) {
return (ParserResult) { return (ParserResult){
.is_valid = false, .is_valid = false,
.err = PARSER_INVALID_TOKENIZE, .err = PARSER_INVALID_TOKENIZE,
}; };
} }
ArraySlice *context; ArraySlice *context;
arraylist_slice(&context, tokens.arr, 0, arraylist_size(tokens.arr)); arraylist_slice(
&context,
allocator_default(),
tokens.arr,
0,
arraylist_size(tokens.arr));
Arena *arena; Arena *arena;
arena_init(&arena, sizeof(Node) * arraylist_size(tokens.arr)); arena_init(
&arena,
allocator_default(),
sizeof(Node) * arraylist_size(tokens.arr));
TreeResult result = parse_expr(context, arena, 0); TreeResult result = parse_expr(context, arena, 0);
if (!result.is_valid) { if (!result.is_valid) {
arena_destroy(&arena); arena_destroy(&arena);
arraylist_destroy(&tokens.arr); arraylist_destroy(&tokens.arr);
return (ParserResult) { return (ParserResult){
.is_valid = false, .is_valid = false,
.err = result.err, .err = result.err,
}; };
} }
arraylist_destroy(&tokens.arr); arraylist_destroy(&tokens.arr);
return (ParserResult) { return (
.is_valid = true, ParserResult){.is_valid = true, .arena = arena, .tree = result.node};
.arena = arena,
.tree = result.node};
} }
TreeResult parse_expr(ArraySlice *slice, Arena *arena, uint8_t min_bp) { TreeResult parse_expr(ArraySlice *slice, Arena *arena, uint8_t min_bp) {
Token current_token; Token current_token;
if (arrayslice_next(slice, &current_token) != ARRLIST_OK) { if (arrayslice_next(slice, &current_token) != ARRLIST_OK) {
return (TreeResult) { return (TreeResult){
.is_valid = false, .is_valid = false,
.err = PARSER_UNEXPECTED_EOF, .err = PARSER_UNEXPECTED_EOF,
}; };

114
test/CMakeLists.txt
View File

@@ -1,114 +0,0 @@
# ================================================================
# FIND CMOCKA (system → FetchContent as fallback)
# ================================================================
find_package(cmocka QUIET)
if(NOT cmocka_FOUND)
message(
STATUS
"[calculator] cmocka not found on system — fetching with FetchContent...")
include(FetchContent)
FetchContent_Declare(
cmocka
GIT_REPOSITORY https://git.cryptomilk.org/projects/cmocka.git
GIT_TAG cmocka-1.1.7
GIT_SHALLOW TRUE)
# Static lib only, no cmocka examples or self-tests
set(WITH_STATIC_LIB
ON
CACHE BOOL "" FORCE)
set(WITH_SHARED_LIB
OFF
CACHE BOOL "" FORCE)
set(WITH_CMOCKERY_SUPPORT
OFF
CACHE BOOL "" FORCE)
set(WITH_EXAMPLES
OFF
CACHE BOOL "" FORCE)
set(UNIT_TESTING
OFF
CACHE BOOL "" FORCE)
set(PICKY_DEVELOPER
OFF
CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(cmocka)
# Normalize the target name (varies across cmocka versions)
if(NOT TARGET cmocka::cmocka)
if(TARGET cmocka-static)
add_library(cmocka::cmocka ALIAS cmocka-static)
elseif(TARGET cmocka)
add_library(cmocka::cmocka ALIAS cmocka)
else()
message(
WARNING "[calculator] Could not create cmocka::cmocka — skipping tests."
)
return()
endif()
endif()
endif()
# ================================================================
# DETECT ADDRESS SANITIZER SUPPORT
# ================================================================
set(CALCULATOR_USE_ASAN OFF)
if(CALCULATOR_ENABLE_SANITIZERS)
if(MSVC)
if(MSVC_VERSION GREATER_EQUAL 1928)
set(CALCULATOR_USE_ASAN ON)
else()
message(STATUS "[calculator] MSVC < 16.9: ASAN not available.")
endif()
elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND NOT WIN32)
include(CheckCCompilerFlag)
check_c_compiler_flag(-fsanitize=address CALCULATOR_COMPILER_HAS_ASAN)
if(CALCULATOR_COMPILER_HAS_ASAN)
set(CALCULATOR_USE_ASAN ON)
else()
message(
STATUS "[calculator] Compiler does not support -fsanitize=address.")
endif()
else()
message(STATUS "[calculator] Unknown platform/compiler — ASAN skipped.")
endif()
if(CALCULATOR_USE_ASAN)
message(STATUS "[calculator] Address Sanitizer enabled.")
endif()
endif()
# ================================================================
# Helper: apply common settings to every test target
# ================================================================
function(calculator_add_test target source)
add_executable(${target} ${source})
target_link_libraries(${target} PRIVATE calculator_lib cmocka::cmocka)
target_compile_features(${target} PRIVATE c_std_11)
if(CALCULATOR_USE_ASAN)
if(MSVC)
target_compile_options(${target} PRIVATE /fsanitize=address)
else()
target_compile_options(${target} PRIVATE -fsanitize=address
-fno-omit-frame-pointer)
target_link_options(${target} PRIVATE -fsanitize=address)
endif()
endif()
add_test(NAME ${target} COMMAND ${target})
set_tests_properties(${target} PROPERTIES TIMEOUT 30)
endfunction()
# ================================================================
# TEST TARGETS
# ================================================================
calculator_add_test(test_lexer test_lexer.c)
calculator_add_test(test_parser test_parser.c)
calculator_add_test(test_evaluator test_evaluator.c)

107
xmake.lua Normal file
View File

@@ -0,0 +1,107 @@
set_project("calculator")
set_version("1.0.0")
set_languages("c11")
add_rules("mode.debug", "mode.release")
-- clang compile commands
add_rules("plugin.compile_commands.autoupdate")
-- =========================================================
-- Options
-- =========================================================
option("tests")
set_default(false)
set_showmenu(true)
option_end()
option("asan")
set_default(false)
set_showmenu(true)
option_end()
-- =========================================================
-- Packages
-- =========================================================
-- Run xmake repo --add lae-repo https://laentropia-homelab.tail7368da.ts.net/laentropia/xmake-repo.git
-- to add my repo :)
add_requires("lae_arena")
add_requires("lae_arraylist")
add_requires("cmocka", { optional = true })
-- =========================================================
-- Library
-- =========================================================
target("calculator_lib")
set_kind("static")
add_packages("lae_arena", "lae_arraylist", {
public = true,
})
add_files("src/lexer.c", "src/parser.c", "src/evaluator.c")
add_headerfiles("include/*.h")
add_includedirs("include", {
public = true,
})
if is_mode("debug") then
add_cflags("-Wall", "-Wextra", "-Wpedantic")
end
if not is_plat("windows") then
add_syslinks("m")
end
-- =========================================================
-- Executable
-- =========================================================
target("calculator")
set_kind("binary")
add_deps("calculator_lib")
add_files("src/main.c")
-- =========================================================
-- Tests
-- =========================================================
if has_config("tests") then
local test_files = {
"test_lexer",
"test_parser",
"test_evaluator",
}
for _, name in ipairs(test_files) do
target(name)
set_kind("binary")
add_files("test/" .. name .. ".c")
add_deps("calculator_lib")
add_packages("cmocka")
add_tests("default")
if has_config("asan") then
add_cflags("-fsanitize=address", "-fno-omit-frame-pointer", {
force = true,
})
add_ldflags("-fsanitize=address", {
force = true,
})
end
end
end