francesco/myclib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: string extend method

Browse Source
This commit is contained in:
Francesco
2025-09-07 22:36:30 +02:00
parent 3e0584d139
commit 16ee246956
17 changed files with 2164 additions and 2123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
.clang-format
View File

@@ -1,5 +1,5 @@
BasedOnStyle: Google BasedOnStyle: Google
ColumnLimit: 160 ColumnLimit: 160
UseTab: Always UseTab: Always
IndentWidth: 4 IndentWidth: 4
TabWidth: 4 TabWidth: 4

114
.gitignore vendored
View File

@@ -1,57 +1,57 @@
.cache/ .cache/
# Prerequisites # Prerequisites
*.d *.d
# Object files # Object files
*.o *.o
*.ko *.ko
*.obj *.obj
*.elf *.elf
# Linker output # Linker output
*.ilk *.ilk
*.map *.map
*.exp *.exp
# Precompiled Headers # Precompiled Headers
*.gch *.gch
*.pch *.pch
# Libraries # Libraries
*.lib *.lib
*.a *.a
*.la *.la
*.lo *.lo
# Shared objects (inc. Windows DLLs) # Shared objects (inc. Windows DLLs)
*.dll *.dll
*.so *.so
*.so.* *.so.*
*.dylib *.dylib
# Executables # Executables
*.exe *.exe
*.out *.out
*.app *.app
*.i*86 *.i*86
*.x86_64 *.x86_64
*.hex *.hex
# Debug files # Debug files
*.dSYM/ *.dSYM/
*.su *.su
*.idb *.idb
*.pdb *.pdb
# Kernel Module Compile Results # Kernel Module Compile Results
*.mod* *.mod*
*.cmd *.cmd
.tmp_versions/ .tmp_versions/
modules.order modules.order
Module.symvers Module.symvers
Mkfile.old Mkfile.old
dkms.conf dkms.conf
# debug information files # debug information files
*.dwo *.dwo

1348
LICENSE
View File

File diff suppressed because it is too large Load Diff

26
README.md
View File

@@ -1,13 +1,13 @@
# myclib # myclib
**myclib** is a personal C library. This project is a work in progress and intended for educational use. **myclib** is a personal C library. This project is a work in progress and intended for educational use.
It is not production-ready. Use at your own risk. It is not production-ready. Use at your own risk.
## Features ## Features
- Hashmaps - Thread-safe (MT Safe) - Hashmaps - Thread-safe (MT Safe)
- Dynamic strings - Thread-safe (MT Safe) - Dynamic strings - Thread-safe (MT Safe)
- Circular Queue - Thread-safe (MT Safe) - Circular Queue - Thread-safe (MT Safe)
## Examples ## Examples
You can find examples inside `test/` folder. You can find examples inside `test/` folder.

662
hashmap/myhashmap.c
View File

