Removing toolbox .c because it will be header only

src/toolbox/args.c

@@ -1,310 +0,0 @@
-#include "toolbox/args.h"
-#include "toolbox/cstring.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-
-struct args
-args_create(int argc, char **argv) {
-	struct args self = (struct args) {
-		.argc = argc,
-		.argv = argv,
-		.mand_num = 0,
-		.prepender = '-',
-		.ops = {
-			.size = 0,
-			.data = {{0}}
-		}
-	};
-	return self;
-}
-
-void
-args_set_toggle(struct args *self
-				, const char abreviation, const char *restrict verbose
-				, const char *restrict description
-				, bool mandatory, bool *ret) {
-	self->ops.data[self->ops.size++] = (struct args_op) {
-		.mand = mandatory,
-		.abv = abreviation,
-		.type = TOGGLE,
-		.ret = ret,
-		.verb = {
-			.cstr = verbose,
-			.size = cstring_len(verbose),
-		},
-		.desc = description,
-	};
-	if ( mandatory ) {
-		++self->mand_num;
-	}
-}
-
-void
-args_set_op_str(struct args *self
-				, const char abreviation, const char *restrict verbose
-				, const char *restrict description
-				, bool mandatory, void *ret) {
-	self->ops.data[self->ops.size++] = (struct args_op) {
-		.mand = mandatory,
-		.abv = abreviation,
-		.type = STRING,
-		.ret = ret,
-		.verb = {
-			.cstr = verbose,
-			.size = cstring_len(verbose),
-		},
-		.desc = description,
-	};
-	if ( mandatory ) {
-		++self->mand_num;
-	}
-}
-
-void
-args_set_op_float(struct args *self
-				  , const char abreviation, const char *restrict verbose
-				  , const char *restrict description, bool mandatory
-				  , bool is_double, void *ret) {
-	self->ops.data[self->ops.size++] = (struct args_op) {
-		.mand = mandatory,
-		.abv = abreviation,
-		.type = ( is_double ) ? DOUBLE : FLOAT,
-		.ret = ret,
-		.verb = {
-			.cstr = verbose,
-			.size = cstring_len(verbose),
-		},
-		.desc = description,
-	};
-	if ( mandatory ) {
-		++self->mand_num;
-	}
-}
-
-void
-args_set_op_int(struct args *self
-				, const char abreviation, const char *restrict verbose
-				, const char *restrict description, bool mandatory
-				, size_t size_in_byte, void *ret) {
-	self->ops.data[self->ops.size++] = (struct args_op) {
-		.mand = mandatory,
-		.abv = abreviation,
-		.type = ( size_in_byte == sizeof(uint8_t) ) ? INT8
-		: ( size_in_byte == sizeof(uint16_t) ) ? INT16
-		: ( size_in_byte == sizeof(uint32_t) ) ? INT32
-		: ( size_in_byte == sizeof(uint64_t) ) ? INT64 : INT32,
-		.ret = ret,
-		.verb = {
-			.cstr = verbose,
-			.size = cstring_len(verbose),
-		},
-		.desc = description,
-	};
-	if ( mandatory ) {
-		++self->mand_num;
-	}
-}
-
-static void
-m_print_ops_and_exit(struct args *self) {
-	(void) self;
-	fprintf(stderr, "usage: %s [OPTION]\n", *self->argv);
-
-	for ( size_t i = 0; i < self->ops.size; ++i ) {
-		struct args_op tmp_op = self->ops.data[i];
-
-		fprintf(stderr, "  %c%c, %c%c%s"
-				, self->prepender, tmp_op.abv
-				, self->prepender, self->prepender, tmp_op.verb.cstr);
-
-		switch ( tmp_op.type ) {
-		case TOGGLE:
-			break;
-		case STRING:
-			fprintf(stderr, "=STRING");
-			break;
-		case INT8:
-		case INT16:
-		case INT32:
-		case INT64:
-		case FLOAT:
-		case DOUBLE:
-			fprintf(stderr, "=NUM");
-			break;
-		}
-
-		fprintf(stderr, "\t\t%s\n", tmp_op.desc);
-	}
-
-	exit(EXIT_FAILURE);
-}
-
-static size_t
-m_index_of_op_with_abv(struct args *self, const char pos_abv) {
-	for ( size_t i = 0; i < self->ops.size; ++i ) {
-		if ( self->ops.data[i].abv == pos_abv ) {
-			return i;
-		}
-	}
-	return (size_t) -1;
-}
-
-static size_t
-m_index_of_op_with_verb(struct args *self, const char *cstring) {
-	for ( size_t i = 0; i < self->ops.size; ++i ) {
-		if ( strncmp(self->ops.data[i].verb.cstr
-					 , cstring
-					 , self->ops.data[i].verb.size) == 0 ) {
-			return i;
-		}
-	}
-	return (size_t) -1;
-}
-
-enum __err_type__ {
-	UNRECOGNIZED_OP,
-	EXPECTED_VALUE,
-	UNEXPECTED_VALUE,
-	EXPECTED_NUM_ONLY_VALUE
-};
-
-static void
-m_error(struct args *self, const enum __err_type__ err_type
-		, const char *option) {
-	fprintf(stderr, "%s: ", *self->argv);
-	switch ( err_type ) {
-	case UNRECOGNIZED_OP:
-		fprintf(stderr, "unrecognized option %s\n\n", option);
-		break;
-	case EXPECTED_VALUE:
-		fprintf(stderr, "%s expects a value\n\n", option);
-		break;
-	case UNEXPECTED_VALUE:
-		fprintf(stderr, "%s doen't expects a value\n\n", option);
-		break;
-	case EXPECTED_NUM_ONLY_VALUE:
-		fprintf(stderr, "%s expects a value made of only number\n\n", option);
-		break;
-	}
-	m_print_ops_and_exit(self);
-}
-
-static void
-m_set_value_from_cstring(struct args_op op
-						 , const char *cstring, size_t cstring_size) {
-	switch ( op.type ) {
-	case TOGGLE:
-		*(bool*)op.ret = true;
-		break;
-	case STRING:
-		if ( cstring_size > 0 ) {
-			strncpy((char*) op.ret, cstring, cstring_size);
-		}
-		break;
-	case INT8:
-		*(uint8_t*)op.ret = (uint8_t) atoi(cstring);
-		break;
-	case INT16:
-		*(uint16_t*)op.ret = (uint16_t) atoi(cstring);
-		break;
-	case INT32:
-		*(uint32_t*)op.ret = (uint32_t) atoi(cstring);
-		break;
-	case INT64:
-		*(uint64_t*)op.ret = (uint64_t) atol(cstring);
-		break;
-	case FLOAT:
-		*(float*)op.ret = (float) atof(cstring);
-		break;
-	case DOUBLE:
-		*(double*)op.ret = (double) atof(cstring);
-		break;
-	}
-}
-
-void
-args_check(struct args *self) {
-	if ( self->argc-1 < (int) self->mand_num ) {
-		m_print_ops_and_exit(self);
-	}
-
-	struct args_op tmp_op = {0};
-	bool exp_value = false;
-	int i = 0;
-	while ( ++i < self->argc) {
-		char *cstring = *(self->argv + i);
-		size_t cstring_size = cstring_len(cstring);
-		if ( ! exp_value ) {
-			if ( *cstring++ != '-' ) {
-				continue;
-			}
-			--cstring_size;
-		}
-		if ( exp_value ) {
-			if ( *cstring == '-' ) {
-				if ( tmp_op.type == TOGGLE ) { // This is Impossible
-					m_error(self, UNEXPECTED_VALUE, *(self->argv + i - 1));
-				}
-				m_error(self, EXPECTED_VALUE, *(self->argv + i - 1));
-			}
-			m_set_value_from_cstring(tmp_op, cstring, cstring_size);
-			tmp_op = (struct args_op) {0};
-			exp_value = false;
-		} else if ( *cstring != '-' ) {
-			// abv -*
-			size_t index = m_index_of_op_with_abv(self, *cstring++);
-			--cstring_size;
-			if ( index == (size_t) -1 ) {
-				m_error(self, UNRECOGNIZED_OP, *(self->argv + i));
-			}
-			tmp_op = self->ops.data[index];
-			if ( *cstring != '\0' && cstring_size > 0) {
-				if ( tmp_op.type == TOGGLE ) {
-					*cstring = '\0'; // Removing the unexpected value
-					m_error(self, UNEXPECTED_VALUE, *(self->argv + i));
-				}
-				m_set_value_from_cstring(tmp_op, cstring, cstring_size);
-			} else {
-				if ( tmp_op.type == TOGGLE ) {
-					m_set_value_from_cstring(tmp_op, NULL, 0);
-				} else {
-					exp_value = true;
-				}
-			}
-		} else {
-			// verb --*
-			++cstring;
-			--cstring_size;
-			size_t index = m_index_of_op_with_verb(self, cstring);
-			if ( index == (size_t) -1 ) {
-				m_error(self, UNRECOGNIZED_OP, *(self->argv + i));
-			}
-			tmp_op = self->ops.data[index];
-			if ( cstring_size > tmp_op.verb.size ) {
-				cstring += tmp_op.verb.size;
-				cstring_size -= tmp_op.verb.size;
-				if ( *cstring == '=' ) {
-					++cstring;
-					--cstring_size;
-				}
-				if ( tmp_op.type == TOGGLE ) {
-					*cstring = '\0'; // Removing the unexpected value
-					m_error(self, UNEXPECTED_VALUE, *(self->argv + i));
-				}
-				m_set_value_from_cstring(tmp_op, cstring, cstring_size);
-			} else {
-				if ( tmp_op.type == TOGGLE ) {
-					m_set_value_from_cstring(tmp_op, NULL, 0);
-				} else {
-					exp_value = true;
-				}
-			}
-		}
-	}
-}

