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

Merge pull request 'refactor-xmake' (#2) from refactor-xmake into main

Browse Source 
Reviewed-on: #2
This commit was merged in pull request #2.
This commit is contained in:
Alonso Adrian Martinez Hernandez
2026-06-10 14:52:54 -06:00
parent 5734af33db 1a0afd331c
commit feccaca57f
7 changed files with 1791 additions and 1507 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
CMakeFiles/

98
CMakeLists.txt
View File

@@ -1,98 +0,0 @@
cmake_minimum_required(VERSION 3.20)
project(
arraylist
VERSION 1.0
LANGUAGES C)
# ------------------------------------------------
# Estandard C
# ------------------------------------------------
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)
# Exportar compile_commands.json (clangd / IDEs)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# ------------------------------------------------
# Is Top project?
# ------------------------------------------------
if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
set(ARRAYLIST_IS_TOP_LEVEL ON)
else()
set(ARRAYLIST_IS_TOP_LEVEL OFF)
endif()
# ------------------------------------------------
# Opciones
# ------------------------------------------------
option(ARRAYLIST_BUILD_TESTS "Build tests" ${ARRAYLIST_IS_TOP_LEVEL})
option(ARRAYLIST_BUILD_EXAMPLE "Build example" ${ARRAYLIST_IS_TOP_LEVEL})
option(ARRAYLIST_ENABLE_INSTALL "Enable install" ${ARRAYLIST_IS_TOP_LEVEL})
option(ARRAYLIST_ENABLE_SANITIZERS "Enable Sanitizers for test" ON)
# ------------------------------------------------
# Warning Flags (GCC/Clang vs MSVC)
# ------------------------------------------------
if(MSVC)
set(ARRAYLIST_WARNING_FLAGS /W4)
else()
set(ARRAYLIST_WARNING_FLAGS -Wall -Wextra -Wpedantic)
endif()
# ------------------------------------------------
# Main Library
# ------------------------------------------------
add_library(arraylist src/arraylist.c)
# Alias con namespace → los consumidores via CPM/FetchContent pueden escribir
# target_link_libraries(mi_app arraylist::arraylist)
add_library(arraylist::arraylist ALIAS arraylist)
target_include_directories(
arraylist PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>)
# Flagas only for compile lib
target_compile_options(arraylist PRIVATE ${ARRAYLIST_WARNING_FLAGS})
# Propagates c11 as requirement
target_compile_features(arraylist PUBLIC c_std_11)
# ------------------------------------------------
# Example only built when is main proyect
# ------------------------------------------------
if(ARRAYLIST_BUILD_EXAMPLE)
add_executable(arraylist_example src/main.c)
target_link_libraries(arraylist_example PRIVATE arraylist)
endif()
# ------------------------------------------------
# Tests
# ------------------------------------------------
if(ARRAYLIST_BUILD_TESTS)
enable_testing()
add_subdirectory(test)
endif()
# ------------------------------------------------
# Installation rules
# ------------------------------------------------
if(ARRAYLIST_ENABLE_INSTALL)
include(GNUInstallDirs)
install(
TARGETS arraylist
EXPORT arraylistTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
install(
EXPORT arraylistTargets
FILE arraylistTargets.cmake
NAMESPACE arraylist::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/arraylist)
endif()

40
include/arraylist.h → include/lae_arraylist.h
View File

@@ -1,9 +1,10 @@
#ifndef ARRAYLIST_H
#define ARRAYLIST_H
#ifndef LAE_ARRAYLIST_H
#define LAE_ARRAYLIST_H
#include "lae_allocator.h"
#include <inttypes.h>
#include <stddef.h>
#include <stdbool.h>
#include <stddef.h>
typedef struct ArrayList ArrayList;
@@ -25,7 +26,11 @@ typedef enum {
ARRLIST_BORROW_UNDERFLOW,
} ArrayListErr;
ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size);
ArrayListErr arraylist_init(
ArrayList **arr,
Allocator allocator,
size_t capacity,
size_t elem_size);
ArrayListErr arraylist_destroy(ArrayList **arr);
ArrayListErr arraylist_clear(ArrayList *arr);
ArrayList *arraylist_clone(const ArrayList *arr);
@@ -35,8 +40,8 @@ size_t arraylist_capacity(const ArrayList *arr);
bool arraylist_is_empty(const ArrayList *arr);
ArrayListErr arraylist_push_back(ArrayList *arr, void *data);
ArrayListErr arraylist_insert(ArrayList*arr, size_t index, void *data);
ArrayListErr arraylist_push_front(ArrayList* arr, void *data);
ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data);
ArrayListErr arraylist_push_front(ArrayList *arr, void *data);
// Here out can be null for not having anything writen
ArrayListErr arraylist_pop_back(ArrayList *arr, void *out);
@@ -49,9 +54,21 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data);
ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity);
ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve);
//Slice stuff
ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
// Slice stuff
ArrayListErr arraylist_slice(
ArraySlice **slice,
Allocator allocator,
ArrayList *arr,
size_t start,
size_t len);
ArrayListErr arraylist_slice_unsafe(
ArraySlice **slice,
Allocator allocator,
ArrayList *arr,
size_t start,
size_t len);
ArrayListErr arrayslice_destroy(ArraySlice **slice);
bool arrayslice_is_valid(const ArraySlice *slice);
@@ -65,6 +82,9 @@ ArrayListErr arrayslice_next(ArraySlice *slice, void *out);
ArrayListErr arrayslice_reset(ArraySlice *slice);
ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n);
ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice);
ArrayListErr arrayslice_to_arraylist(
ArrayList **arr,
Allocator allocator,
const ArraySlice *slice);
#endif

