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

Merge pull request 'refactor: xmake in use, allocator sintaxis' (#13) from refactor-xmake into main

Browse Source 
Reviewed-on: #13
This commit was merged in pull request #13.
This commit is contained in:
Alonso Adrian Martinez Hernandez
2026-06-10 16:05:00 -06:00
parent 21853362a4 9a2e084143
commit 14c115bdbc
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/Release/
# xmake
.xmake
xmake
xmake/
.xmake/
# Cmake files
CMakeCache.txt
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
#define LEXER_H
#include "arraylist.h"
#include <stddef.h>
#include "lae_arraylist.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
// For identifing
@@ -66,8 +66,8 @@ typedef struct {
} LexerI64Result;
// Lexer funtions as well as few functionality
TokenizeResult tokenize(const char* input);
TokenResult tokenize_number(const char* input, size_t *offset);
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);

14
include/parser.h
View File

@@ -1,9 +1,9 @@
#ifndef PARSER_H
#define PARSER_H
#include "lae_arena.h"
#include "lae_arraylist.h"
#include "lexer.h"
#include "arena.h"
#include "arraylist.h"
#include <stdbool.h>
#include <stdint.h>
@@ -21,11 +21,11 @@ typedef struct Node {
Operator op;
struct Node *left;
struct Node *right;
}binary;
} binary;
struct {
Operator op;
struct Node *to;
}unary;
} unary;
Operator par;
};
} Node;
@@ -76,7 +76,11 @@ typedef struct {
} ParserU8Result;
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 postfix_lbp(Token token);

27
src/evaluator.c
View File

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

41
src/lexer.c
View File

