libcutils

← Back to log@ 1cc1a61

removed dependency on stdbool and stdint, bytearray reworked (if it should be stack allocated, vla's are a better choice anyways, added linked list header

AuthorKonata <konata@posteo.jp>
Date
Commit1cc1a61d6a5c70a43c5f7070e4d42e7dc71f952c
Parent0c9637b
13 files changed, 143 insertions(+), 147 deletions(-)
▾Minclude/cutils/byte_array.h
+5-14@ 1cc1a61@ master
@@ -3,34 +3,25 @@
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <cutils/common.h>
#define BYTEARRAY_DEFAULT_SIZE 4
#define BT_FIXED 1
#define BT_FREE_EL 2
#define BT_FREE_ARRAY 4
#define BT_FREE_STRUCT 8
typedef enum {b_false, b_true} bool_t;
typedef struct Bytearray
{
char* items;
size_t capacity;
size_t length;
size_t element_size;
short flags;
} Bytearray;
#define new_bytearray(element_size) bytearray_with_capacity(BYTEARRAY_DEFAULT_SIZE, element_size)
#define bytearray_with_capacity(capacity, element_size) new_bytearray_ext(capacity, element_size, NULL, NULL, BT_FREE_ARRAY | BT_FREE_STRUCT)
Bytearray* new_bytearray_ext(size_t capacity, size_t element_size, char* array_storage, Bytearray* struct_storage, short flags);
void delete_bytearray(Bytearray* bytearray);
void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv_items) (void*), void(*rmv_struct) (void*));
Bytearray* bytearray_with_capacity(size_t capacity, size_t element_size);
void delete_bytearray(Bytearray* bytearray, void(*rmv_el) (void*));
void* bytearray_at(const Bytearray* bytearray, size_t index);
#define bytearray_pop(bytearray) bytearray_pop_at(bytearray, bytearray->length-1)
void* bytearray_pop_at(Bytearray* bytearray, size_t index);
#define bytearray_pop(bytearray, retptr) bytearray_pop_at(bytearray, bytearray->length-1, retptr)
void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr);
#define bytearray_push(bytearray, item) bytearray_insert(bytearray, bytearray->length, item)
bool_t bytearray_insert(Bytearray* bytearray, size_t index, const void* item);
▾Ainclude/cutils/common.h
+11@ 1cc1a61@ master
@@ -0,0 +1,11 @@
#ifndef CUTILS_COMMON_H
#define CUTILS_COMMON_H
#include <stddef.h>
#ifndef SIZE_MAX
#define SIZE_MAX (size_t)-1;
#endif
typedef enum {b_false, b_true} bool_t;
#endif /* CUTILS_COMMON_H */
▾Minclude/cutils/cutils.h
+1@ 1cc1a61@ master
@@ -5,5 +5,6 @@
#include <cutils/dyn_string.h>
#include <cutils/misc.h>
#include <cutils/byte_array.h>
#include <cutils/linked-list.h>
#endif /* CUTILS_H */
▾Minclude/cutils/dyn_string.h
+6-5@ 1cc1a61@ master
@@ -2,10 +2,10 @@
#define DYN_STRING_H
#define STRING_DEFAULT_SIZE 8
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <cutils/common.h>
typedef struct String
{
@@ -22,15 +22,16 @@ char string_at(const String* string, size_t index);
#define string_pop(string) string_pop_at(string, string->length-1)
char string_pop_at(String* string, size_t index);
bool string_insert(String* string, size_t index, char character);
bool_t string_insert(String* string, size_t index, char character);
#define string_push(string, character) string_insert(string, string->length, character)
void string_remove(String* string, size_t index);
void string_remove_range(String* string, size_t index, size_t length);
bool string_adjust_size(String* string, size_t size);
bool_t string_adjust_size(String* string, size_t size);
size_t* string_find_char(const String* haystack, const char needle);
bool string_concat(String* string, const String* other);
bool_t string_concat(String* string, const String* other);
String* from_cstring(const char* cstring);
String* from_cstring_del(char* cstring);
char* to_cstring(const String* string);
▾Ainclude/cutils/linked-list.h
+41@ 1cc1a61@ master
@@ -0,0 +1,41 @@
#ifndef LINKED_LIST_H
#define LINKED_LIST_H
typedef struct SLnode
{
void* item;
struct SLnode* next;
} SLnode;
typedef struct DLnode
{
void* item;
struct DLnode* next;
struct DLnode* prev;
} DLnode;
typedef struct LinkedList
{
void* head;
void* tail;
size_t length;
bool_t doubly_linked;
} LinkedList;
LinkedList* new_ll(bool_t doubly_linked);
void delete_ll(LinkedList* ll, void(*rmv) (void*));
void* ll_at(const LinkedList* ll, size_t index);
#define ll_pop(ll) ll_pop_at(ll, ll->length-1)
void* ll_pop_at(LinkedList* ll, size_t index);
bool_t ll_insert(LinkedList* ll, size_t index, void* item);
#define ll_push(ll, item) ll_insert(ll, ll->length, item)
void ll_remove(LinkedList* ll, size_t index, void (*rmv)(void*));
void ll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*));
size_t* ll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*));
#endif /* LINKED_LIST_H */
▾Minclude/cutils/misc.h
+2-2@ 1cc1a61@ master
@@ -14,11 +14,12 @@
#include <windows.h>
#endif
#include <stdint.h>
#include <string.h>
#if __STDC_VERSION__ >= 199901L
#include <stdint.h>
typedef uintmax_t max_uint_t;
uint32_t ntoh32(uint32_t const net);
#else
typedef unsigned long max_uint_t;
#endif
@@ -29,7 +30,6 @@
#endif
void sleep_ms(unsigned int milliseconds);
uint32_t ntoh32(uint32_t const net);
#if __STDC_VERSION__ >= 201112L
struct timespec timespec_diff(const struct timespec* old_ts, const struct timespec* new_ts);
▾Minclude/cutils/vector.h
+6-5@ 1cc1a61@ master
@@ -2,10 +2,10 @@
#define VECTOR_H
#define VECTOR_DEFAULT_SIZE 4
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <cutils/common.h>
typedef struct Vector
{
@@ -22,13 +22,14 @@ void* vector_at(const Vector* vector, size_t index);
#define vector_pop(vector) vector_pop_at(vector, vector->length-1)
void* vector_pop_at(Vector* vector, size_t index);
bool vector_insert(Vector* vector, size_t index, void* item);
bool_t vector_insert(Vector* vector, size_t index, void* item);
#define vector_push(vector, item) vector_insert(vector, vector->length, item)
void vector_remove(Vector* vector, size_t index, void (*rmv)(void*));
void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*));
bool vector_adjust_size(Vector* vector, size_t size);
bool vector_shrink(Vector* vector);
bool_t vector_adjust_size(Vector* vector, size_t size);
bool_t vector_shrink(Vector* vector);
size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const void*, const void*));
▾Mmeson.build
+1-1@ 1cc1a61@ master
@@ -1,7 +1,7 @@
project('cutils', 'c')
WARNINGS = ['-Wall', '-Wpedantic', '-Wextra', '-Wnull-dereference', '-Wshadow', '-Wconversion', '-Wstrict-prototypes', '-Wmissing-prototypes', '-Wcast-qual', '-Wstrict-overflow=5', '-Wunreachable-code', '-Wno-unused-parameter']
CFLAGS = ['-std=c11', '-fstrict-aliasing', '-fPIC'] + WARNINGS
CFLAGS = ['-std=c89', '-fstrict-aliasing', '-fPIC'] + WARNINGS
subdir('include')
subdir('src')
▾Msrc/byte_array.c
+19-55@ 1cc1a61@ master
@@ -1,47 +1,29 @@
#include <cutils/byte_array.h>
Bytearray* new_bytearray_ext(size_t capacity, size_t element_size, char* array_storage, Bytearray* struct_storage, short flags)
Bytearray* bytearray_with_capacity(size_t capacity, size_t element_size)
{
Bytearray* bytearray;
if(struct_storage)
{
bytearray = struct_storage;
} else {
bytearray = malloc(sizeof(*bytearray));
if(!bytearray)
return NULL;
}
bytearray = malloc(sizeof(*bytearray));
if(!bytearray)
return NULL;
if(array_storage)
bytearray->items = malloc(sizeof(*bytearray->items)*capacity*element_size);
if(!bytearray->items)
{
bytearray->items = array_storage;
} else {
bytearray->items = malloc(sizeof(*bytearray->items)*capacity*element_size);
if(!bytearray->items)
{
free(bytearray);
return NULL;
}
free(bytearray);
return NULL;
}
bytearray->length = 0;
bytearray->capacity = capacity;
bytearray->element_size = element_size;
bytearray->flags = flags;
return bytearray;
}
void delete_bytearray(Bytearray* bytearray)
{
delete_bytearray_ext(bytearray,
(bytearray->flags & BT_FREE_EL) ? free : NULL,
(bytearray->flags & BT_FREE_ARRAY) ? free : NULL,
(bytearray->flags & BT_FREE_STRUCT) ? free : NULL);
}
void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv_items) (void*), void(*rmv_struct) (void*))
void delete_bytearray(Bytearray* bytearray, void(*rmv_el) (void*))
{
if(rmv_el)
{
@@ -51,10 +33,9 @@ void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv
rmv_el(&bytearray->items[i*bytearray->element_size]);
}
}
if(rmv_items)
rmv_items(bytearray->items);
if(rmv_struct)
rmv_struct(bytearray);
free(bytearray->items);
free(bytearray);
}
void* bytearray_at(const Bytearray* bytearray, size_t index)
@@ -65,27 +46,21 @@ void* bytearray_at(const Bytearray* bytearray, size_t index)
return bytearray->items+(index*bytearray->element_size);
}
void* bytearray_pop_at(Bytearray* bytearray, size_t index)
void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr)
{
void *tmp, *ret;
void *tmp;
tmp = bytearray_at(bytearray, index);
if(!tmp)
{
errno = 0;
return NULL;
}
ret = malloc(bytearray->element_size);
if(!ret)
{
errno = ENOMEM;
retptr = retptr ? retptr : malloc(bytearray->element_size);
if(!retptr)
return NULL;
}
memcpy(ret, tmp, bytearray->element_size);
memcpy(retptr, tmp, bytearray->element_size);
bytearray_remove(bytearray, index, NULL);
return ret;
return retptr;
}
bool_t bytearray_insert(Bytearray* bytearray, size_t index, const void* item)
@@ -118,14 +93,6 @@ void bytearray_remove(Bytearray* bytearray, size_t index, void (*rmv)(void*))
bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
{
if(bytearray->flags & BT_FIXED)
{
if(bytearray->capacity < size)
return b_false;
else
return b_true;
}
while(bytearray->capacity < size)
{
size_t capacity = bytearray->capacity;
@@ -144,9 +111,6 @@ bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
bool_t bytearray_shrink(Bytearray* bytearray)
{
if(bytearray->flags & BT_FIXED)
return b_false;
while(bytearray->capacity > bytearray->length*2)
{
size_t capacity = bytearray->capacity;
▾Msrc/dyn_string.c
+18-9@ 1cc1a61@ master
@@ -26,15 +26,24 @@ void string_remove(String* string, size_t index)
}
}
bool string_insert(String* string, size_t index, char character)
void string_remove_range(String* string, size_t index, size_t length)
{
size_t i;
for(i = 0; i < length; i++)
{
string_remove(string, index+i);
}
}
bool_t string_insert(String* string, size_t index, char character)
{
if(index > string->length || !string_adjust_size(string, string->length))
return false;
return b_false;
memmove(string->chars+index+1, string->chars+index, (string->length-index)*sizeof(*string->chars));
string->chars[index] = character;
string->length++;
return true;
return b_true;
}
char string_at(const String* string, size_t index)
@@ -57,13 +66,13 @@ char string_pop_at(String* string, size_t index)
}
}
bool string_concat(String* string, const String* other)
bool_t string_concat(String* string, const String* other)
{
if(!string_adjust_size(string,string->length+other->length-1))
return false;
return b_false;
memcpy(string->chars+string->length,other->chars,other->length);
string->length += other->length;
return true;
return b_true;
}
size_t* string_find_char(const String* haystack, const char needle)
@@ -82,7 +91,7 @@ size_t* string_find_char(const String* haystack, const char needle)
return NULL;
}
bool string_adjust_size(String* string, size_t size)
bool_t string_adjust_size(String* string, size_t size)
{
while(string->capacity < size)
{
@@ -91,11 +100,11 @@ bool string_adjust_size(String* string, size_t size)
if(!string->chars)
{
string->chars = tmp;
return false;
return b_false;
}
string->capacity *= 2;
}
return true;
return b_true;
}
▾Msrc/misc.c
+2@ 1cc1a61@ master
@@ -10,6 +10,7 @@ void sleep_ms(unsigned int milliseconds)
#endif
}
#if __STDC_VERSION__ >= 199901L
uint32_t ntoh32(uint32_t const net)
{
uint8_t data[4];
@@ -20,6 +21,7 @@ uint32_t ntoh32(uint32_t const net)
| ((uint32_t) data[1] << 16)
| ((uint32_t) data[0] << 24);
}
#endif
#if __STDC_VERSION__ >= 201112L
struct timespec timespec_diff(const struct timespec* old_ts, const struct timespec* new_ts)
▾Msrc/test.c
+13-47@ 1cc1a61@ master
@@ -108,12 +108,8 @@ static void test2(void)
static void test3(void)
{
Bytearray* bt;
void* localarray;
struct test my_struct;
struct test* my_structptr;
char* tmpchar;
/*test pushing and popping with default constructor and simple values*/
bt = new_bytearray(1);
bytearray_push(bt, "a");
bytearray_push(bt, "b");
@@ -123,70 +119,37 @@ static void test3(void)
assert(strcmp(bt->items, "abcd") == 0);
tmpchar = bytearray_pop(bt);
tmpchar = bytearray_pop(bt, NULL);
assert(*tmpchar == '\0');
free(tmpchar);
tmpchar = bytearray_pop(bt);
tmpchar = bytearray_pop(bt, NULL);
assert(*tmpchar == 'd');
free(tmpchar);
tmpchar = bytearray_pop(bt);
tmpchar = bytearray_pop(bt, NULL);
assert(*tmpchar == 'c');
free(tmpchar);
tmpchar = bytearray_pop(bt);
tmpchar = malloc(1);
bytearray_pop(bt, tmpchar);
assert(*tmpchar == 'b');
free(tmpchar);
tmpchar = bytearray_pop(bt);
bytearray_pop(bt, tmpchar);
assert(*tmpchar == 'a');
free(tmpchar);
tmpchar = bytearray_pop(bt);
tmpchar = bytearray_pop(bt, NULL);
assert(tmpchar == NULL);
free(tmpchar);
bytearray_push(bt, "a");
tmpchar = bytearray_pop(bt);
tmpchar = bytearray_pop(bt, NULL);
assert(*tmpchar == 'a');
free(tmpchar);
delete_bytearray(bt);
/*test pushing and popping with self allocated array and fixed size*/
localarray = malloc(3*sizeof(struct test));
my_struct.a = 0;
my_struct.b = 0;
bt = new_bytearray_ext(3, sizeof(struct test), localarray, NULL, BT_FREE_ARRAY | BT_FIXED | BT_FREE_STRUCT);
bytearray_push(bt, &my_struct);
my_struct.a = 1;
my_struct.b = 1;
bytearray_push(bt, &my_struct);
my_struct.a = 2;
my_struct.b = 2;
bytearray_push(bt, &my_struct);
my_struct.a = 3;
my_struct.b = 3;
bytearray_push(bt, &my_struct);
my_structptr = bytearray_pop(bt);
my_struct.a = 2;
my_struct.b = 2;
assert(my_structptr->a == my_struct.a);
assert(my_structptr->b == my_struct.b);
free(my_structptr);
delete_bytearray(bt);
delete_bytearray(bt, NULL);
}
#if __STDC_VERSION__ >= 201112L
static void test4(void)
{
struct timespec ts1 = {10, 10};
@@ -236,13 +199,16 @@ static void test4(void)
res = timespec_diff(&ts1, &ts2);
assert(res.tv_sec == 10 && res.tv_nsec == 999999998);
}
#endif
int main(int argc, char** argv)
{
test1();
test2();
test3();
#if __STDC_VERSION__ >= 201112L
test4();
#endif
sleep_ms(1000);
return 0;
}
▾Msrc/vector.c
+18-9@ 1cc1a61@ master
@@ -49,6 +49,15 @@ void vector_remove(Vector* vector, size_t index, void (*rmv)(void*))
}
}
void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*))
{
size_t i;
for(i = 0; i < length; i++)
{
vector_remove(vector, index+i, rmv);
}
}
size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const void*, const void*))
{
size_t* ret;
@@ -66,18 +75,18 @@ size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const
return NULL;
}
bool vector_insert(Vector* vector, size_t index, void* item)
bool_t vector_insert(Vector* vector, size_t index, void* item)
{
if(index > vector->length || !vector_adjust_size(vector, vector->length+1))
return false;
return b_false;
memmove(vector->items+index+1, vector->items+index, (vector->length-index)*sizeof(*vector->items));
vector->items[index] = item;
++vector->length;
return true;
return b_true;
}
bool vector_adjust_size(Vector* vector, size_t size)
bool_t vector_adjust_size(Vector* vector, size_t size)
{
while(vector->capacity < size)
{
@@ -86,14 +95,14 @@ bool vector_adjust_size(Vector* vector, size_t size)
if(!vector->items)
{
vector->items = tmp;
return false;
return b_false;
}
vector->capacity *= 2;
}
return true;
return b_true;
}
bool vector_shrink(Vector* vector)
bool_t vector_shrink(Vector* vector)
{
while(vector->capacity > (vector->length*2))
{
@@ -102,11 +111,11 @@ bool vector_shrink(Vector* vector)
if(!vector->items)
{
vector->items = tmp;
return false;
return b_false;
}
vector->capacity /= 2;
}
return true;
return b_true;
}
void delete_vector(Vector* vector, void (*rmv)(void*))