src/toolbox/array.c

@@ -1,245 +0,0 @@
-#include "toolbox/array.h"
-
-#include <stdint.h>
-#include <stddef.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "toolbox/void_pointer.h"
-#include "toolbox/log.h"
-#include "toolbox/errno.h"
-
-#define true ((unsigned char) 1L)
-#define false ((unsigned char) 0L)
-
-#define TEST_FOR_NULL(POINTER)						\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return toolbox_errno;					\
-	}
-
-#define TEST_FOR_NULL_SR(POINTER, RET)					\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return RET;						\
-	}
-
-struct array *
-array_create(size_t arr_size, size_t item_size) {
-	toolbox_errno = RET_OK;
-	struct array *self = calloc(1, sizeof(struct array));
-	if ( self == NULL ) {
-		toolbox_errno = RET_EFM;
-		return NULL;
-	}
-	self->item_size = item_size;
-	self->alloc_size = arr_size;
-	self->size = 0;
-	self->data = calloc(self->alloc_size, sizeof(void *));
-	if ( self->data == NULL ) {
-		toolbox_errno = RET_EFM;
-		free(self);
-		return NULL;
-	}
-	return self;
-}
-
-RET_TYPE
-array_clear(struct array *self) {
-	toolbox_errno = RET_OK;
-	for ( size_t i = 0; i < self->size; ++i ) {
-		free(self->data[i]);
-		self->data[i] = NULL;
-	}
-	self->size = 0;
-	return toolbox_errno;
-}
-
-RET_TYPE
-array_destroy(struct array **self) {
-	toolbox_errno = RET_OK;
-	if ( self != NULL ) {
-		if ( *self != NULL ) {
-			for ( size_t i = 0; i < (*self)->size; ++i ) {
-				free((*self)->data[i]);
-			}
-			free(*self);
-			*self = NULL;
-			return RET_OK;
-		}
-	}
-	toolbox_errno = RET_EVN;
-	return toolbox_errno;
-}
-
-size_t
-array_index_of(const struct array *self
-			   , const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, (size_t) -1)
-	TEST_FOR_NULL_SR(item, (size_t) -1)
-	for ( size_t i = 0; i < self->size; ++i ) {
-		if ( void_pointer_equal(self->data[i], self->item_size
-								, item, self->item_size) ) {
-			return i;
-		}
-	}
-	toolbox_errno = RET_EIDNE;
-	return (size_t) -1;
-}
-
-_Bool
-array_contain(const struct array *self, const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, 0);
-	TEST_FOR_NULL_SR(item, 0);
-	for ( size_t i = 0; i < self->size; ++i ) {
-		if ( void_pointer_equal(self->data[i], self->item_size
-					, item, self->item_size) ) {
-			return true;
-		}
-	}
-	return false;
-}
-
-size_t
-array_count(const struct array *self, const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, (size_t) -1);
-	TEST_FOR_NULL_SR(item, (size_t) -1);
-	size_t count = 0;
-	for ( size_t i = 0; i < self->size; ++i ) {
-		if ( void_pointer_equal(self->data[i], self->item_size
-								, item, self->item_size) ) {
-			++count;
-		}
-	}
-	return count;
-}
-
-RET_TYPE
-array_set(struct array *self, const size_t p_index
-		  , const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(item);
-	if ( p_index >= self->size ) {
-		toolbox_errno = RET_EVBTS;
-		return toolbox_errno;
-	}
-	if ( self->data[p_index] != NULL ) {
-		free(self->data[p_index]);
-	}
-	self->data[p_index] = calloc(1, self->item_size);
-	memcpy(self->data[p_index], item, self->item_size);
-	return RET_OK;
-}
-
-RET_TYPE
-array_insert(struct array *self, const size_t p_index
-			 , const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(item);
-	if ( p_index > self->size+1 ) {
-		toolbox_errno = RET_EVBTS;
-		return toolbox_errno;
-	}
-	++self->size;
-	++self->alloc_size;
-	struct array *tmp = array_create(self->alloc_size, self->item_size);
-
-	tmp->data[p_index] = calloc(1, tmp->item_size);
-	memcpy(tmp->data[p_index], item, self->item_size);
-
-	size_t j = 0;
-	for ( size_t i = 0; i < p_index; ++i ) {
-		tmp->data[i] = self->data[j++];
-	}
-	for ( size_t i = p_index+1; i < self->size; ++i ) {
-		tmp->data[i] = self->data[j++];
-	}
-	free(self->data);
-
-	self->data = tmp->data;
-	return RET_OK;
-}
-
-RET_TYPE
-array_append(struct array *self, const void *item) {
-	for ( size_t i = 0; i < self->size; ++i ) {
-		if ( self->data[i] == NULL ) {
-			return array_set(self, i, item);
-		}
-	}
-	return array_insert(self, self->size, item);
-}
-
-RET_TYPE
-array_prepend(struct array *self, const void *item) {
-	return array_insert(self, 0, item);
-}
-
-RET_TYPE
-array_delete(struct array *self, const size_t p_index) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	if ( p_index >= self->size ) {
-		toolbox_errno = RET_EVBTS;
-		return toolbox_errno;
-	}
-	--self->size;
-	if ( p_index == self->size ) {
-		free(self->data[p_index]);
-		self->data[p_index] = NULL;
-		return RET_OK;
-	}
-	free(self->data[p_index]);
-	for ( size_t i = p_index; i < self->size; ++i ) {
-		self->data[i] = self->data[i + 1];
-	}
-	return RET_OK;
-}
-
-RET_TYPE
-array_remove(struct array *self, const void *item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(item);
-
-	for ( size_t z = 0; z < self->size; ++z ) {
-		if ( void_pointer_equal(self->data[z], self->item_size
-					, item, self->item_size) ) {
-			array_delete(self, z);
-			goto exit_found;
-		}
-	}
-
-	toolbox_errno = RET_EIDNE;
-	return RET_EIDNE;
-
-exit_found:
-	return RET_OK;
-}
-
-RET_TYPE
-array_for_each(struct array *self, void (*for_each)(void *item)) {
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(for_each);
-
-	for ( size_t i = 0; i < self->size; ++i ) {
-		for_each(self->data[i]);
-	}
-
-	return RET_OK;
-}
-
-#undef TEST_FOR_NULL_SR
-#undef TEST_FOR_NULL
-
-#undef false
-#undef true