@@ -1,22 +1,19 @@
#include "lexer.h"
#include "arraylist.h"
#include "lae_allocator.h"
#include "lae_arraylist.h"
#include <ctype.h>
#include <limits.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;
typedef enum { WAIT_FOR_NUMBER, WAIT_FOR_OPERATOR } LexerState;
TokenizeResult tokenize(const char *input) {
ArrayList *arr;
arraylist_init(&arr, 64, sizeof(Token));
arraylist_init(&arr, allocator_default(), 64, sizeof(Token));
size_t offset = 0;
while (input[offset] != '\0') {
@@ -26,7 +23,7 @@ TokenizeResult tokenize(const char *input) {
if (!result.is_valid) {
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);
@@ -41,8 +38,7 @@ TokenizeResult tokenize(const char *input) {
// Nothing...
} else {
arraylist_destroy(&arr);
return (TokenizeResult) {
.is_valid = false,
return (TokenizeResult){.is_valid = false,
.err = LEXER_NOT_RECOGNIZED_SYMBOL};
}
@@ -51,16 +47,16 @@ TokenizeResult tokenize(const char *input) {
if (arraylist_size(arr) < 1) {
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
// point is implemented but i'll figure it out
TokenResult tokenize_number(const char *input, size_t *offset) {
char buf[64] = { '\0' };
char buf[64] = {'\0'};
size_t buf_pos = 0;
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;
while (isdigit(input[current])) {
if (buf_pos >= sizeof(buf) - 1) {
return (TokenResult) {
.is_valid = false,
.err = LEXER_BUF_OVERFLOW};
return (TokenResult){.is_valid = false, .err = LEXER_BUF_OVERFLOW};
}
buf[buf_pos] = input[current];
@@ -84,19 +78,17 @@ TokenResult tokenize_number(const char *input, size_t *offset) {
new_token.type = TOKEN_INTEGER;
LexerI64Result result = string_to_integer(buf);
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;
*offset = current - 1;
return (TokenResult) {.is_valid = true, .token = new_token};
return (TokenResult){.is_valid = true, .token = new_token};
}
return (TokenResult) {
.is_valid = false,
return (TokenResult){.is_valid = false,
.err = LEXER_FAILED_NUMBER_CONVERSION};
}
@@ -110,8 +102,7 @@ LexerI64Result string_to_integer(const char *buf) {
int digit = buf[c] - '0';
if (count > (INT64_MAX - digit) / 10) {
return (LexerI64Result) {
.is_valid = false,
return (LexerI64Result){.is_valid = false,
.err = LEXER_INT_OVERFLOW};
}
@@ -121,7 +112,7 @@ LexerI64Result string_to_integer(const char *buf) {
c++;
}
return (LexerI64Result) {.is_valid = true, .num = count};
return (LexerI64Result){.is_valid = true, .num = count};
}
bool isoperator(int c) {

135
src/parser.c
View File

@@ -1,7 +1,8 @@
#include "parser.h"
#include "arraylist.h"
#include "lae_allocator.h"
#include "lae_arena.h"
#include "lae_arraylist.h"
#include "lexer.h"
#include "arena.h"
#include <cmocka.h>
#include <stdalign.h>
#include <stdbool.h>
@@ -9,7 +10,7 @@
ParserU8Result prefix_rbp(Token token) {
if (token.type == TOKEN_INTEGER) {
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -17,12 +18,12 @@ ParserU8Result prefix_rbp(Token token) {
switch (token.op) {
case OP_SUB:
case OP_ADD:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 30,
};
default:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -31,7 +32,7 @@ ParserU8Result prefix_rbp(Token token) {
ParserU8Result postfix_lbp(Token token) {
if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -39,12 +40,12 @@ ParserU8Result postfix_lbp(Token token) {
switch (token.op) {
case OP_FACTORIAL:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 40,
};
default:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -53,7 +54,7 @@ ParserU8Result postfix_lbp(Token token) {
ParserU8Result infix_lbp(Token token) {
if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -62,23 +63,23 @@ ParserU8Result infix_lbp(Token token) {
switch (token.op) {
case OP_ADD:
case OP_SUB:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 10,
};
case OP_DIV:
case OP_MUL:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 20,
};
case OP_POW:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 51,
};
default:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -87,7 +88,7 @@ ParserU8Result infix_lbp(Token token) {
ParserU8Result infix_rbp(Token token) {
if (token.type != TOKEN_OPERATOR) {
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -96,48 +97,34 @@ ParserU8Result infix_rbp(Token token) {
switch (token.op) {
case OP_ADD:
case OP_SUB:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 11,
};
case OP_DIV:
case OP_MUL:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 21,
};
case OP_POW:
return (ParserU8Result) {
return (ParserU8Result){
.is_valid = true,
.num = 50,
};
default:
return (ParserU8Result) {
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)
);
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)
)
);
Node *node =
arena_unwrap_pointer(arena_alloc(arena, sizeof(Node), alignof(Node)));
switch (token.op) {
@@ -152,17 +139,13 @@ TreeResult led(
ParserU8Result rbp_result = infix_rbp(token);
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
);
TreeResult right = parse_expr(slice, arena, rbp_result.num);
if (!right.is_valid) {
return right;
@@ -171,7 +154,7 @@ TreeResult led(
node->binary.left = left;
node->binary.right = right.node;
return (TreeResult) {
return (TreeResult){
.is_valid = true,
.node = node,
};
@@ -183,14 +166,14 @@ TreeResult led(
node->unary.op = token.op;
node->unary.to = left;
return (TreeResult) {
return (TreeResult){
.is_valid = true,
.node = node,
};
}
default:
return (TreeResult) {
return (TreeResult){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
@@ -198,25 +181,16 @@ TreeResult led(
}
TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
arena_ensure_capacity(
arena,
sizeof(Node),
alignof(Node)
);
arena_ensure_capacity(arena, sizeof(Node), alignof(Node));
Node *node = arena_unwrap_pointer(
arena_alloc(
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) {
return (TreeResult){
.is_valid = true,
.node = node,
};
@@ -231,15 +205,14 @@ TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
Token end_par;
if (arrayslice_next(slice, &end_par) != ARRLIST_OK) {
return (TreeResult) {
return (TreeResult){
.is_valid = false,
.err = PARSER_UNMATCHED_PAREN,
};
}
if (end_par.type != TOKEN_OPERATOR ||
end_par.op != OP_END_PAR) {
return (TreeResult) {
if (end_par.type != TOKEN_OPERATOR || end_par.op != OP_END_PAR) {
return (TreeResult){
.is_valid = false,
.err = PARSER_UNMATCHED_PAREN,
};
@@ -255,17 +228,13 @@ TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
ParserU8Result rbp_result = prefix_rbp(token);
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
);
TreeResult right = parse_expr(slice, arena, rbp_result.num);
if (!right.is_valid) {
return right;
@@ -273,56 +242,60 @@ TreeResult nud(ArraySlice *slice, Arena *arena, Token token) {
node->unary.to = right.node;
return (TreeResult) {
return (TreeResult){
.is_valid = true,
.node = node,
};
}
default:
return (TreeResult) {
return (TreeResult){
.is_valid = false,
.err = PARSER_UNEXPECTED_TOKEN,
};
}
}
ParserResult parse(TokenizeResult tokens) {
if (!tokens.is_valid) {
return (ParserResult) {
return (ParserResult){
.is_valid = false,
.err = PARSER_INVALID_TOKENIZE,
};
}
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_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);
if (!result.is_valid) {
arena_destroy(&arena);
arraylist_destroy(&tokens.arr);
return (ParserResult) {
return (ParserResult){
.is_valid = false,
.err = result.err,
};
}
arraylist_destroy(&tokens.arr);
return (ParserResult) {
.is_valid = true,
.arena = arena,
.tree = result.node};
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) {
return (TreeResult){
.is_valid = false,
.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