@@ -1,331 +1,331 @@
#include "myhashmap.h" #include "myhashmap.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static size_t mcl_get_mutex(mcl_hashmap_s *hashmap, size_t hash) { return hash % hashmap->num_locks; } static size_t mcl_get_mutex(mcl_hashmap_s *hashmap, size_t hash) { return hash % hashmap->num_locks; }
static size_t mcl_get_bucket_index(mcl_hashmap_s *hashmap, void *key) { static size_t mcl_get_bucket_index(mcl_hashmap_s *hashmap, void *key) {
unsigned int hash = hashmap->hash_fn(key); unsigned int hash = hashmap->hash_fn(key);
return hash % MYCLIB_HASHMAP_SIZE; return hash % MYCLIB_HASHMAP_SIZE;
} }
static void mcl_free_bucket_content(mcl_hashmap_s *hashmap, mcl_bucket_s *bucket) { static void mcl_free_bucket_content(mcl_hashmap_s *hashmap, mcl_bucket_s *bucket) {
if (bucket == NULL) { if (bucket == NULL) {
return; return;
} }
/* Free key if free function is provided */ /* Free key if free function is provided */
if (hashmap->free_key_fn != NULL && bucket->key != NULL) { if (hashmap->free_key_fn != NULL && bucket->key != NULL) {
hashmap->free_key_fn(bucket->key); hashmap->free_key_fn(bucket->key);
} }
/* Free value if free function is provided */ /* Free value if free function is provided */
if (hashmap->free_value_fn != NULL && bucket->value != NULL) { if (hashmap->free_value_fn != NULL && bucket->value != NULL) {
hashmap->free_value_fn(bucket->value); hashmap->free_value_fn(bucket->value);
} }
} }
static mcl_bucket_s *mcl_find_bucket(mcl_hashmap_s *hashmap, void *key, mcl_bucket_s **prev) { static mcl_bucket_s *mcl_find_bucket(mcl_hashmap_s *hashmap, void *key, mcl_bucket_s **prev) {
size_t index = mcl_get_bucket_index(hashmap, key); size_t index = mcl_get_bucket_index(hashmap, key);
mcl_bucket_s *bucket = &hashmap->map[index]; mcl_bucket_s *bucket = &hashmap->map[index];
*prev = NULL; *prev = NULL;
/* Return NULL if first bucket is empty */ /* Return NULL if first bucket is empty */
if (bucket->key == NULL) { if (bucket->key == NULL) {
return NULL; return NULL;
} }
/* Search through the collision chain */ /* Search through the collision chain */
while (bucket != NULL) { while (bucket != NULL) {
if (hashmap->equal_fn(bucket->key, key)) { if (hashmap->equal_fn(bucket->key, key)) {
return bucket; return bucket;
} }
*prev = bucket; *prev = bucket;
bucket = bucket->next; bucket = bucket->next;
} }
return NULL; return NULL;
} }
mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size) { mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size) {
mcl_hashmap_s *hashmap = malloc(sizeof(mcl_hashmap_s)); mcl_hashmap_s *hashmap = malloc(sizeof(mcl_hashmap_s));
if (hashmap == NULL) { if (hashmap == NULL) {
return NULL; return NULL;
} }
hashmap->hash_fn = hash_fn; hashmap->hash_fn = hash_fn;
hashmap->equal_fn = equal_fn; hashmap->equal_fn = equal_fn;
hashmap->free_key_fn = free_key_fn; hashmap->free_key_fn = free_key_fn;
hashmap->free_value_fn = free_value_fn; hashmap->free_value_fn = free_value_fn;
hashmap->key_size = key_size; hashmap->key_size = key_size;
hashmap->value_size = value_size; hashmap->value_size = value_size;
hashmap->num_locks = 64; hashmap->num_locks = 64;
hashmap->locks = malloc(sizeof(mtx_t) * hashmap->num_locks); hashmap->locks = malloc(sizeof(mtx_t) * hashmap->num_locks);
if (hashmap->locks == NULL) { if (hashmap->locks == NULL) {
free(hashmap); free(hashmap);
return NULL; return NULL;
} }
int ret; int ret;
for (size_t i = 0; i < hashmap->num_locks; ++i) { for (size_t i = 0; i < hashmap->num_locks; ++i) {
ret = mtx_init(&(hashmap->locks[i]), mtx_plain); ret = mtx_init(&(hashmap->locks[i]), mtx_plain);
if (ret != thrd_success) { if (ret != thrd_success) {
/* Mutex failed */ /* Mutex failed */
for (size_t j = 0; j < i; ++j) { for (size_t j = 0; j < i; ++j) {
mtx_destroy(&(hashmap->locks[j])); mtx_destroy(&(hashmap->locks[j]));
} }
free(hashmap->locks); free(hashmap->locks);
free(hashmap); free(hashmap);
} }
} }
memset(hashmap->map, 0, sizeof(hashmap->map)); memset(hashmap->map, 0, sizeof(hashmap->map));
return hashmap; return hashmap;
} }
void mcl_hm_free(mcl_hashmap_s *hashmap) { void mcl_hm_free(mcl_hashmap_s *hashmap) {
if (hashmap == NULL) { if (hashmap == NULL) {
return; return;
} }
/* Iterate through all buckets in the hash map */ /* Iterate through all buckets in the hash map */
for (size_t i = 0; i < MYCLIB_HASHMAP_SIZE; ++i) { for (size_t i = 0; i < MYCLIB_HASHMAP_SIZE; ++i) {
mcl_bucket_s *bucket = &hashmap->map[i]; mcl_bucket_s *bucket = &hashmap->map[i];
/* Free the first bucket if it contains data */ /* Free the first bucket if it contains data */
if (bucket->key != NULL) { if (bucket->key != NULL) {
mcl_free_bucket_content(hashmap, bucket); mcl_free_bucket_content(hashmap, bucket);
} }
/* Free all chained buckets */ /* Free all chained buckets */
bucket = bucket->next; bucket = bucket->next;
while (bucket != NULL) { while (bucket != NULL) {
mcl_bucket_s *next = bucket->next; mcl_bucket_s *next = bucket->next;
mcl_free_bucket_content(hashmap, bucket); mcl_free_bucket_content(hashmap, bucket);
free(bucket); free(bucket);
bucket = next; bucket = next;
} }
} }
/* Free the mutex */ /* Free the mutex */
for (size_t i = 0; i < hashmap->num_locks; ++i) { for (size_t i = 0; i < hashmap->num_locks; ++i) {
mtx_destroy(&(hashmap->locks[i])); mtx_destroy(&(hashmap->locks[i]));
} }
free(hashmap->locks); free(hashmap->locks);
/* Free the hash map structure itself */ /* Free the hash map structure itself */
free(hashmap); free(hashmap);
} }
void mcl_hm_free_bucket(mcl_bucket_s *bucket) { void mcl_hm_free_bucket(mcl_bucket_s *bucket) {
if (bucket == NULL) { if (bucket == NULL) {
return; return;
} }
free(bucket->key); free(bucket->key);
free(bucket->value); free(bucket->value);
free(bucket); free(bucket);
} }
bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) { bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value) {
if (hashmap == NULL || key == NULL || value == NULL) { if (hashmap == NULL || key == NULL || value == NULL) {
return false; return false;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; mcl_bucket_s *prev;
mcl_bucket_s *existing = mcl_find_bucket(hashmap, key, &prev); mcl_bucket_s *existing = mcl_find_bucket(hashmap, key, &prev);
if (existing != NULL) { if (existing != NULL) {
/* Key exists, update value */ /* Key exists, update value */
if (hashmap->free_value_fn != NULL && existing->value != NULL) { if (hashmap->free_value_fn != NULL && existing->value != NULL) {
hashmap->free_value_fn(existing->value); hashmap->free_value_fn(existing->value);
} }
existing->value = malloc(hashmap->value_size); existing->value = malloc(hashmap->value_size);
if (existing->value == NULL) { if (existing->value == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
memcpy(existing->value, value, hashmap->value_size); memcpy(existing->value, value, hashmap->value_size);
mtx_unlock(mutex); mtx_unlock(mutex);
return true; return true;
} }
/* Key doesn't exist, need to insert new bucket */ /* Key doesn't exist, need to insert new bucket */
size_t index = mcl_get_bucket_index(hashmap, key); size_t index = mcl_get_bucket_index(hashmap, key);
mcl_bucket_s *bucket = &hashmap->map[index]; mcl_bucket_s *bucket = &hashmap->map[index];
if (bucket->key == NULL) { if (bucket->key == NULL) {
/* First bucket is empty, use it */ /* First bucket is empty, use it */
bucket->key = malloc(hashmap->key_size); bucket->key = malloc(hashmap->key_size);
if (bucket->key == NULL) { if (bucket->key == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
bucket->value = malloc(hashmap->value_size); bucket->value = malloc(hashmap->value_size);
if (bucket->value == NULL) { if (bucket->value == NULL) {
free(bucket->key); free(bucket->key);
bucket->key = NULL; bucket->key = NULL;
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
memcpy(bucket->key, key, hashmap->key_size); memcpy(bucket->key, key, hashmap->key_size);
memcpy(bucket->value, value, hashmap->value_size); memcpy(bucket->value, value, hashmap->value_size);
bucket->next = NULL; bucket->next = NULL;
mtx_unlock(mutex); mtx_unlock(mutex);
return true; return true;
} }
/* Create new bucket and insert at head of collision chain */ /* Create new bucket and insert at head of collision chain */
mcl_bucket_s *new_bucket = malloc(sizeof(mcl_bucket_s)); mcl_bucket_s *new_bucket = malloc(sizeof(mcl_bucket_s));
if (new_bucket == NULL) { if (new_bucket == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
new_bucket->key = malloc(hashmap->key_size); new_bucket->key = malloc(hashmap->key_size);
if (new_bucket->key == NULL) { if (new_bucket->key == NULL) {
free(new_bucket); free(new_bucket);
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
new_bucket->value = malloc(hashmap->value_size); new_bucket->value = malloc(hashmap->value_size);
if (new_bucket->value == NULL) { if (new_bucket->value == NULL) {
free(new_bucket->key); free(new_bucket->key);
free(new_bucket); free(new_bucket);
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
memcpy(new_bucket->key, key, hashmap->key_size); memcpy(new_bucket->key, key, hashmap->key_size);
memcpy(new_bucket->value, value, hashmap->value_size); memcpy(new_bucket->value, value, hashmap->value_size);
new_bucket->next = bucket->next; new_bucket->next = bucket->next;
bucket->next = new_bucket; bucket->next = new_bucket;
mtx_unlock(mutex); mtx_unlock(mutex);
return true; return true;
} }
static mcl_bucket_s *mcl_get_bucket_copy(mcl_bucket_s *from, size_t key_size, size_t value_size) { static mcl_bucket_s *mcl_get_bucket_copy(mcl_bucket_s *from, size_t key_size, size_t value_size) {
mcl_bucket_s *copy = malloc(sizeof(mcl_bucket_s)); mcl_bucket_s *copy = malloc(sizeof(mcl_bucket_s));
if (copy == NULL) { if (copy == NULL) {
return NULL; return NULL;
} }
memcpy(copy, from, sizeof(mcl_bucket_s)); memcpy(copy, from, sizeof(mcl_bucket_s));
copy->key = malloc(key_size); copy->key = malloc(key_size);
if (copy->key == NULL) { if (copy->key == NULL) {
free(copy); free(copy);
return NULL; return NULL;
} }
memcpy(copy->key, from->key, key_size); memcpy(copy->key, from->key, key_size);
copy->value = malloc(value_size); copy->value = malloc(value_size);
if (copy->value == NULL) { if (copy->value == NULL) {
free(copy->key); free(copy->key);
free(copy); free(copy);
return NULL; return NULL;
} }
memcpy(copy->value, from->value, value_size); memcpy(copy->value, from->value, value_size);
return copy; return copy;
} }
mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key) { mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key) {
if (hashmap == NULL || key == NULL) { if (hashmap == NULL || key == NULL) {
return NULL; return NULL;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; mcl_bucket_s *prev;
mcl_bucket_s *found = mcl_find_bucket(hashmap, key, &prev); mcl_bucket_s *found = mcl_find_bucket(hashmap, key, &prev);
if (found) { if (found) {
mcl_bucket_s *copy = mcl_get_bucket_copy(found, hashmap->key_size, hashmap->value_size); mcl_bucket_s *copy = mcl_get_bucket_copy(found, hashmap->key_size, hashmap->value_size);
mtx_unlock(mutex); mtx_unlock(mutex);
return copy; return copy;
} }
mtx_unlock(mutex); mtx_unlock(mutex);
return NULL; return NULL;
} }
bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key) { bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key) {
if (hashmap == NULL || key == NULL) { if (hashmap == NULL || key == NULL) {
return false; return false;
} }
size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key)); size_t mutex_id = mcl_get_mutex(hashmap, hashmap->hash_fn(key));
mtx_t *mutex = &(hashmap->locks[mutex_id]); mtx_t *mutex = &(hashmap->locks[mutex_id]);
mtx_lock(mutex); mtx_lock(mutex);
mcl_bucket_s *prev; mcl_bucket_s *prev;
mcl_bucket_s *to_remove = mcl_find_bucket(hashmap, key, &prev); mcl_bucket_s *to_remove = mcl_find_bucket(hashmap, key, &prev);
if (to_remove == NULL) { if (to_remove == NULL) {
mtx_unlock(mutex); mtx_unlock(mutex);
return false; return false;
} }
/* Free the content of the bucket */ /* Free the content of the bucket */
mcl_free_bucket_content(hashmap, to_remove); mcl_free_bucket_content(hashmap, to_remove);
/* Handle removal based on position in chain */ /* Handle removal based on position in chain */
if (prev == NULL) { if (prev == NULL) {
/* Removing first bucket in chain */ /* Removing first bucket in chain */
if (to_remove->next != NULL) { if (to_remove->next != NULL) {
/* Move next bucket's content to first bucket and free the next bucket */ /* Move next bucket's content to first bucket and free the next bucket */
mcl_bucket_s *next_bucket = to_remove->next; mcl_bucket_s *next_bucket = to_remove->next;
to_remove->key = next_bucket->key; to_remove->key = next_bucket->key;
to_remove->value = next_bucket->value; to_remove->value = next_bucket->value;
to_remove->next = next_bucket->next; to_remove->next = next_bucket->next;
free(next_bucket); free(next_bucket);
} else { } else {
/* No next bucket, mark first bucket as empty */ /* No next bucket, mark first bucket as empty */
to_remove->key = NULL; to_remove->key = NULL;
to_remove->value = NULL; to_remove->value = NULL;
to_remove->next = NULL; to_remove->next = NULL;
} }
} else { } else {
/* Removing bucket from middle/end of chain */ /* Removing bucket from middle/end of chain */
prev->next = to_remove->next; prev->next = to_remove->next;
free(to_remove); free(to_remove);
} }
mtx_unlock(mutex); mtx_unlock(mutex);
return true; return true;
} }

286
hashmap/myhashmap.h
View File

@@ -1,143 +1,143 @@
#ifndef MYCLIB_HASHMAP_H #ifndef MYCLIB_HASHMAP_H
#define MYCLIB_HASHMAP_H #define MYCLIB_HASHMAP_H
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <threads.h> #include <threads.h>
#define MYCLIB_HASHMAP_SIZE 1024 /**< Number of buckets in the hash map */ #define MYCLIB_HASHMAP_SIZE 1024 /**< Number of buckets in the hash map */
/** /**
* @brief A single bucket in the hash map * @brief A single bucket in the hash map
* *
* Each bucket can hold one key-value pair and points to the next bucket * Each bucket can hold one key-value pair and points to the next bucket
* in case of hash collisions (separate chaining). * in case of hash collisions (separate chaining).
*/ */
typedef struct mcl_bucket { typedef struct mcl_bucket {
void *key; /**< Pointer to the key */ void *key; /**< Pointer to the key */
void *value; /**< Pointer to the value */ void *value; /**< Pointer to the value */
struct mcl_bucket *next; /**< Pointer to the next bucket in case of collision */ struct mcl_bucket *next; /**< Pointer to the next bucket in case of collision */
} mcl_bucket_s; } mcl_bucket_s;
/** /**
* @brief Function pointer type for a hash function * @brief Function pointer type for a hash function
* *
* @param[in] key Pointer to the key to hash * @param[in] key Pointer to the key to hash
* @return The computed hash as an unsigned integer * @return The computed hash as an unsigned integer
*/ */
typedef unsigned int hash_f(const void *key); typedef unsigned int hash_f(const void *key);
/** /**
* @brief Function pointer type for a key comparison function * @brief Function pointer type for a key comparison function
* *
* @param[in] key_a Pointer to the first key * @param[in] key_a Pointer to the first key
* @param[in] key_b Pointer to the second key * @param[in] key_b Pointer to the second key
* @return true if the keys are considered equal, false otherwise * @return true if the keys are considered equal, false otherwise
*/ */
typedef bool equal_f(const void *key_a, const void *key_b); typedef bool equal_f(const void *key_a, const void *key_b);
/** /**
* @brief Function pointer type for freeing a key * @brief Function pointer type for freeing a key
* *
* @param[in] key Pointer to the key to free * @param[in] key Pointer to the key to free
*/ */
typedef void free_key_f(void *key); typedef void free_key_f(void *key);
/** /**
* @brief Function pointer type for freeing a value * @brief Function pointer type for freeing a value
* *
* @param[in] value Pointer to the value to free * @param[in] value Pointer to the value to free
*/ */
typedef void free_value_f(void *value); typedef void free_value_f(void *value);
/** /**
* @brief Main structure representing the hash map * @brief Main structure representing the hash map
* *
* Contains function pointers for hash computation, key comparison, * Contains function pointers for hash computation, key comparison,
* and memory management, along with the bucket array. * and memory management, along with the bucket array.
*/ */
typedef struct mcl_hashmap { typedef struct mcl_hashmap {
hash_f *hash_fn; /**< Hash function */ hash_f *hash_fn; /**< Hash function */
equal_f *equal_fn; /**< Equality comparison function */ equal_f *equal_fn; /**< Equality comparison function */
free_key_f *free_key_fn; /**< Key deallocation function (optional) */ free_key_f *free_key_fn; /**< Key deallocation function (optional) */
free_value_f *free_value_fn; /**< Value deallocation function (optional) */ free_value_f *free_value_fn; /**< Value deallocation function (optional) */
size_t key_size; /**< Size in bytes of the key */ size_t key_size; /**< Size in bytes of the key */
size_t value_size; /**< Size in bytes of the value */ size_t value_size; /**< Size in bytes of the value */
mcl_bucket_s map[MYCLIB_HASHMAP_SIZE]; /**< Array of bucket chains */ mcl_bucket_s map[MYCLIB_HASHMAP_SIZE]; /**< Array of bucket chains */
mtx_t *locks; /**< Mutex array */ mtx_t *locks; /**< Mutex array */
size_t num_locks; /**< Number of mutex */ size_t num_locks; /**< Number of mutex */
} mcl_hashmap_s; } mcl_hashmap_s;
/** /**
* @brief Initialize a new hash map with user-defined behavior functions * @brief Initialize a new hash map with user-defined behavior functions
* *
* Creates a new hash map and initializes it with the provided function pointers. * Creates a new hash map and initializes it with the provided function pointers.
* The free functions can be NULL if no automatic memory management is needed. * The free functions can be NULL if no automatic memory management is needed.
* Keys and values will be copied into the hashmap using memcpy with the specified sizes. * Keys and values will be copied into the hashmap using memcpy with the specified sizes.
* *
* @param[in] hash_fn Function used to hash keys (required) * @param[in] hash_fn Function used to hash keys (required)
* @param[in] equal_fn Function used to compare keys (required) * @param[in] equal_fn Function used to compare keys (required)
* @param[in] free_key_fn Function used to free keys (optional, can be NULL) * @param[in] free_key_fn Function used to free keys (optional, can be NULL)
* @param[in] free_value_fn Function used to free values (optional, can be NULL) * @param[in] free_value_fn Function used to free values (optional, can be NULL)
* @param[in] key_size Size in bytes of each key to be stored * @param[in] key_size Size in bytes of each key to be stored
* @param[in] value_size Size in bytes of each value to be stored * @param[in] value_size Size in bytes of each value to be stored
* @return A pointer to the newly initialized hash map, or NULL on failure * @return A pointer to the newly initialized hash map, or NULL on failure
*/ */
mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size); mcl_hashmap_s *mcl_hm_new(hash_f *hash_fn, equal_f *equal_fn, free_key_f *free_key_fn, free_value_f *free_value_fn, size_t key_size, size_t value_size);
/** /**
* @brief Free all resources used by the hash map * @brief Free all resources used by the hash map
* *
* Iterates through all buckets, frees keys and values using the provided * Iterates through all buckets, frees keys and values using the provided
* free functions (if not NULL), and deallocates the hash map structure. * free functions (if not NULL), and deallocates the hash map structure.
* *
* @param[in] hashmap Pointer to the hash map to free * @param[in] hashmap Pointer to the hash map to free
*/ */
void mcl_hm_free(mcl_hashmap_s *hashmap); void mcl_hm_free(mcl_hashmap_s *hashmap);
/** /**
* @brief Free a bucket returned by mcl_hm_get() * @brief Free a bucket returned by mcl_hm_get()
* *
* @param[in] bucket Pointer to the bucket to free * @param[in] bucket Pointer to the bucket to free
*/ */
void mcl_hm_free_bucket(mcl_bucket_s *bucket); void mcl_hm_free_bucket(mcl_bucket_s *bucket);
/** /**
* @brief Insert or update a key-value pair in the hash map * @brief Insert or update a key-value pair in the hash map
* *
* If the key already exists, the old value is freed (if free_value_fn is provided) * If the key already exists, the old value is freed (if free_value_fn is provided)
* and replaced with the new value. If the key doesn't exist, a new entry is created. * and replaced with the new value. If the key doesn't exist, a new entry is created.
* Both key and value are copied into the hashmap using memcpy. * Both key and value are copied into the hashmap using memcpy.
* *
* @param[in] hashmap Pointer to the hash map * @param[in] hashmap Pointer to the hash map
* @param[in] key Pointer to the key to insert (will be copied, must not be NULL) * @param[in] key Pointer to the key to insert (will be copied, must not be NULL)
* @param[in] value Pointer to the value to insert (will be copied, must not be NULL) * @param[in] value Pointer to the value to insert (will be copied, must not be NULL)
* @return true if the operation succeeded, false on failure (NULL hashmap/key/value or memory allocation failure) * @return true if the operation succeeded, false on failure (NULL hashmap/key/value or memory allocation failure)
*/ */
bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value); bool mcl_hm_set(mcl_hashmap_s *hashmap, void *key, void *value);
/** /**
* @brief Retrieve a bucket by key * @brief Retrieve a bucket by key
* *
* Searches for the given key in the hash map and returns the bucket containing it. * Searches for the given key in the hash map and returns the bucket containing it.
* The caller can then access both the key and value from the returned bucket. * The caller can then access both the key and value from the returned bucket.
* *
* @param[in] hashmap Pointer to the hash map * @param[in] hashmap Pointer to the hash map
* @param[in] key Pointer to the key to search for * @param[in] key Pointer to the key to search for
* @return Pointer to the copy of the bucket, to avoid race conditions, or NULL if not found or on invalid input * @return Pointer to the copy of the bucket, to avoid race conditions, or NULL if not found or on invalid input
*/ */
mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key); mcl_bucket_s *mcl_hm_get(mcl_hashmap_s *hashmap, void *key);
/** /**
* @brief Remove a key-value pair from the hash map * @brief Remove a key-value pair from the hash map
* *
* Searches for the given key and removes it from the hash map. Both the key * Searches for the given key and removes it from the hash map. Both the key
* and value are freed using the provided free functions (if not NULL). * and value are freed using the provided free functions (if not NULL).
* *
* @param[in] hashmap Pointer to the hash map * @param[in] hashmap Pointer to the hash map
* @param[in] key Pointer to the key to remove * @param[in] key Pointer to the key to remove
* @return true if the key was found and removed, false if not found or on invalid input * @return true if the key was found and removed, false if not found or on invalid input
*/ */
bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key); bool mcl_hm_remove(mcl_hashmap_s *hashmap, void *key);
#endif /* MYCLIB_HASHMAP_H */ #endif /* MYCLIB_HASHMAP_H */

52
meson.build
View File

@@ -1,26 +1,26 @@
project( project(
'testlib', 'testlib',
'c', 'c',
version: '0.1', version: '0.1',
default_options: ['c_std=c17'], default_options: ['c_std=c17'],
) )
src = files( src = files(
'hashmap/myhashmap.c', 'hashmap/myhashmap.c',
'queue/myqueue.c', 'queue/myqueue.c',
'string/mystring.c', 'string/mystring.c',
) )
testlib = files( testlib = files(
'test/test.c', 'test/test.c',
'test/hashmap/hm1.c', 'test/hashmap/hm1.c',
'test/queue/q1.c', 'test/queue/q1.c',
'test/string/str1.c', 'test/string/str1.c',
'test/string/str2.c', 'test/string/str2.c',
) )
sources = src + testlib sources = src + testlib
inc_dir = include_directories('string', 'queue', 'hashmap') inc_dir = include_directories('string', 'queue', 'hashmap')
executable('testlib', sources, include_directories: inc_dir) executable('testlib', sources, include_directories: inc_dir)

8
native_cl.ini
View File

@@ -1,4 +1,4 @@
[binaries] [binaries]
c = 'cl' c = 'cl'
cpp = 'cl' cpp = 'cl'
ar = 'lib' ar = 'lib'

282
queue/myqueue.c
View File

@@ -1,141 +1,141 @@
#include "myqueue.h" #include "myqueue.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
mcl_queue_s *mcl_queue_new(size_t queue_size, size_t elem_size) { mcl_queue_s *mcl_queue_new(size_t queue_size, size_t elem_size) {
mcl_queue_s *queue = malloc(sizeof(mcl_queue_s)); mcl_queue_s *queue = malloc(sizeof(mcl_queue_s));
if (queue == NULL) { if (queue == NULL) {
return NULL; return NULL;
} }
queue->buffer = malloc(queue_size * elem_size); queue->buffer = malloc(queue_size * elem_size);
if (queue->buffer == NULL) { if (queue->buffer == NULL) {
free(queue); free(queue);
return NULL; return NULL;
} }
int ret = mtx_init(&queue->lock, mtx_plain); int ret = mtx_init(&queue->lock, mtx_plain);
if (ret != thrd_success) { if (ret != thrd_success) {
free(queue->buffer); free(queue->buffer);
free(queue); free(queue);
return NULL; return NULL;
} }
queue->front = 0; queue->front = 0;
queue->rear = 0; queue->rear = 0;
queue->size = 0; queue->size = 0;
queue->capacity = queue_size; queue->capacity = queue_size;
queue->elem_size = elem_size; queue->elem_size = elem_size;
return queue; return queue;
} }
int mcl_queue_push(mcl_queue_s *queue, const void *elem) { int mcl_queue_push(mcl_queue_s *queue, const void *elem) {
int ret = mtx_lock(&queue->lock); int ret = mtx_lock(&queue->lock);
if (ret != thrd_success) { if (ret != thrd_success) {
return -1; return -1;
} }
if (queue->size == queue->capacity) { if (queue->size == queue->capacity) {
/* Queue full */ /* Queue full */
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return -1; return -1;
} }
/* Copy the elem in the buffer */ /* Copy the elem in the buffer */
void *dest = (char *)queue->buffer + (queue->rear * queue->elem_size); void *dest = (char *)queue->buffer + (queue->rear * queue->elem_size);
memcpy(dest, elem, queue->elem_size); memcpy(dest, elem, queue->elem_size);
queue->size++; queue->size++;
queue->rear = (queue->rear + 1) % queue->capacity; queue->rear = (queue->rear + 1) % queue->capacity;
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return 0; return 0;
} }
int mcl_queue_pop(mcl_queue_s *queue, void *out_elem) { int mcl_queue_pop(mcl_queue_s *queue, void *out_elem) {
int ret = mtx_lock(&queue->lock); int ret = mtx_lock(&queue->lock);
if (ret != thrd_success) { if (ret != thrd_success) {
return -1; return -1;
} }
if (queue->size == 0) { if (queue->size == 0) {
/* Queue empty */ /* Queue empty */
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return -1; return -1;
} }
void *src = (char *)queue->buffer + (queue->front * queue->elem_size); void *src = (char *)queue->buffer + (queue->front * queue->elem_size);
memcpy(out_elem, src, queue->elem_size); memcpy(out_elem, src, queue->elem_size);
queue->front = (queue->front + 1) % queue->capacity; queue->front = (queue->front + 1) % queue->capacity;
queue->size--; queue->size--;
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return 0; return 0;
} }
int mcl_queue_get_front(mcl_queue_s *queue, void *out) { int mcl_queue_get_front(mcl_queue_s *queue, void *out) {
int ret = mtx_lock(&queue->lock); int ret = mtx_lock(&queue->lock);
if (ret != thrd_success) { if (ret != thrd_success) {
return -1; return -1;
} }
if (queue->size == 0) { if (queue->size == 0) {
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return -1; return -1;
} }
void *front = (char *)queue->buffer + (queue->front * queue->elem_size); void *front = (char *)queue->buffer + (queue->front * queue->elem_size);
memcpy(out, front, queue->elem_size); memcpy(out, front, queue->elem_size);
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return 0; return 0;
} }
int mcl_queue_get_rear(mcl_queue_s *queue, void *out) { int mcl_queue_get_rear(mcl_queue_s *queue, void *out) {
int ret = mtx_lock(&queue->lock); int ret = mtx_lock(&queue->lock);
if (ret != thrd_success) { if (ret != thrd_success) {
return -1; return -1;
} }
if (queue->size == 0) { if (queue->size == 0) {
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return -1; return -1;
} }
size_t rear_index; size_t rear_index;
if (queue->rear == 0) { if (queue->rear == 0) {
rear_index = queue->capacity - 1; rear_index = queue->capacity - 1;
} else { } else {
rear_index = queue->rear - 1; rear_index = queue->rear - 1;
} }
void *rear = (char *)queue->buffer + (rear_index * queue->elem_size); void *rear = (char *)queue->buffer + (rear_index * queue->elem_size);
memcpy(out, rear, queue->elem_size); memcpy(out, rear, queue->elem_size);
mtx_unlock(&queue->lock); mtx_unlock(&queue->lock);
return 0; return 0;
} }
void mcl_queue_free(mcl_queue_s *queue) { void mcl_queue_free(mcl_queue_s *queue) {
if (queue == NULL) { if (queue == NULL) {
return; return;
} }
mtx_destroy(&queue->lock); mtx_destroy(&queue->lock);
free(queue->buffer); free(queue->buffer);
free(queue); free(queue);
} }

144
queue/myqueue.h
View File

@@ -1,72 +1,72 @@
#ifndef MYCLIB_QUEUE_H #ifndef MYCLIB_QUEUE_H
#define MYCLIB_QUEUE_H #define MYCLIB_QUEUE_H
#include <stddef.h> #include <stddef.h>
#include <threads.h> #include <threads.h>
/** /**
* @brief A simple circular queue (ring buffer). * @brief A simple circular queue (ring buffer).
*/ */
typedef struct mcl_queue { typedef struct mcl_queue {
size_t front; /**< Index of the next element to read. */ size_t front; /**< Index of the next element to read. */
size_t rear; /**< Index where the next element will be written. */ size_t rear; /**< Index where the next element will be written. */
size_t size; /**< Current number of elements in the queue. */ size_t size; /**< Current number of elements in the queue. */
size_t capacity; /**< Maximum number of elements the queue can hold. */ size_t capacity; /**< Maximum number of elements the queue can hold. */
size_t elem_size; /**< Size in bytes of each element. */ size_t elem_size; /**< Size in bytes of each element. */
void *buffer; /**< Memory buffer that holds the elements. */ void *buffer; /**< Memory buffer that holds the elements. */
mtx_t lock; /**< Mutex to protect concurrent access. */ mtx_t lock; /**< Mutex to protect concurrent access. */
} mcl_queue_s; } mcl_queue_s;
/** /**
* @brief Create and initialize a new queue. * @brief Create and initialize a new queue.
* *
* @param queue_size Number of elements the queue can hold. * @param queue_size Number of elements the queue can hold.
* @param elem_size Size in bytes of each element. * @param elem_size Size in bytes of each element.
* @return Pointer to the new queue, or NULL on failure. * @return Pointer to the new queue, or NULL on failure.
*/ */
mcl_queue_s *mcl_queue_new(size_t queue_size, size_t elem_size); mcl_queue_s *mcl_queue_new(size_t queue_size, size_t elem_size);
/** /**
* @brief Add an element to the queue. * @brief Add an element to the queue.
* *
* @param queue Pointer to the queue. * @param queue Pointer to the queue.
* @param elem Pointer to the data to add. * @param elem Pointer to the data to add.
* @return 0 on success, -1 if the queue is full or on error. * @return 0 on success, -1 if the queue is full or on error.
*/ */
int mcl_queue_push(mcl_queue_s *queue, const void *elem); int mcl_queue_push(mcl_queue_s *queue, const void *elem);
/** /**
* @brief Remove an element from the queue. * @brief Remove an element from the queue.
* *
* @param queue Pointer to the queue. * @param queue Pointer to the queue.
* @param out_elem Pointer to memory where the removed element will be copied. * @param out_elem Pointer to memory where the removed element will be copied.
* @return 0 on success, -1 if the queue is empty or on error. * @return 0 on success, -1 if the queue is empty or on error.
*/ */
int mcl_queue_pop(mcl_queue_s *queue, void *out_elem); int mcl_queue_pop(mcl_queue_s *queue, void *out_elem);
/** /**
* @brief Copy the front element without removing it. * @brief Copy the front element without removing it.
* *
* @param queue Pointer to the queue. * @param queue Pointer to the queue.
* @param out Pointer to memory where the element will be copied. * @param out Pointer to memory where the element will be copied.
* @return 0 on success, -1 if the queue is empty or on error. * @return 0 on success, -1 if the queue is empty or on error.
*/ */
int mcl_queue_get_front(mcl_queue_s *queue, void *out); int mcl_queue_get_front(mcl_queue_s *queue, void *out);
/** /**
* @brief Copy the last element without removing it. * @brief Copy the last element without removing it.
* *
* @param queue Pointer to the queue. * @param queue Pointer to the queue.
* @param out Pointer to memory where the element will be copied. * @param out Pointer to memory where the element will be copied.
* @return 0 on success, -1 if the queue is empty or on error. * @return 0 on success, -1 if the queue is empty or on error.
*/ */
int mcl_queue_get_rear(mcl_queue_s *queue, void *out); int mcl_queue_get_rear(mcl_queue_s *queue, void *out);
/** /**
* @brief Free all resources used by the queue. * @brief Free all resources used by the queue.
* *
* @param queue Pointer to the queue to free. * @param queue Pointer to the queue to free.
*/ */
void mcl_queue_free(mcl_queue_s *queue); void mcl_queue_free(mcl_queue_s *queue);
#endif // MYCLIB_QUEUE_H #endif // MYCLIB_QUEUE_H

660
string/mystring.c
View File

@@ -1,321 +1,339 @@
#include "mystring.h" #include "mystring.h"
#include <ctype.h> #include <ctype.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <threads.h> #include <threads.h>
/* Initialize Thread-Specific Storage */ /* Initialize Thread-Specific Storage */
static tss_t buffer_key; static tss_t buffer_key;
static once_flag buffer_once = ONCE_FLAG_INIT; static once_flag buffer_once = ONCE_FLAG_INIT;
typedef struct { typedef struct {
char *buf; /**< Allocated buffer */ char *buf; /**< Allocated buffer */
size_t cap; /**< Buffer's capacity */ size_t cap; /**< Buffer's capacity */
} tl_buffer_s; } tl_buffer_s;
static void buffer_destructor(void *buf) { static void buffer_destructor(void *buf) {
tl_buffer_s *tb = (tl_buffer_s *)buf; tl_buffer_s *tb = (tl_buffer_s *)buf;
if (tb == NULL) { if (tb == NULL) {
return; return;
} }
free(tb->buf); free(tb->buf);
free(tb); free(tb);
} }
static void buffer_key_init(void) { tss_create(&buffer_key, buffer_destructor); } static void buffer_key_init(void) { tss_create(&buffer_key, buffer_destructor); }
/* Returns the next power of two of a number */ /* Returns the next power of two of a number */
static size_t next_power_two(size_t len) { static size_t next_power_two(size_t len) {
if (len == 0) return 1; if (len == 0) return 1;
size_t p = 1; size_t p = 1;
while (p < len) { while (p < len) {
if (p > SIZE_MAX / 2) { if (p > SIZE_MAX / 2) {
p = len; p = len;
break; break;
} }
p <<= 1; p <<= 1;
} }
return p; return p;
} }
mcl_string_s *mcl_string_new(const char *text, size_t initial_capacity) { mcl_string_s *mcl_string_new(const char *text, size_t initial_capacity) {
if (text == NULL) { if (text == NULL) {
return NULL; return NULL;
} }
mcl_string_s *str = malloc(sizeof(mcl_string_s)); mcl_string_s *str = malloc(sizeof(mcl_string_s));
if (str == NULL) { if (str == NULL) {
return NULL; return NULL;
} }
str->size = strlen(text); str->size = strlen(text);
if (initial_capacity != 0 && initial_capacity < (str->size + 1)) { if (initial_capacity != 0 && initial_capacity < (str->size + 1)) {
/* Can't allocate with this capacity */ /* Can't allocate with this capacity */
free(str); free(str);
return NULL; return NULL;
} }
size_t capacity = initial_capacity; size_t capacity = initial_capacity;
if (capacity == 0) { if (capacity == 0) {
/* Calculate the needed capacity */ /* Calculate the needed capacity */
capacity = next_power_two(str->size + 1); capacity = next_power_two(str->size + 1);
} }
str->capacity = capacity; str->capacity = capacity;
/* Allocate data (text) buffer */ /* Allocate data (text) buffer */
str->data = malloc(str->capacity); str->data = malloc(str->capacity);
if (str->data == NULL) { if (str->data == NULL) {
free(str); free(str);
return NULL; return NULL;
} }
/* Copy the text and ensure null termination */ /* Copy the text and ensure null termination */
memcpy(str->data, text, str->size); memcpy(str->data, text, str->size);
str->data[str->size] = '\0'; str->data[str->size] = '\0';
/* Init mutex */ /* Init mutex */
if (mtx_init(&str->lock, mtx_plain) != thrd_success) { if (mtx_init(&str->lock, mtx_plain) != thrd_success) {
free(str->data); free(str->data);
free(str); free(str);
return NULL; return NULL;
} }
return str; return str;
} }
int mcl_string_append(mcl_string_s *string, const char *text) { int mcl_string_append(mcl_string_s *string, const char *text) {
if (string == NULL || text == NULL) { if (string == NULL || text == NULL) {
return -1; return -1;
} }
if (mtx_lock(&string->lock) != thrd_success) { if (mtx_lock(&string->lock) != thrd_success) {
return -1; return -1;
} }
/* Handle empty case */ /* Handle empty case */
size_t text_len = strlen(text); size_t text_len = strlen(text);
if (text_len == 0) { if (text_len == 0) {
mtx_unlock(&string->lock); mtx_unlock(&string->lock);
return 0; return 0;
} }
size_t new_size = string->size + text_len; size_t new_size = string->size + text_len;
/* Check if we need to resize */ /* Check if we need to resize */
if (new_size + 1 > string->capacity) { if (new_size + 1 > string->capacity) {
size_t new_capacity = next_power_two(new_size + 1); size_t new_capacity = next_power_two(new_size + 1);
/* Reallocate the buffer */ /* Reallocate the buffer */
void *new_data = realloc(string->data, new_capacity); void *new_data = realloc(string->data, new_capacity);
if (!new_data) { if (!new_data) {
mtx_unlock(&string->lock); mtx_unlock(&string->lock);
return -1; return -1;
} }
string->data = new_data; string->data = new_data;
string->capacity = new_capacity; string->capacity = new_capacity;
} }
/* Append text */ /* Append text */
memcpy(string->data + string->size, text, text_len); memcpy(string->data + string->size, text, text_len);
string->size = new_size; string->size = new_size;
string->data[string->size] = '\0'; string->data[string->size] = '\0';
mtx_unlock(&string->lock); mtx_unlock(&string->lock);
return 0; return 0;
} }
int mcl_string_extend(mcl_string_s *destination, mcl_string_s *source) { int mcl_string_extend(mcl_string_s *destination, mcl_string_s *source) {
/* TODO */ if (destination == NULL || source == NULL) {
return -1;
return 0; }
}
size_t need = destination->size + source->size;
void mcl_string_free(mcl_string_s *string) { if (need > destination->capacity) {
if (string == NULL) { /* Reallocate destination data buffer */
return; destination->capacity = next_power_two(need);
} char *tmp = realloc(destination->data, destination->capacity);
if (tmp == NULL) {
if (string->data) { return -1;
free(string->data); }
} destination->data = tmp;
}
mtx_destroy(&string->lock);
/* Copy memory from source data buffer */
free(string); memcpy(destination->data + destination->size, source->data, source->size);
} destination->size = need;
destination->data[destination->size] = '\0';
size_t mcl_string_length(mcl_string_s *string) {
if (string == NULL) { return 0;
return 0; }
}
void mcl_string_free(mcl_string_s *string) {
if (mtx_lock(&string->lock) != thrd_success) { if (string == NULL) {
return 0; return;
} }
size_t len = string->size; if (string->data) {
free(string->data);
mtx_unlock(&string->lock); }
return len; mtx_destroy(&string->lock);
}
free(string);
size_t mcl_string_capacity(mcl_string_s *string) { }
if (string == NULL) {
return 0; size_t mcl_string_length(mcl_string_s *string) {
} if (string == NULL) {
return 0;
if (mtx_lock(&string->lock) != thrd_success) { }
return 0;
} if (mtx_lock(&string->lock) != thrd_success) {
return 0;
size_t cap = string->capacity; }
mtx_unlock(&string->lock); size_t len = string->size;
return cap; mtx_unlock(&string->lock);
}
return len;
char *mcl_string_cstr(mcl_string_s *string) { }
if (string == NULL || string->data == NULL) {
return NULL; size_t mcl_string_capacity(mcl_string_s *string) {
} if (string == NULL) {
return 0;
call_once(&buffer_once, buffer_key_init); }
if (mtx_lock(&string->lock) != thrd_success) { if (mtx_lock(&string->lock) != thrd_success) {
return NULL; return 0;
} }
size_t need = string->size + 1; size_t cap = string->capacity;
/* Retrieve thread local buffer */ mtx_unlock(&string->lock);
tl_buffer_s *tb = (tl_buffer_s *)tss_get(buffer_key);
if (tb == NULL) { return cap;
/* Not found, make a new one */ }
tb = malloc(sizeof(*tb));
if (tb == NULL) { char *mcl_string_cstr(mcl_string_s *string) {
mtx_unlock(&string->lock); if (string == NULL || string->data == NULL) {
return NULL;
return NULL; }
}
call_once(&buffer_once, buffer_key_init);
tb->cap = next_power_two(need);
tb->buf = malloc(tb->cap); if (mtx_lock(&string->lock) != thrd_success) {
if (tb->buf == NULL) { return NULL;
free(tb); }
mtx_unlock(&string->lock);
size_t need = string->size + 1;
return NULL;
} /* Retrieve thread local buffer */
tl_buffer_s *tb = (tl_buffer_s *)tss_get(buffer_key);
if (tss_set(buffer_key, tb) != thrd_success) { if (tb == NULL) {
free(tb->buf); /* Not found, make a new one */
free(tb); tb = malloc(sizeof(*tb));
mtx_unlock(&string->lock); if (tb == NULL) {
mtx_unlock(&string->lock);
return NULL;
} return NULL;
} else if (tb->cap < need) { }
/* Found, but we need a bigger buffer */
size_t newcap = next_power_two(need); tb->cap = next_power_two(need);
char *tmp = realloc(tb->buf, newcap); tb->buf = malloc(tb->cap);
if (tmp == NULL) { if (tb->buf == NULL) {
mtx_unlock(&string->lock); free(tb);
mtx_unlock(&string->lock);
return NULL;
} return NULL;
}
tb->buf = tmp;
tb->cap = newcap; if (tss_set(buffer_key, tb) != thrd_success) {
} free(tb->buf);
free(tb);
memcpy(tb->buf, string->data, need); mtx_unlock(&string->lock);
mtx_unlock(&string->lock); return NULL;
}
return tb->buf; } else if (tb->cap < need) {
} /* Found, but we need a bigger buffer */
size_t newcap = next_power_two(need);
int mcl_string_compare(mcl_string_s *s1, mcl_string_s *s2) { char *tmp = realloc(tb->buf, newcap);
if (s1 == NULL || s2 == NULL) { if (tmp == NULL) {
return -123; mtx_unlock(&string->lock);
}
return NULL;
if (mtx_lock(&s1->lock) != thrd_success) { }
return -123;
} tb->buf = tmp;
tb->cap = newcap;
if (mtx_lock(&s2->lock) != thrd_success) { }
mtx_unlock(&s1->lock);
memcpy(tb->buf, string->data, need);
return -123;
} mtx_unlock(&string->lock);
int ret = strcmp(s1->data, s2->data); return tb->buf;
}
mtx_unlock(&s1->lock);
mtx_unlock(&s2->lock); int mcl_string_compare(mcl_string_s *s1, mcl_string_s *s2) {
if (s1 == NULL || s2 == NULL) {
return ret; return -123;
} }
void mcl_string_clear(mcl_string_s *string) { if (mtx_lock(&s1->lock) != thrd_success) {
if (string == NULL) { return -123;
return; }
}
if (mtx_lock(&s2->lock) != thrd_success) {
if (mtx_lock(&string->lock) != thrd_success) { mtx_unlock(&s1->lock);
return;
} return -123;
}
memset(string->data, 0, string->size);
string->size = 0; int ret = strcmp(s1->data, s2->data);
mtx_unlock(&string->lock); mtx_unlock(&s1->lock);
} mtx_unlock(&s2->lock);
void mcl_string_toupper(mcl_string_s *string) { return ret;
if (string == NULL) { }
return;
} void mcl_string_clear(mcl_string_s *string) {
if (string == NULL) {
if (mtx_lock(&string->lock) != thrd_success) { return;
return; }
}
if (mtx_lock(&string->lock) != thrd_success) {
for (size_t i = 0; i < string->size; ++i) { return;
string->data[i] = (char)toupper((unsigned char)string->data[i]); }
}
memset(string->data, 0, string->size);
mtx_unlock(&string->lock); string->size = 0;
}
mtx_unlock(&string->lock);
void mcl_string_tolower(mcl_string_s *string) { }
if (string == NULL) {
return; void mcl_string_toupper(mcl_string_s *string) {
} if (string == NULL) {
return;
if (mtx_lock(&string->lock) != thrd_success) { }
return;
} if (mtx_lock(&string->lock) != thrd_success) {
return;
for (size_t i = 0; i < string->size; ++i) { }
string->data[i] = (char)tolower((unsigned char)string->data[i]);
} for (size_t i = 0; i < string->size; ++i) {
string->data[i] = (char)toupper((unsigned char)string->data[i]);
mtx_unlock(&string->lock); }
}
mtx_unlock(&string->lock);
}
void mcl_string_tolower(mcl_string_s *string) {
if (string == NULL) {
return;
}
if (mtx_lock(&string->lock) != thrd_success) {
return;
}
for (size_t i = 0; i < string->size; ++i) {
string->data[i] = (char)tolower((unsigned char)string->data[i]);
}
mtx_unlock(&string->lock);
}

227
string/mystring.h
View File

@@ -1,108 +1,119 @@
#ifndef MYCLIB_STRING_H #ifndef MYCLIB_STRING_H
#define MYCLIB_STRING_H #define MYCLIB_STRING_H
#include <stddef.h> #include <stddef.h>
#include <threads.h> #include <threads.h>
/** /**
* @brief Thread-safe dynamic string structure. * @brief Thread-safe dynamic string structure.
*/ */
typedef struct mcl_string { typedef struct mcl_string {
char *data; /**< Pointer to null-terminated string data */ char *data; /**< Pointer to null-terminated string data */
size_t size; /**< Current length (excluding null terminator) */ size_t size; /**< Current length (excluding null terminator) */
size_t capacity; /**< Allocated capacity including null terminator */ size_t capacity; /**< Allocated capacity including null terminator */
mtx_t lock; /**< Mutex for thread safety */ mtx_t lock; /**< Mutex for thread safety */
} mcl_string_s; } mcl_string_s;
/** /**
* @brief Create a new string initialized with the given text. * @brief Create a new string initialized with the given text.
* *
* @param text Initial text. * @param text Initial text.
* @param initial_capacity Initial buffer capacity (including null terminator). Pass 0 to auto-calculate. * @param initial_capacity Initial buffer capacity (including null terminator). Pass 0 to auto-calculate.
* @return Pointer to the new string, or NULL on failure. * @return Pointer to the new string, or NULL on failure.
*/ */
mcl_string_s *mcl_string_new(const char *text, size_t initial_capacity); mcl_string_s *mcl_string_new(const char *text, size_t initial_capacity);
/** /**
* @brief Free the string and its resources. * @brief Free the string and its resources.
* *
* @param string String to free (safe to call with NULL). * @param string String to free (safe to call with NULL).
*/ */
void mcl_string_free(mcl_string_s *string); void mcl_string_free(mcl_string_s *string);
/** /**
* @brief Append text to the string. * @brief Append text to the string.
* *
* @param string String to modify. * @param string String to modify.
* @param text Text to append. * @param text Text to append.
* @return 0 on success, -1 on failure. * @return 0 on success, -1 on failure.
*/ */
int mcl_string_append(mcl_string_s *string, const char *text); int mcl_string_append(mcl_string_s *string, const char *text);
/** /**
* @brief Extend by adding another string. * @brief Extend by adding another string.
* *
* @param destination Destination string. * @param destination Destination string.
* @param source Source string. * @param source Source string.
* @return 0 on success, -1 on failure. * @return 0 on success, -1 on failure.
*/ */
int mcl_string_extend(mcl_string_s *destination, mcl_string_s *source); int mcl_string_extend(mcl_string_s *destination, mcl_string_s *source);
/** /**
* @brief Clear the string content without freeing the memory. * @brief Clear the string content without freeing the memory.
* *
* @param string String to clear. * @param string String to clear.
*/ */
void mcl_string_clear(mcl_string_s *string); void mcl_string_clear(mcl_string_s *string);
/** /**
* @brief Get the current length of the string. * @brief Get the current length of the string.
* *
* @param string String to query. * @param string String to query.
* @return Length excluding null terminator, or 0 if NULL. * @return Length excluding null terminator, or 0 if NULL.
*/ */
size_t mcl_string_length(mcl_string_s *string); size_t mcl_string_length(mcl_string_s *string);
/** /**
* @brief Get the total allocated capacity of the string buffer. * @brief Get the total allocated capacity of the string buffer.
* *
* @param string String to query. * @param string String to query.
* @return Capacity in bytes (including null terminator), or 0 if NULL. * @return Capacity in bytes (including null terminator), or 0 if NULL.
*/ */
size_t mcl_string_capacity(mcl_string_s *string); size_t mcl_string_capacity(mcl_string_s *string);
/** /**
* @brief Get a pointer to a null-terminated C-string. * @brief Get a pointer to a null-terminated C-string.
* *
* @param string String to read. * @param string String to read.
* @return Pointer to a thread-local buffer, or NULL on failure. * @return Pointer to a thread-local buffer, or NULL on failure.
* *
* @note Valid until the next call in the same thread. Do NOT free the returned pointer. * @note Valid until the next call in the same thread. Do NOT free the returned pointer.
* Do NOT call more than once this function in a print function. * Do NOT call more than once this function in a print function.
*/ */
char *mcl_string_cstr(mcl_string_s *string); char *mcl_string_cstr(mcl_string_s *string);
/** /**
* @brief Compare two strings. * @brief Compare two strings.
* *
* @param s1 First string. * @param s1 First string.
* @param s2 Second string. * @param s2 Second string.
* @return -123 on failure or same as strcmp(). * @return -123 on failure or same as strcmp().
*/ */
int mcl_string_compare(mcl_string_s *s1, mcl_string_s *s2); int mcl_string_compare(mcl_string_s *s1, mcl_string_s *s2);
/** /**
* @brief Convert the string to uppercase. * @brief Convert the string to uppercase.
* *
* @param string String to modify. * @param string String to modify.
*/ */
void mcl_string_toupper(mcl_string_s *string); void mcl_string_toupper(mcl_string_s *string);
/** /**
* @brief Convert the string to lowercase. * @brief Convert the string to lowercase.
* *
* @param string String to modify. * @param string String to modify.
*/ */
void mcl_string_tolower(mcl_string_s *string); void mcl_string_tolower(mcl_string_s *string);
#endif /* MYCLIB_STRING_H */ /**
* @brief Find a substring inside a string.
*
* @param string String where to search.
* @param substring Substring to search.
* @return Index of the first occurrence, -1 on failure.
*
* @note TODO
*/
int mcl_string_find(mcl_string_s *string, const char *substring);
#endif /* MYCLIB_STRING_H */

180
test/hashmap/hm1.c
View File

@@ -1,90 +1,90 @@
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "../../hashmap/myhashmap.h" #include "../../hashmap/myhashmap.h"
#define MAX_STR_LEN 64 #define MAX_STR_LEN 64
/* My custom data type stored as value */ /* My custom data type stored as value */
struct my_custom_type { struct my_custom_type {
int age; int age;
char favourite_brand[MAX_STR_LEN]; char favourite_brand[MAX_STR_LEN];
}; };
/* Let's hash our name */ /* Let's hash our name */
static unsigned int my_hash_func(const void *key) { static unsigned int my_hash_func(const void *key) {
char *name = (char *)key; char *name = (char *)key;
size_t len = strlen(name); size_t len = strlen(name);
unsigned int hash = 0; unsigned int hash = 0;
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
hash += (int)name[i]; hash += (int)name[i];
} }
return hash % 2069; return hash % 2069;
} }
/* Let's write our compare function */ /* Let's write our compare function */
bool my_equal_fun(const void *key_a, const void *key_b) { bool my_equal_fun(const void *key_a, const void *key_b) {
char *name_a = (char *)key_a; char *name_a = (char *)key_a;
char *name_b = (char *)key_b; char *name_b = (char *)key_b;
if (strcmp(name_a, name_b) == 0) { if (strcmp(name_a, name_b) == 0) {
return true; return true;
} }
return false; return false;
} }
/* And our last two functions, the free key and value called inside mcl_hm_remove() */ /* And our last two functions, the free key and value called inside mcl_hm_remove() */
void my_free_key(void *key) { free(key); } void my_free_key(void *key) { free(key); }
void my_free_value(void *value) { void my_free_value(void *value) {
struct my_custom_type *mct = (struct my_custom_type *)value; struct my_custom_type *mct = (struct my_custom_type *)value;
free(mct); free(mct);
} }
void test_hm1(void) { void test_hm1(void) {
/* Allocate a new hashmap */ /* Allocate a new hashmap */
/* Pass your custom hash, equal and free functions */ /* Pass your custom hash, equal and free functions */
/* This hashmap will contain names as keys and a custom type as value */ /* This hashmap will contain names as keys and a custom type as value */
size_t key_size = sizeof(char) * MAX_STR_LEN; size_t key_size = sizeof(char) * MAX_STR_LEN;
size_t value_size = sizeof(int) + sizeof(char) * MAX_STR_LEN; size_t value_size = sizeof(int) + sizeof(char) * MAX_STR_LEN;
mcl_hashmap_s *map = mcl_hm_new(my_hash_func, my_equal_fun, my_free_key, my_free_value, key_size, value_size); mcl_hashmap_s *map = mcl_hm_new(my_hash_func, my_equal_fun, my_free_key, my_free_value, key_size, value_size);
assert(map != NULL); assert(map != NULL);
/* Make a new value */ /* Make a new value */
struct my_custom_type p1 = { struct my_custom_type p1 = {
.age = 21, .age = 21,
}; };
strncpy(p1.favourite_brand, "Ferrari", sizeof(p1.favourite_brand)); strncpy(p1.favourite_brand, "Ferrari", sizeof(p1.favourite_brand));
/* Insert a new pair */ /* Insert a new pair */
assert(mcl_hm_set(map, "John", &p1)); assert(mcl_hm_set(map, "John", &p1));
/* Retrieve the data */ /* Retrieve the data */
/* Remember to free the value from the get function */ /* Remember to free the value from the get function */
mcl_bucket_s *john = mcl_hm_get(map, "John"); mcl_bucket_s *john = mcl_hm_get(map, "John");
assert(john != NULL); assert(john != NULL);
char *name = (char *)john->key; char *name = (char *)john->key;
struct my_custom_type *john_v = (struct my_custom_type *)john->value; struct my_custom_type *john_v = (struct my_custom_type *)john->value;
int age = john_v->age; int age = john_v->age;
char *fav_brand = john_v->favourite_brand; char *fav_brand = john_v->favourite_brand;
assert(strcmp(name, "John") == 0); assert(strcmp(name, "John") == 0);
assert(age == 21); assert(age == 21);
assert(strcmp(fav_brand, "Ferrari") == 0); assert(strcmp(fav_brand, "Ferrari") == 0);
/* Free the bucket */ /* Free the bucket */
mcl_hm_free_bucket(john); mcl_hm_free_bucket(john);
/* Remove a key from hash map */ /* Remove a key from hash map */
assert(mcl_hm_remove(map, "John")); assert(mcl_hm_remove(map, "John"));
/* Deallocate */ /* Deallocate */
mcl_hm_free(map); mcl_hm_free(map);
} }

96
test/queue/q1.c
View File

@@ -1,48 +1,48 @@
#include <assert.h> #include <assert.h>
#include "../../queue/myqueue.h" #include "../../queue/myqueue.h"
void test_q1(void) { void test_q1(void) {
/* Allocate a new queue */ /* Allocate a new queue */
mcl_queue_s *queue = mcl_queue_new(3, sizeof(int)); mcl_queue_s *queue = mcl_queue_new(3, sizeof(int));
assert(queue != NULL); assert(queue != NULL);
int val, out; int val, out;
/* Push value to the ring buffer */ /* Push value to the ring buffer */
val = 1; val = 1;
assert(mcl_queue_push(queue, &val) == 0); assert(mcl_queue_push(queue, &val) == 0);
val = 2; val = 2;
assert(mcl_queue_push(queue, &val) == 0); assert(mcl_queue_push(queue, &val) == 0);
/* Retrieve values */ /* Retrieve values */
int front, rear; int front, rear;
assert(mcl_queue_get_front(queue, &front) == 0); assert(mcl_queue_get_front(queue, &front) == 0);
assert(mcl_queue_get_rear(queue, &rear) == 0); assert(mcl_queue_get_rear(queue, &rear) == 0);
assert(front == 1); assert(front == 1);
assert(rear == 2); assert(rear == 2);
/* Remove an element from the buffer */ /* Remove an element from the buffer */
assert(mcl_queue_pop(queue, &out) == 0); assert(mcl_queue_pop(queue, &out) == 0);
assert(out == 1); assert(out == 1);
assert(mcl_queue_get_front(queue, &front) == 0); assert(mcl_queue_get_front(queue, &front) == 0);
assert(front == 2); assert(front == 2);
val = 3; val = 3;
assert(mcl_queue_push(queue, &val) == 0); assert(mcl_queue_push(queue, &val) == 0);
assert(mcl_queue_get_rear(queue, &rear) == 0); assert(mcl_queue_get_rear(queue, &rear) == 0);
assert(rear == 3); assert(rear == 3);
val = 4; val = 4;
assert(mcl_queue_push(queue, &val) == 0); assert(mcl_queue_push(queue, &val) == 0);
/* Clear queue */ /* Clear queue */
while (mcl_queue_pop(queue, &out) == 0) {} while (mcl_queue_pop(queue, &out) == 0) {}
assert(queue->size == 0); assert(queue->size == 0);
/* Deallocate memory */ /* Deallocate memory */
mcl_queue_free(queue); mcl_queue_free(queue);
} }

74
test/string/str1.c
View File

@@ -1,37 +1,37 @@
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "../../string/mystring.h" #include "../../string/mystring.h"
void test_str1(void) { void test_str1(void) {
size_t length; size_t length;
size_t capacity; size_t capacity;
char *c_str; char *c_str;
/* Allocate a new dynamic string with an initial capacity */ /* Allocate a new dynamic string with an initial capacity */
mcl_string_s *str = mcl_string_new("Hello, world!", 512); mcl_string_s *str = mcl_string_new("Hello, world!", 512);
assert(str != NULL); assert(str != NULL);
/* Retrieve a C str from string with mcl_string_cstr() */ /* Retrieve a C str from string with mcl_string_cstr() */
c_str = mcl_string_cstr(str); c_str = mcl_string_cstr(str);
length = mcl_string_length(str); length = mcl_string_length(str);
capacity = mcl_string_capacity(str); capacity = mcl_string_capacity(str);
assert(strcmp(c_str, "Hello, world!") == 0); assert(strcmp(c_str, "Hello, world!") == 0);
assert(length == 13); assert(length == 13);
assert(capacity == 512); assert(capacity == 512);
/* Append text to a mcl_string */ /* Append text to a mcl_string */
assert(mcl_string_append(str, " How are you?") == 0); assert(mcl_string_append(str, " How are you?") == 0);
c_str = mcl_string_cstr(str); c_str = mcl_string_cstr(str);
length = mcl_string_length(str); length = mcl_string_length(str);
capacity = mcl_string_capacity(str); capacity = mcl_string_capacity(str);
assert(strcmp(c_str, "Hello, world! How are you?") == 0); assert(strcmp(c_str, "Hello, world! How are you?") == 0);
assert(length == 26); assert(length == 26);
assert(capacity == 512); assert(capacity == 512);
/* Always deallocate memory */ /* Always deallocate memory */
mcl_string_free(str); mcl_string_free(str);
} }

61
test/string/str2.c
View File

@@ -1,27 +1,34 @@
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
#include "../../string/mystring.h" #include "../../string/mystring.h"
void test_str2(void) { void test_str2(void) {
mcl_string_s *s1 = mcl_string_new("Hello, world!", 0); mcl_string_s *s1 = mcl_string_new("Hello, world!", 0);
assert(s1 != NULL); assert(s1 != NULL);
mcl_string_s *s2 = mcl_string_new("Hello, world!", 0); mcl_string_s *s2 = mcl_string_new("Hello, world!", 0);
assert(s2 != NULL); assert(s2 != NULL);
/* Don't call mcl_string_cstr() more than once in the same printf function */ /* Don't call mcl_string_cstr() more than once in the same printf function */
int ret = mcl_string_compare(s1, s2); int ret = mcl_string_compare(s1, s2);
assert(ret == 0); assert(ret == 0);
mcl_string_clear(s1); mcl_string_clear(s1);
ret = mcl_string_compare(s1, s2); ret = mcl_string_compare(s1, s2);
assert(ret != 0); assert(ret != 0);
mcl_string_tolower(s1); mcl_string_tolower(s1);
mcl_string_toupper(s2); mcl_string_toupper(s2);
assert(strcmp(mcl_string_cstr(s1), "") == 0); assert(strcmp(mcl_string_cstr(s1), "") == 0);
assert(strcmp(mcl_string_cstr(s2), "HELLO, WORLD!") == 0); assert(strcmp(mcl_string_cstr(s2), "HELLO, WORLD!") == 0);
mcl_string_free(s1); /* Extend a string */
mcl_string_free(s2); mcl_string_s *extend_me = mcl_string_new("This string is suuuuuuuuuuuuuuuuuuuuuper extended!", 0);
} mcl_string_extend(s1, extend_me);
assert(mcl_string_length(s1) == 50);
assert(mcl_string_capacity(s1) == 64);
mcl_string_free(s1);
mcl_string_free(s2);
mcl_string_free(extend_me);
}

57
test/test.c
View File

@@ -1,26 +1,31 @@
/** /**
* Ignore this file * Ignore this file
*/ */
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
int main(void) { void test_hm1();
puts("==== [Running Hashmap tests] ===="); void test_q1();
test_hm1(); void test_str1();
puts("OK!"); void test_str2();
puts("");
int main(void) {
puts("==== [Running Queue tests] ===="); puts("==== [Running Hashmap tests] ====");
test_q1(); test_hm1();
puts("OK!"); puts("OK!");
puts(""); puts("");
puts("==== [Running String tests] ===="); puts("==== [Running Queue tests] ====");
test_str1(); test_q1();
test_str2(); puts("OK!");
puts("OK!"); puts("");
puts("");
puts("==== [Running String tests] ====");
return 0; test_str1();
} test_str2();
puts("OK!");
puts("");
return 0;
}