src/toolbox/cstr_fixed.c

@@ -1,52 +0,0 @@
-#include "toolbox/cstr_fixed.h"
-
-#include <stddef.h>
-#include <string.h>
-
-#include "toolbox/cstring.h"
-#include "toolbox/errno.h"
-#include "toolbox/errcode.h"
-
-#define false 0
-#define true  1
-
-struct cstr_fixed
-cstr_fixed_from_cstring(const char *cstring) {
-	toolbox_errno = RET_OK;
-	struct cstr_fixed ret = {
-		.size = cstring_len(cstring),
-		.data = {0}
-	};
-
-	if ( ret.size > TOOLBOX_CSTR_FIXED_MAX_SIZE ) {
-		toolbox_errno = RET_EVBTS;
-		return ret;
-	}
-
-	memcpy(ret.data, cstring, ret.size);
-
-	return ret;
-}
-
-_Bool
-cstr_fixed_equal(const struct cstr_fixed cstr_fixed1
-		 , const struct cstr_fixed cstr_fixed2) {
-	if ( cstr_fixed1.size != cstr_fixed2.size ) {
-		return false;
-	}
-	for ( size_t i = 0; i < cstr_fixed1.size; ++i ) {
-		if ( cstr_fixed1.data[i] != cstr_fixed2.data[i] ) {
-			return false;
-		}
-	}
-	return true;
-}
-
-_Bool
-cstr_fixed_equal_cstring(const struct cstr_fixed cstr_fixed
-			 , const char *cstring) {
-	return cstr_fixed_equal(cstr_fixed, cstr_fixed_from_cstring(cstring));
-}
-
-#undef false
-#undef true