125
src/arraylist.c → src/lae_arraylist.c
View File

@@ -1,15 +1,19 @@
#include "arraylist.h"
#include "lae_arraylist.h"
#include "lae_allocator.h"
#include <stdalign.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
struct ArrayList{
struct ArrayList {
uint8_t *buffer;
size_t capacity;
size_t len;
size_t elem_size;
size_t borrows;
Allocator allocator;
};
struct ArraySlice {
@@ -18,6 +22,8 @@ struct ArraySlice {
size_t end;
size_t current;
bool is_safe;
Allocator allocator;
};
// Grow and shrink factor is 2, 1.5 might give different results i guess
@@ -26,11 +32,15 @@ struct ArraySlice {
static ArrayListErr arraylist_grow(ArrayList *arr);
static ArrayListErr arraylist_shrink(ArrayList *arr);
ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
ArrayListErr arraylist_init(
ArrayList **arr,
Allocator allocator,
size_t capacity,
size_t elem_size) {
if (arr == NULL) {
return ARRLIST_NULL_ARG;
}
*arr = NULL;
if (capacity == 0) {
@@ -45,7 +55,8 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
return ARRLIST_INVALID_CAPACITY;
}
ArrayList *new_arr = malloc(sizeof(ArrayList));
ArrayList *new_arr =
allocator.alloc(allocator.ctx, sizeof(ArrayList), alignof(ArrayList));
if (new_arr == NULL) {
return ARRLIST_BAD_ALLOC;
}
@@ -54,9 +65,14 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
new_arr->elem_size = elem_size;
new_arr->len = 0;
new_arr->borrows = 0;
new_arr->buffer = malloc(capacity * elem_size);
new_arr->buffer = allocator.alloc(allocator.ctx, capacity * elem_size, 0);
new_arr->allocator = allocator;
if (new_arr->buffer == NULL) {
free(new_arr);
allocator.free(
allocator.ctx,
new_arr,
sizeof(ArrayList),
alignof(ArrayList));
return ARRLIST_BAD_ALLOC;
}
@@ -73,9 +89,12 @@ ArrayListErr arraylist_destroy(ArrayList **arr) {
return ARRLIST_IS_BORROWED;
}
ArrayList *tmp = *arr;
// No problem on using free on NULL :)
free((*arr)->buffer);
free(*arr);
tmp->allocator.free(tmp->allocator.ctx, tmp->buffer, tmp->capacity, 0);
tmp->allocator
.free(tmp->allocator.ctx, tmp, sizeof(ArrayList), alignof(ArrayList));
*arr = NULL;
return ARRLIST_OK;
@@ -122,7 +141,7 @@ static ArrayListErr arraylist_grow(ArrayList *arr) {
size_t new_capacity = arr->capacity * 2;
if (new_capacity > SIZE_MAX / arr->elem_size) {
return ARRLIST_ALLOC_OVERFLOW;
return ARRLIST_ALLOC_OVERFLOW;
}
void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
@@ -139,10 +158,10 @@ static ArrayListErr arraylist_shrink(ArrayList *arr) {
size_t new_capacity = arr->capacity / 2;
if (new_capacity > SIZE_MAX / arr->elem_size) {
return ARRLIST_ALLOC_OVERFLOW;
return ARRLIST_ALLOC_OVERFLOW;
}
void *tmp = realloc(arr->buffer, new_capacity *arr->elem_size);
void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
if (tmp == NULL) {
return ARRLIST_BAD_ALLOC;
}
@@ -195,13 +214,9 @@ ArrayListErr arraylist_push_front(ArrayList *arr, void *data) {
memmove(
arr->buffer + arr->elem_size,
arr->buffer,
(arr->len) * arr->elem_size
);
(arr->len) * arr->elem_size);
memcpy(
arr->buffer,
data,
arr->elem_size);
memcpy(arr->buffer, data, arr->elem_size);
arr->len++;
@@ -233,9 +248,7 @@ ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data) {
arr->buffer + (index * arr->elem_size),
(arr->len - index) * arr->elem_size);
memcpy(arr->buffer + (index * arr->elem_size),
data,
arr->elem_size);
memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
arr->len++;
@@ -295,11 +308,7 @@ ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) {
}
if (out != NULL) {
memcpy(
out,
arr->buffer,
arr->elem_size
);
memcpy(out, arr->buffer, arr->elem_size);
}
memmove(
@@ -330,11 +339,7 @@ ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
}
if (out != NULL) {
memcpy(
out,
arr->buffer + (index * arr->elem_size),
arr->elem_size
);
memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
}
memmove(
@@ -356,10 +361,7 @@ ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out) {
return ARRLIST_OUT_OF_BOUNDS;
}
memcpy(
out,
arr->buffer + (index * arr->elem_size),
arr->elem_size);
memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
return ARRLIST_OK;
}
@@ -373,10 +375,7 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data) {
return ARRLIST_OUT_OF_BOUNDS;
}
memcpy(
arr->buffer + (index * arr->elem_size),
data,
arr->elem_size);
memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
return ARRLIST_OK;
}
@@ -395,7 +394,7 @@ ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity) {
}
if (new_capacity > SIZE_MAX / arr->elem_size) {
return ARRLIST_ALLOC_OVERFLOW;
return ARRLIST_ALLOC_OVERFLOW;
}
uint8_t *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
@@ -420,7 +419,7 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size ||
size_to_reserve > SIZE_MAX / arr->elem_size) {
return ARRLIST_ALLOC_OVERFLOW;
return ARRLIST_ALLOC_OVERFLOW;
}
uint8_t *tmp = realloc(
@@ -436,7 +435,12 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
return ARRLIST_OK;
}
ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
ArrayListErr arraylist_slice(
ArraySlice **slice,
Allocator allocator,
ArrayList *arr,
size_t start,
size_t len) {
if (arr == NULL || slice == NULL) {
return ARRLIST_NULL_ARG;
}
@@ -453,7 +457,8 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s
return ARRLIST_INVALID_START;
}
ArraySlice *new_slice = malloc(sizeof(ArraySlice));
ArraySlice *new_slice =
allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
if (new_slice == NULL) {
return ARRLIST_BAD_ALLOC;
}
@@ -463,13 +468,19 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s
new_slice->end = start + len;
new_slice->current = start;
new_slice->is_safe = true;
new_slice->allocator = allocator;
arr->borrows++;
*slice = new_slice;
return ARRLIST_OK;
}
ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
ArrayListErr arraylist_slice_unsafe(
ArraySlice **slice,
Allocator allocator,
ArrayList *arr,
size_t start,
size_t len) {
if (arr == NULL || slice == NULL) {
return ARRLIST_NULL_ARG;
}
@@ -486,7 +497,8 @@ ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t s
return ARRLIST_INVALID_START;
}
ArraySlice *new_slice = malloc(sizeof(ArraySlice));
ArraySlice *new_slice =
allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
if (new_slice == NULL) {
return ARRLIST_BAD_ALLOC;
}
@@ -496,6 +508,7 @@ ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t s
new_slice->end = start + len;
new_slice->current = start;
new_slice->is_safe = false;
new_slice->allocator = allocator;
*slice = new_slice;
return ARRLIST_OK;
@@ -510,7 +523,11 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice) {
(*slice)->arr->borrows--;
}
free(*slice);
(*slice)->allocator.free(
(*slice)->allocator.ctx,
*slice,
sizeof(ArraySlice),
alignof(ArraySlice));
*slice = NULL;
return ARRLIST_OK;
@@ -581,13 +598,16 @@ ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) {
if (n > SIZE_MAX - slice->current || slice->current + n > slice->end) {
return ARRLIST_OUT_OF_BOUNDS;
}
slice->current += n;
return ARRLIST_OK;
}
ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
ArrayListErr arrayslice_to_arraylist(
ArrayList **arr,
Allocator allocator,
const ArraySlice *slice) {
if (slice == NULL || slice->arr == NULL) {
return ARRLIST_NULL_ARG;
}
@@ -605,9 +625,9 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
ArrayList *new_arr;
ArrayListErr init_err = arraylist_init(
&new_arr,
allocator,
arraylist_capacity(slice->arr),
slice->arr->elem_size
);
slice->arr->elem_size);
if (init_err != ARRLIST_OK) {
return init_err;
@@ -616,8 +636,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
memcpy(
new_arr->buffer,
slice->arr->buffer + (slice->start * slice->arr->elem_size),
slice->arr->elem_size * len
);
slice->arr->elem_size * len);
new_arr->len = len;