src/toolbox/errno.c

@@ -1,3 +0,0 @@
-#include "toolbox/errno.h"
-
-__thread RET_TYPE toolbox_errno;

src/toolbox/hashtable.c

@@ -1,469 +0,0 @@
-#include "toolbox/hashtable.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "toolbox/hash.h"
-#include "toolbox/cstring.h"
-#include "toolbox/log.h"
-#include "toolbox/errno.h"
-#include "toolbox/void_pointer.h"
-#include "toolbox/vptr.h"
-
-#define true ((unsigned char) 1L)
-#define false ((unsigned char) 0L)
-
-#define TEST_FOR_NULL(POINTER)						\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return toolbox_errno;					\
-	}
-
-#define TEST_FOR_NULL_SR(POINTER, RET)					\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return RET;						\
-	}
-
-struct hashtable_item {
-	struct {
-		size_t hash;
-		uint64_t true_hash;
-	} key;
-
-	struct vptr item;
-
-	struct hashtable_item *p_next;
-};
-
-#define HASHTABLE_SIZE \
-	(HASHTABLE_SIZE_BYTES / sizeof(struct hashtable_item))
-
-struct hashtable {
-	struct {
-		size_t size;
-		size_t data[HASHTABLE_SIZE];
-	} used_keys;
-
-	struct hashtable_item data[HASHTABLE_SIZE];
-};
-
-struct hashtable *
-hashtable_create(void) {
-	toolbox_errno = RET_OK;
-	struct hashtable *self = calloc(1, sizeof(struct hashtable));
-	if ( self == NULL ) {
-		toolbox_errno = RET_EFM;
-	}
-	return self;
-}
-
-RET_TYPE
-hashtable_destroy(struct hashtable **self) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(*self);
-
-	struct hashtable *ht = (*self);
-
-	for ( size_t i = 0; i < ht->used_keys.size; ++i ) {
-		if ( ht->data[ht->used_keys.data[i]].item.data == NULL )
-			continue;
-
-		free(ht->data[ht->used_keys.data[i]].item.data);
-	}
-	free(*self);
-	*self = NULL;
-	return RET_OK;
-}
-
-_Bool
-hashtable_contain_item(const struct hashtable *self
-		       , const void* p_item, const size_t p_item_size) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(p_item);
-	const struct hashtable_item *p_tmp = NULL;
-	for ( size_t i = 0; i < self->used_keys.size; ++i ) {
-		p_tmp = &self->data[self->used_keys.data[i]];
-		if ( void_pointer_equal(p_tmp->item.data, p_tmp->item.size
-					, p_item, p_item_size) ) {
-			return true;
-		}
-		while ( p_tmp->p_next != NULL ) {
-			p_tmp = p_tmp->p_next;
-			if ( void_pointer_equal(p_tmp->item.data, p_tmp->item.size
-						, p_item, p_item_size) ) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-_Bool
-hashtable_contain_key(const struct hashtable *self
-		      , const char *r_p_key) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(r_p_key);
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const struct hashtable_item *p_tmp
-		= &self->data[true_key_hash % HASHTABLE_SIZE];
-	if ( p_tmp->key.true_hash == true_key_hash ) {
-		return true;
-	}
-	return false;
-}
-
-_Bool
-hashtable_contain_key_hash(const struct hashtable *self
-			   , const size_t p_key_hash) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	if ( self->data[p_key_hash].key.hash == p_key_hash ) {
-		return true;
-	}
-	return false;
-}
-
-const void *
-hashtable_get(const struct hashtable *self
-	      , const char *r_p_key) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, NULL);
-	TEST_FOR_NULL_SR(r_p_key, NULL);
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const struct hashtable_item *p_tmp
-		= &self->data[true_key_hash % HASHTABLE_SIZE];
-	if ( p_tmp->key.true_hash == true_key_hash ) {
-		return p_tmp->item.data;
-	}
-	while ( p_tmp->p_next != NULL ) {
-		p_tmp = p_tmp->p_next;
-		if ( p_tmp->key.true_hash == true_key_hash ) {
-			return p_tmp->item.data;
-		}
-	}
-	toolbox_errno = RET_EIDNE;
-	return NULL;
-}
-
-const void *
-hashtable_get_or_default(const struct hashtable *self
-			 , const char *r_p_key
-			 , const void *p_default_item) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, NULL);
-	TEST_FOR_NULL_SR(r_p_key, NULL);
-	TEST_FOR_NULL_SR(p_default_item, NULL);
-
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const struct hashtable_item *p_tmp
-		= &self->data[true_key_hash % HASHTABLE_SIZE];
-
-	if ( p_tmp->key.true_hash == true_key_hash )
-		return p_tmp->item.data;
-
-	while ( p_tmp->p_next != NULL ) {
-		p_tmp = p_tmp->p_next;
-
-		if ( p_tmp->key.true_hash == true_key_hash )
-			return p_tmp->item.data;
-	}
-
-	return p_default_item;
-}
-
-_Bool
-hashtable_is_empty(const struct hashtable *self) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	return ( self->used_keys.size == 0 );
-}
-
-static RET_TYPE
-m_hashtable_put_helper(struct hashtable *self, struct hashtable_item *p_tmp
-		       , uint64_t true_key_hash, size_t key_hash
-		       , const void *r_p_item, size_t p_item_size) {
-	p_tmp->key.true_hash = true_key_hash;
-	p_tmp->key.hash = key_hash;
-	p_tmp->p_next = NULL;
-	p_tmp->item.size = p_item_size;
-	p_tmp->item.data = malloc(p_tmp->item.size);
-
-	if ( p_tmp->item.data == NULL ) {
-		self->used_keys.data[--self->used_keys.size] = 0;
-		p_tmp->key.true_hash = 0;
-		p_tmp->key.hash = 0;
-		p_tmp->item.size = 0;
-		toolbox_errno = RET_EFM;
-		return RET_EFM;
-	}
-
-	memcpy(p_tmp->item.data, r_p_item, p_tmp->item.size);
-	return RET_OK;
-}
-
-RET_TYPE
-hashtable_put(struct hashtable *self
-			  , const char *r_p_key
-			  , const void *r_p_item, const size_t p_item_size) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self)
-	TEST_FOR_NULL(r_p_key);
-	TEST_FOR_NULL(r_p_item);
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const size_t key_hash = true_key_hash % HASHTABLE_SIZE;
-	struct hashtable_item *p_tmp = &self->data[key_hash];
-
-	if ( p_tmp->key.true_hash == true_key_hash ) {
-		toolbox_errno = RET_EIAE;
-		return RET_EIAE;
-	}
-
-	if ( p_tmp->key.true_hash == 0 ) {
-		self->used_keys.data[self->used_keys.size++] = key_hash;
-		return m_hashtable_put_helper(self, p_tmp
-					      , true_key_hash, key_hash
-					      , r_p_item, p_item_size);
-	}
-
-	do {
-		p_tmp = p_tmp->p_next;
-	} while ( p_tmp != NULL );
-
-	p_tmp = malloc(sizeof(struct hashtable_item));
-
-	return m_hashtable_put_helper(self, p_tmp
-				      , true_key_hash, key_hash
-				      , r_p_item, p_item_size);
-
-	return RET_OK;
-}
-
-__attribute__((__nonnull__))
-inline static void
-m_remove_index_carray(size_t *restrict r_p_carray, size_t *restrict r_p_size
-					  , const size_t p_index) {
-	--(*r_p_size);
-	for ( size_t i = p_index; i < *r_p_size; ++i ) {
-		*(r_p_carray + i) = *(r_p_carray + i + 1);
-	}
-}
-
-__attribute__((__nonnull__))
-inline static void
-m_remove_item(struct hashtable *self
-	      , const size_t p_key_hash, const uint64_t p_true_key_hash) {
-	struct hashtable_item *p_tmp = &self->data[p_key_hash];
-	if ( p_tmp->key.true_hash == p_true_key_hash ) {
-		if ( p_tmp->p_next == NULL ) {
-			for ( size_t i = 0; i < self->used_keys.size; ++i ) {
-				if ( self->used_keys.data[i] == p_key_hash ) {
-					m_remove_index_carray(self->used_keys.data
-							      , &self->used_keys.size, i);
-				}
-			}
-			p_tmp->key.hash = 0;
-			p_tmp->key.true_hash = 0;
-			free(p_tmp->item.data);
-			p_tmp->item.data = NULL;
-			p_tmp->item.size = 0;
-			p_tmp->p_next = NULL;
-		}
-	} else {
-		while ( p_tmp->p_next != NULL ) {
-			if ( p_tmp->key.true_hash == p_true_key_hash ) {
-				break;
-			}
-			p_tmp = p_tmp->p_next;
-		}
-	}
-	free(p_tmp->item.data);
-	p_tmp = p_tmp->p_next;
-	//memcpy(p_tmp, p_tmp->p_next, sizeof(*p_tmp->p_next));
-}
-
-const void *
-hashtable_remove(struct hashtable *self, const char *r_p_key) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL_SR(self, NULL);
-	TEST_FOR_NULL_SR(r_p_key, NULL);
-
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const size_t key_hash = true_key_hash % HASHTABLE_SIZE;
-	const struct hashtable_item *p_tmp = &self->data[key_hash];
-
-	void *ret = NULL;
-	if ( p_tmp->key.true_hash == true_key_hash ) {
-		ret = malloc(p_tmp->item.size);
-		memcpy(ret, p_tmp->item.data, p_tmp->item.size);
-		m_remove_item(self, key_hash, true_key_hash);
-		goto exit;
-	}
-
-	while ( p_tmp->p_next != NULL ) {
-		if ( p_tmp->key.true_hash == true_key_hash ) {
-			ret = malloc(p_tmp->item.size);
-			memcpy(ret, p_tmp->item.data, p_tmp->item.size);
-			m_remove_item(self, key_hash, true_key_hash);
-		}
-	}
-
-exit:
-	return ret;
-}
-
-_Bool
-hashtable_remove_if_equal(struct hashtable *self
-			  , const char *r_p_key
-			  , const void *r_p_item, const size_t p_item_size) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(r_p_key);
-	TEST_FOR_NULL(r_p_item);
-
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	const size_t key_hash = true_key_hash % HASHTABLE_SIZE;
-	const struct hashtable_item *p_tmp = &self->data[key_hash];
-
-	if ( p_tmp->key.true_hash == true_key_hash
-		 && void_pointer_equal(p_tmp->item.data, p_tmp->item.size
-				       , r_p_item, p_item_size) ) {
-		m_remove_item(self, key_hash, true_key_hash);
-		return true;
-	}
-
-	while ( p_tmp->p_next != NULL ) {
-		if ( p_tmp->key.true_hash == true_key_hash
-		     && void_pointer_equal(p_tmp->item.data, p_tmp->item.size
-					   , r_p_item, p_item_size) ) {
-			m_remove_item(self, key_hash, true_key_hash);
-			return true;
-		}
-	}
-
-	return false;
-}
-
-const void *
-hashtable_replace(struct hashtable *self
-		  , const char *r_p_key
-		  , const void *r_p_item, const size_t p_item_size) {
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL_SR(self, NULL);
-	TEST_FOR_NULL_SR(r_p_key, NULL);
-	TEST_FOR_NULL_SR(r_p_item, NULL);
-
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	struct hashtable_item *p_tmp
-		= &self->data[true_key_hash % HASHTABLE_SIZE];
-	void *ret = NULL;
-
-	if ( p_tmp->key.true_hash != true_key_hash ) {
-		while ( p_tmp->p_next != NULL ) {
-			p_tmp = p_tmp->p_next;
-
-			if ( p_tmp->key.true_hash == true_key_hash )
-				break;
-		}
-	}
-
-	ret = malloc(p_tmp->item.size);
-	memcpy(ret, p_tmp->item.data, p_tmp->item.size);
-
-	if ( p_tmp->item.size == p_item_size ) {
-		memcpy(p_tmp->item.data, r_p_item, p_tmp->item.size);
-		goto exit;
-	}
-
-	free(p_tmp->item.data);
-	p_tmp->item.size = p_item_size;
-	p_tmp->item.data = malloc(p_tmp->item.size);
-	memcpy(p_tmp->item.data, r_p_item, p_tmp->item.size);
-
-exit:
-	return ret;
-}
-
-_Bool
-hashtable_replace_if_equal(struct hashtable *self
-			   , const char *r_p_key
-			   , const void *restrict r_p_old_item
-			   , const size_t p_old_item_size
-			   , const void *restrict r_p_new_item
-			   , const size_t p_new_item_size) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(r_p_key);
-	TEST_FOR_NULL(r_p_old_item);
-	TEST_FOR_NULL(r_p_new_item);
-
-	const uint64_t true_key_hash = hash_cstr(r_p_key);
-	struct hashtable_item *p_tmp
-		= &self->data[true_key_hash % HASHTABLE_SIZE];
-
-	if ( p_tmp->key.true_hash != true_key_hash ) {
-		while ( p_tmp->p_next != NULL ) {
-			p_tmp = p_tmp->p_next;
-
-			if ( p_tmp->key.true_hash == true_key_hash )
-				break;
-		}
-	}
-
-	if ( ! void_pointer_equal(p_tmp->item.data, p_tmp->item.size
-				  , r_p_old_item, p_old_item_size) ) {
-		return false;
-	}
-
-	if ( p_tmp->item.size == p_new_item_size ) {
-		memcpy(p_tmp->item.data, r_p_new_item, p_tmp->item.size);
-		goto exit_true;
-	}
-
-	free(p_tmp->item.data);
-	p_tmp->item.size = p_new_item_size;
-	p_tmp->item.data = malloc(p_tmp->item.size);
-	memcpy(p_tmp->item.data, r_p_new_item, p_tmp->item.size);
-
-exit_true:
-	return true;
-}
-
-size_t
-hashtable_used_size(const struct hashtable *self) {
-	toolbox_errno = RET_OK;
-	TEST_FOR_NULL(self);
-	return self->used_keys.size;
-}
-
-RET_TYPE
-hashtable_for_each(struct hashtable *self
-		   , void (*for_each)(void *item, size_t *item_size)) {
-	toolbox_errno = RET_OK;
-	for ( size_t i = 0; i < self->used_keys.size; ++i ) {
-		struct hashtable_item *tmp_it
-			= &self->data[self->used_keys.data[i]];
-
-		for_each(tmp_it->item.data, &tmp_it->item.size);
-
-		while ( tmp_it->p_next != NULL ) {
-			tmp_it = tmp_it->p_next;
-			for_each(tmp_it->item.data, &tmp_it->item.size);
-		}
-	}
-	return RET_OK;
-}
-
-#undef TEST_FOR_NULL_SR
-#undef TEST_FOR_NULL
-
-#undef false
-#undef true

src/toolbox/list/sll.c

@@ -1,172 +0,0 @@
-#include "toolbox/list/sll.h"
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-
-#include "toolbox/errcode.h"
-#include "toolbox/errno.h"
-#include "toolbox/log.h"
-
-#define TEST_FOR_NULL(POINTER)						\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return toolbox_errno;					\
-	}
-
-#define TEST_FOR_NULL_SR(POINTER, RET)					\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return RET;						\
-	}
-
-struct sll *
-sll_create(void) {
-	toolbox_errno = RET_OK;
-
-	struct sll *ret = malloc(sizeof(struct sll));
-	bzero(ret, sizeof(struct sll));
-
-	return ret;
-}
-
-static RET_TYPE
-m_sll_item_free(void *item, size_t item_size) {
-	(void) item_size;
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(item);
-
-	free(item);
-
-	return RET_OK;
-}
-
-RET_TYPE
-sll_destroy(struct sll **self) {
-	toolbox_errno = RET_OK;
-
-	sll_for_each(*self, m_sll_item_free);
-
-	free(*self);
-
-	*self = NULL;
-
-	return RET_OK;
-}
-
-RET_TYPE
-sll_insert(struct sll *restrict self
-	   , const void *restrict item, const size_t item_size
-	   , const size_t index) {
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(item);
-
-	size_t z = 0;
-	struct sll_item *tmp = NULL;
-	size_t tmp_index = index - 1;
-
-	if ( self->head == NULL )
-		self->head = malloc(sizeof(struct sll_item));
-
-	if ( self->size > index ) {
-		self->size = index;
-	} else {
-		++self->size;
-	}
-
-	tmp = self->head;
-	for ( z = 0; z < self->size; ++z ) {
-
-		if ( z == tmp_index ) {
-			tmp->item = malloc(item_size);
-			memcpy((void *) tmp->item, item, item_size);
-			memcpy((void *) tmp->size, &item_size, sizeof(size_t));
-			goto exit_ok;
-		}
-
-		if ( tmp->next == NULL )
-			tmp->next = malloc(sizeof(struct sll_item));
-
-		tmp = tmp->next;
-	}
-
-exit_ok:
-	return RET_OK;
-}
-
-RET_TYPE
-sll_append(struct sll *restrict self
-	   , const void *restrict item, const size_t item_size) {
-	struct sll_item *tmp = NULL;
-
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(self);
-	TEST_FOR_NULL(item);
-
-	if ( self->head == NULL )
-		self->head = malloc(sizeof(struct sll_item));
-
-	tmp = self->head;
-
-	while ( tmp->item != NULL && tmp->size != 0 )
-		tmp = tmp->next;
-
-	tmp->item = malloc(item_size);
-	memcpy((void *) tmp->item, item, item_size);
-	memcpy((void *) tmp->size, &item_size, sizeof(size_t));
-
-	return RET_OK;
-}
-
-struct vptr
-sll_remove(struct sll *self, const size_t index) {
-	struct sll_item *tmp = NULL;
-	struct vptr ret = {.data=NULL,.size=0};
-	size_t z = 0;
-
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL_SR(self, ret);
-
-	if ( index > self->size ) {
-		toolbox_errno = RET_EVBTS;
-		return ret;
-	}
-
-	tmp = self->head;
-	for ( z = 0; z < index - 1; ++z ) {
-		tmp = tmp->next;
-	}
-
-	ret.data = (void *) tmp->next->item;
-	ret.size = tmp->next->size;
-
-	tmp->next = tmp->next->next;
-
-	return ret;
-}
-
-struct vptr
-sll_get(struct sll *self, const size_t index);
-
-RET_TYPE
-sll_for_each(struct sll *self, RET_TYPE (*for_each)(void *, size_t)) {
-	struct sll_item *t = self->head;
-
-	do {
-		for_each(t->item, t->size);
-		t = t->next;
-	} while ( t != NULL );
-
-	return RET_OK;
-}
-
-#undef TEST_FOR_NULL_SR
-#undef TEST_FOR_NULL