121
test/CMakeLists.txt
View File

@@ -1,121 +0,0 @@
# ---------------------------------------------------------------
# First search cmocka and automatically download if necessary
# ---------------------------------------------------------------
find_package(cmocka QUIET)
if(NOT cmocka_FOUND)
message(
STATUS
"[arraylist] cmocka was not fount in the system — downloading 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)
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)
# cmocka can export its target as "cmocka" or "cmocka-static" create alias if
# it doesnt exist
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
"[arraylist] cmocka::cmocka target could not be tested — skipping tests"
)
return()
endif()
endif()
endif()
# ---------------------------------------------------------------
# Verifiy ASAN support
# ---------------------------------------------------------------
set(ARRAYLIST_USE_ASAN OFF)
if(ARRAYLIST_ENABLE_SANITIZERS)
if(MSVC)
if(MSVC_VERSION GREATER_EQUAL 1928)
set(ARRAYLIST_USE_ASAN ON)
else()
message(
STATUS
"[arraylist] MSVC < 16.9 doesnt support ASAN — sanitizers deactivated."
)
endif()
elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND NOT WIN32)
include(CheckCCompilerFlag)
check_c_compiler_flag(-fsanitize=address ARRAYLIST_COMPILER_HAS_ASAN)
if(ARRAYLIST_COMPILER_HAS_ASAN)
set(ARRAYLIST_USE_ASAN ON)
else()
message(
STATUS
"[arraylist] Compiler doesnt support -fsanitize=address — sanitizers deactivated."
)
endif()
else()
message(
STATUS
"[arraylist] Platform/compiler doesnt support ASAN — sanitizers deactivated."
)
endif()
if(ARRAYLIST_USE_ASAN)
message(STATUS "[arraylist] ASAN Enabled for tests")
endif()
endif()
# ---------------------------------------------------------------
# Test execuatable
# ---------------------------------------------------------------
add_executable(test_arraylist test_arraylist.c)
target_link_libraries(test_arraylist PRIVATE arraylist cmocka::cmocka)
# Same as lib
target_compile_features(test_arraylist PRIVATE c_std_11)
# Apply asan
if(ARRAYLIST_USE_ASAN)
if(MSVC)
target_compile_options(test_arraylist PRIVATE /fsanitize=address)
else()
target_compile_options(test_arraylist PRIVATE -fsanitize=address
-fno-omit-frame-pointer)
target_link_options(test_arraylist PRIVATE -fsanitize=address)
endif()
endif()
# ---------------------------------------------------------------
# Register with CTests
# ---------------------------------------------------------------
add_test(NAME arraylist_tests COMMAND test_arraylist)
set_tests_properties(arraylist_tests PROPERTIES TIMEOUT 30)

2814
test/test_arraylist.c
View File

File diff suppressed because it is too large Load Diff

94
xmake.lua Normal file
View File

@@ -0,0 +1,94 @@
set_project("lae_arraylist")
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("example")
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("cmocka", { optional = true }) -- For tests
add_requires("lae_allocator")
-- =========================================================
-- Library
-- =========================================================
target("lae_arraylist")
set_kind("static")
add_packages("lae_allocator", { public = true })
add_files("src/lae_arraylist.c")
add_headerfiles("include/*.h")
add_includedirs("include", { public = true })
if is_mode("debug") then
add_cflags("-Wall", "-Wextra", "-Wpedantic")
end
-- =========================================================
-- Example executable
-- =========================================================
if has_config("example") then
target("example")
set_kind("binary")
add_deps("lae_arraylist")
add_packages("lae_allocator")
add_files("src/main.c")
end
-- =========================================================
-- Tests
-- =========================================================
if has_config("tests") then
target("test_arraylist")
set_kind("binary")
add_files("test/test_arraylist.c")
add_deps("lae_arraylist")
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