src/toolbox/random.c

@@ -1,28 +0,0 @@
-#include "toolbox/random.h"
-
-#include <stdlib.h>
-#include <stdint.h>
-
-char rand_print_char(void) {
-	return (char) (33 + (rand() % (126 - 33)));
-}
-
-static int m_rand(int p_min, int p_max) {
-	return (p_max > p_min) * (p_min + (rand() % ((p_max + 1) - p_min)));
-}
-
-int8_t rand_int8(int8_t p_min, int8_t p_max) {
-	return (int8_t) m_rand(p_min, p_max);
-}
-
-int16_t rand_int16(int16_t p_min, int16_t p_max) {
-	return (int16_t) m_rand(p_min, p_max);
-}
-
-int32_t rand_int32(int32_t p_min, int32_t p_max) {
-	return (int32_t) m_rand(p_min, p_max);
-}
-
-int64_t rand_int64(int64_t p_min, int64_t p_max) {
-	return (int64_t) ((p_max > p_min) * (p_min + (rand() % (p_max - p_min))));
-}

src/toolbox/void_pointer.c

@@ -1,43 +0,0 @@
-#include "toolbox/void_pointer.h"
-
-#include <stddef.h>
-
-#include "toolbox/errno.h"
-#include "toolbox/log.h"
-
-#define true ((unsigned char) 1L)
-#define false ((unsigned char) 0L)
-
-#define DEREF(PTR, POS) (*(((unsigned char *) (PTR)) + POS))
-
-#define TEST_FOR_NULL(POINTER, RET)					\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return RET;						\
-	}
-
-_Bool
-void_pointer_equal(const void *restrict p_vptr1, const size_t p_vptr1_size
-		   , const void *restrict p_vptr2, const size_t p_vptr2_size) {
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(p_vptr1, false);
-	TEST_FOR_NULL(p_vptr2, false);
-
-	if ( p_vptr1_size != p_vptr2_size )
-		return false;
-
-	for ( size_t z = 0; z < p_vptr1_size; ++z ) {
-		if ( DEREF(p_vptr1, z) != DEREF(p_vptr2, z) )
-			return false;
-	}
-
-	return true;
-}
-
-#undef TEST_FOR_NULL
-#undef DEREF
-
-#undef false
-#undef true

src/toolbox/vptr.c

@@ -1,47 +0,0 @@
-#include "toolbox/vptr.h"
-
-#include "toolbox/errno.h"
-#include "toolbox/log.h"
-
-
-
-#define true ((unsigned char) 1L)
-#define false ((unsigned char) 0L)
-
-#define DEREF(PTR, POS) (*(((unsigned char *) (PTR)) + POS))
-
-#define TEST_FOR_NULL(POINTER, RET)					\
-	if ( POINTER == NULL ) {					\
-		LOG_ERROR("Null Pointer Not Expected");		\
-		toolbox_errno = RET_EVN;				\
-		return RET;						\
-	}
-
-_Bool
-vptr_equal(const struct vptr *restrict p_vptr1
-	   , const struct vptr *restrict p_vptr2) {
-	toolbox_errno = RET_OK;
-
-	TEST_FOR_NULL(p_vptr1, false);
-	TEST_FOR_NULL(p_vptr2, false);
-
-	TEST_FOR_NULL(p_vptr1->data, false);
-	TEST_FOR_NULL(p_vptr2->data, false);
-
-	if ( p_vptr1->size != p_vptr2->size )
-		return false;
-
-	for ( size_t z = 0; z < p_vptr1->size; ++z ) {
-		if ( DEREF(p_vptr1->data, z) != DEREF(p_vptr2->data, z) )
-			return false;
-	}
-
-	return true;
-
-}
-
-#undef TEST_FOR_NULL
-#undef DEREF
-
-#undef false
-#undef true