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 @@
33 #include <stdlib.h>
44 #include <string.h>
55 #include <errno.h>
6+#include <cutils/common.h>
67
78 #define BYTEARRAY_DEFAULT_SIZE 4
89
9-#define BT_FIXED 1
10-#define BT_FREE_EL 2
11-#define BT_FREE_ARRAY 4
12-#define BT_FREE_STRUCT 8
13-
14-typedef enum {b_false, b_true} bool_t;
15-
1610 typedef struct Bytearray
1711 {
1812 char* items;
1913 size_t capacity;
2014 size_t length;
2115 size_t element_size;
22- short flags;
2316 } Bytearray;
2417
2518 #define new_bytearray(element_size) bytearray_with_capacity(BYTEARRAY_DEFAULT_SIZE, element_size)
26-#define bytearray_with_capacity(capacity, element_size) new_bytearray_ext(capacity, element_size, NULL, NULL, BT_FREE_ARRAY | BT_FREE_STRUCT)
27-Bytearray* new_bytearray_ext(size_t capacity, size_t element_size, char* array_storage, Bytearray* struct_storage, short flags);
28-void delete_bytearray(Bytearray* bytearray);
29-void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv_items) (void*), void(*rmv_struct) (void*));
19+Bytearray* bytearray_with_capacity(size_t capacity, size_t element_size);
20+void delete_bytearray(Bytearray* bytearray, void(*rmv_el) (void*));
3021
3122 void* bytearray_at(const Bytearray* bytearray, size_t index);
32-#define bytearray_pop(bytearray) bytearray_pop_at(bytearray, bytearray->length-1)
33-void* bytearray_pop_at(Bytearray* bytearray, size_t index);
23+#define bytearray_pop(bytearray, retptr) bytearray_pop_at(bytearray, bytearray->length-1, retptr)
24+void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr);
3425
3526 #define bytearray_push(bytearray, item) bytearray_insert(bytearray, bytearray->length, item)
3627 bool_t bytearray_insert(Bytearray* bytearray, size_t index, const void* item);
▾Ainclude/cutils/common.h
+11@ 1cc1a61@ master
@@ -0,0 +1,11 @@
1+#ifndef CUTILS_COMMON_H
2+#define CUTILS_COMMON_H
3+
4+#include <stddef.h>
5+#ifndef SIZE_MAX
6+ #define SIZE_MAX (size_t)-1;
7+#endif
8+typedef enum {b_false, b_true} bool_t;
9+
10+
11+#endif /* CUTILS_COMMON_H */
▾Minclude/cutils/cutils.h
+1@ 1cc1a61@ master
@@ -5,5 +5,6 @@
55 #include <cutils/dyn_string.h>
66 #include <cutils/misc.h>
77 #include <cutils/byte_array.h>
8+#include <cutils/linked-list.h>
89
910 #endif /* CUTILS_H */
▾Minclude/cutils/dyn_string.h
+6-5@ 1cc1a61@ master
@@ -2,10 +2,10 @@
22 #define DYN_STRING_H
33
44 #define STRING_DEFAULT_SIZE 8
5-#include <stdint.h>
5+
66 #include <stdlib.h>
77 #include <string.h>
8-#include <stdbool.h>
8+#include <cutils/common.h>
99
1010 typedef struct String
1111 {
@@ -22,15 +22,16 @@ char string_at(const String* string, size_t index);
2222 #define string_pop(string) string_pop_at(string, string->length-1)
2323 char string_pop_at(String* string, size_t index);
2424
25-bool string_insert(String* string, size_t index, char character);
25+bool_t string_insert(String* string, size_t index, char character);
2626 #define string_push(string, character) string_insert(string, string->length, character)
2727
2828 void string_remove(String* string, size_t index);
29+void string_remove_range(String* string, size_t index, size_t length);
2930
30-bool string_adjust_size(String* string, size_t size);
31+bool_t string_adjust_size(String* string, size_t size);
3132 size_t* string_find_char(const String* haystack, const char needle);
3233
33-bool string_concat(String* string, const String* other);
34+bool_t string_concat(String* string, const String* other);
3435 String* from_cstring(const char* cstring);
3536 String* from_cstring_del(char* cstring);
3637 char* to_cstring(const String* string);
▾Ainclude/cutils/linked-list.h
+41@ 1cc1a61@ master
@@ -0,0 +1,41 @@
1+#ifndef LINKED_LIST_H
2+#define LINKED_LIST_H
3+
4+typedef struct SLnode
5+{
6+ void* item;
7+ struct SLnode* next;
8+} SLnode;
9+
10+typedef struct DLnode
11+{
12+ void* item;
13+ struct DLnode* next;
14+ struct DLnode* prev;
15+} DLnode;
16+
17+typedef struct LinkedList
18+{
19+ void* head;
20+ void* tail;
21+ size_t length;
22+ bool_t doubly_linked;
23+} LinkedList;
24+
25+LinkedList* new_ll(bool_t doubly_linked);
26+void delete_ll(LinkedList* ll, void(*rmv) (void*));
27+
28+void* ll_at(const LinkedList* ll, size_t index);
29+#define ll_pop(ll) ll_pop_at(ll, ll->length-1)
30+void* ll_pop_at(LinkedList* ll, size_t index);
31+
32+bool_t ll_insert(LinkedList* ll, size_t index, void* item);
33+#define ll_push(ll, item) ll_insert(ll, ll->length, item)
34+
35+void ll_remove(LinkedList* ll, size_t index, void (*rmv)(void*));
36+void ll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*));
37+
38+size_t* ll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*));
39+
40+
41+#endif /* LINKED_LIST_H */
▾Minclude/cutils/misc.h
+2-2@ 1cc1a61@ master
@@ -14,11 +14,12 @@
1414 #include <windows.h>
1515 #endif
1616
17-#include <stdint.h>
1817 #include <string.h>
1918
2019 #if __STDC_VERSION__ >= 199901L
20+ #include <stdint.h>
2121 typedef uintmax_t max_uint_t;
22+ uint32_t ntoh32(uint32_t const net);
2223 #else
2324 typedef unsigned long max_uint_t;
2425 #endif
@@ -29,7 +30,6 @@
2930 #endif
3031
3132 void sleep_ms(unsigned int milliseconds);
32-uint32_t ntoh32(uint32_t const net);
3333
3434 #if __STDC_VERSION__ >= 201112L
3535 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 @@
22 #define VECTOR_H
33
44 #define VECTOR_DEFAULT_SIZE 4
5-#include <stdint.h>
5+
66 #include <stdlib.h>
77 #include <string.h>
8-#include <stdbool.h>
8+#include <cutils/common.h>
99
1010 typedef struct Vector
1111 {
@@ -22,13 +22,14 @@ void* vector_at(const Vector* vector, size_t index);
2222 #define vector_pop(vector) vector_pop_at(vector, vector->length-1)
2323 void* vector_pop_at(Vector* vector, size_t index);
2424
25-bool vector_insert(Vector* vector, size_t index, void* item);
25+bool_t vector_insert(Vector* vector, size_t index, void* item);
2626 #define vector_push(vector, item) vector_insert(vector, vector->length, item)
2727
2828 void vector_remove(Vector* vector, size_t index, void (*rmv)(void*));
29+void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*));
2930
30-bool vector_adjust_size(Vector* vector, size_t size);
31-bool vector_shrink(Vector* vector);
31+bool_t vector_adjust_size(Vector* vector, size_t size);
32+bool_t vector_shrink(Vector* vector);
3233 size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const void*, const void*));
3334
3435
▾Mmeson.build
+1-1@ 1cc1a61@ master
@@ -1,7 +1,7 @@
11 project('cutils', 'c')
22
33 WARNINGS = ['-Wall', '-Wpedantic', '-Wextra', '-Wnull-dereference', '-Wshadow', '-Wconversion', '-Wstrict-prototypes', '-Wmissing-prototypes', '-Wcast-qual', '-Wstrict-overflow=5', '-Wunreachable-code', '-Wno-unused-parameter']
4-CFLAGS = ['-std=c11', '-fstrict-aliasing', '-fPIC'] + WARNINGS
4+CFLAGS = ['-std=c89', '-fstrict-aliasing', '-fPIC'] + WARNINGS
55
66 subdir('include')
77 subdir('src')
▾Msrc/byte_array.c
+19-55@ 1cc1a61@ master
@@ -1,47 +1,29 @@
11 #include <cutils/byte_array.h>
22
3-Bytearray* new_bytearray_ext(size_t capacity, size_t element_size, char* array_storage, Bytearray* struct_storage, short flags)
3+Bytearray* bytearray_with_capacity(size_t capacity, size_t element_size)
44 {
55 Bytearray* bytearray;
66
7- if(struct_storage)
8- {
9- bytearray = struct_storage;
10- } else {
11- bytearray = malloc(sizeof(*bytearray));
12- if(!bytearray)
13- return NULL;
14- }
7+ bytearray = malloc(sizeof(*bytearray));
8+ if(!bytearray)
9+ return NULL;
1510
16- if(array_storage)
11+ bytearray->items = malloc(sizeof(*bytearray->items)*capacity*element_size);
12+ if(!bytearray->items)
1713 {
18- bytearray->items = array_storage;
19- } else {
20- bytearray->items = malloc(sizeof(*bytearray->items)*capacity*element_size);
21- if(!bytearray->items)
22- {
23- free(bytearray);
24- return NULL;
25- }
14+ free(bytearray);
15+ return NULL;
2616 }
17+
2718 bytearray->length = 0;
2819 bytearray->capacity = capacity;
2920 bytearray->element_size = element_size;
30- bytearray->flags = flags;
3121
3222 return bytearray;
3323 }
3424
35-void delete_bytearray(Bytearray* bytearray)
36-{
37- delete_bytearray_ext(bytearray,
38- (bytearray->flags & BT_FREE_EL) ? free : NULL,
39- (bytearray->flags & BT_FREE_ARRAY) ? free : NULL,
40- (bytearray->flags & BT_FREE_STRUCT) ? free : NULL);
41-}
42-
4325
44-void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv_items) (void*), void(*rmv_struct) (void*))
26+void delete_bytearray(Bytearray* bytearray, void(*rmv_el) (void*))
4527 {
4628 if(rmv_el)
4729 {
@@ -51,10 +33,9 @@ void delete_bytearray_ext(Bytearray* bytearray, void(*rmv_el) (void*), void(*rmv
5133 rmv_el(&bytearray->items[i*bytearray->element_size]);
5234 }
5335 }
54- if(rmv_items)
55- rmv_items(bytearray->items);
56- if(rmv_struct)
57- rmv_struct(bytearray);
36+
37+ free(bytearray->items);
38+ free(bytearray);
5839 }
5940
6041 void* bytearray_at(const Bytearray* bytearray, size_t index)
@@ -65,27 +46,21 @@ void* bytearray_at(const Bytearray* bytearray, size_t index)
6546 return bytearray->items+(index*bytearray->element_size);
6647 }
6748
68-void* bytearray_pop_at(Bytearray* bytearray, size_t index)
49+void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr)
6950 {
70- void *tmp, *ret;
51+ void *tmp;
7152
7253 tmp = bytearray_at(bytearray, index);
7354 if(!tmp)
74- {
75- errno = 0;
7655 return NULL;
77- }
7856
79- ret = malloc(bytearray->element_size);
80- if(!ret)
81- {
82- errno = ENOMEM;
57+ retptr = retptr ? retptr : malloc(bytearray->element_size);
58+ if(!retptr)
8359 return NULL;
84- }
8560
86- memcpy(ret, tmp, bytearray->element_size);
61+ memcpy(retptr, tmp, bytearray->element_size);
8762 bytearray_remove(bytearray, index, NULL);
88- return ret;
63+ return retptr;
8964 }
9065
9166 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*))
11893
11994 bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
12095 {
121- if(bytearray->flags & BT_FIXED)
122- {
123- if(bytearray->capacity < size)
124- return b_false;
125- else
126- return b_true;
127- }
128-
12996 while(bytearray->capacity < size)
13097 {
13198 size_t capacity = bytearray->capacity;
@@ -144,9 +111,6 @@ bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
144111
145112 bool_t bytearray_shrink(Bytearray* bytearray)
146113 {
147- if(bytearray->flags & BT_FIXED)
148- return b_false;
149-
150114 while(bytearray->capacity > bytearray->length*2)
151115 {
152116 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)
2626 }
2727 }
2828
29-bool string_insert(String* string, size_t index, char character)
29+void string_remove_range(String* string, size_t index, size_t length)
30+{
31+ size_t i;
32+ for(i = 0; i < length; i++)
33+ {
34+ string_remove(string, index+i);
35+ }
36+}
37+
38+bool_t string_insert(String* string, size_t index, char character)
3039 {
3140 if(index > string->length || !string_adjust_size(string, string->length))
32- return false;
41+ return b_false;
3342
3443 memmove(string->chars+index+1, string->chars+index, (string->length-index)*sizeof(*string->chars));
3544 string->chars[index] = character;
3645 string->length++;
37- return true;
46+ return b_true;
3847 }
3948
4049 char string_at(const String* string, size_t index)
@@ -57,13 +66,13 @@ char string_pop_at(String* string, size_t index)
5766 }
5867 }
5968
60-bool string_concat(String* string, const String* other)
69+bool_t string_concat(String* string, const String* other)
6170 {
6271 if(!string_adjust_size(string,string->length+other->length-1))
63- return false;
72+ return b_false;
6473 memcpy(string->chars+string->length,other->chars,other->length);
6574 string->length += other->length;
66- return true;
75+ return b_true;
6776 }
6877
6978 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)
8291 return NULL;
8392 }
8493
85-bool string_adjust_size(String* string, size_t size)
94+bool_t string_adjust_size(String* string, size_t size)
8695 {
8796 while(string->capacity < size)
8897 {
@@ -91,11 +100,11 @@ bool string_adjust_size(String* string, size_t size)
91100 if(!string->chars)
92101 {
93102 string->chars = tmp;
94- return false;
103+ return b_false;
95104 }
96105 string->capacity *= 2;
97106 }
98- return true;
107+ return b_true;
99108 }
100109
101110
▾Msrc/misc.c
+2@ 1cc1a61@ master
@@ -10,6 +10,7 @@ void sleep_ms(unsigned int milliseconds)
1010 #endif
1111 }
1212
13+#if __STDC_VERSION__ >= 199901L
1314 uint32_t ntoh32(uint32_t const net)
1415 {
1516 uint8_t data[4];
@@ -20,6 +21,7 @@ uint32_t ntoh32(uint32_t const net)
2021 | ((uint32_t) data[1] << 16)
2122 | ((uint32_t) data[0] << 24);
2223 }
24+#endif
2325
2426 #if __STDC_VERSION__ >= 201112L
2527 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)
108108 static void test3(void)
109109 {
110110 Bytearray* bt;
111- void* localarray;
112- struct test my_struct;
113- struct test* my_structptr;
114111 char* tmpchar;
115112
116- /*test pushing and popping with default constructor and simple values*/
117113 bt = new_bytearray(1);
118114 bytearray_push(bt, "a");
119115 bytearray_push(bt, "b");
@@ -123,70 +119,37 @@ static void test3(void)
123119
124120 assert(strcmp(bt->items, "abcd") == 0);
125121
126- tmpchar = bytearray_pop(bt);
122+ tmpchar = bytearray_pop(bt, NULL);
127123 assert(*tmpchar == '\0');
128124 free(tmpchar);
129125
130- tmpchar = bytearray_pop(bt);
126+ tmpchar = bytearray_pop(bt, NULL);
131127 assert(*tmpchar == 'd');
132128 free(tmpchar);
133129
134- tmpchar = bytearray_pop(bt);
130+ tmpchar = bytearray_pop(bt, NULL);
135131 assert(*tmpchar == 'c');
136132 free(tmpchar);
137133
138- tmpchar = bytearray_pop(bt);
134+ tmpchar = malloc(1);
135+ bytearray_pop(bt, tmpchar);
139136 assert(*tmpchar == 'b');
140- free(tmpchar);
141137
142- tmpchar = bytearray_pop(bt);
138+ bytearray_pop(bt, tmpchar);
143139 assert(*tmpchar == 'a');
144140 free(tmpchar);
145141
146- tmpchar = bytearray_pop(bt);
142+ tmpchar = bytearray_pop(bt, NULL);
147143 assert(tmpchar == NULL);
148- free(tmpchar);
149144
150145 bytearray_push(bt, "a");
151- tmpchar = bytearray_pop(bt);
146+ tmpchar = bytearray_pop(bt, NULL);
152147 assert(*tmpchar == 'a');
153148 free(tmpchar);
154149
155- delete_bytearray(bt);
156-
157- /*test pushing and popping with self allocated array and fixed size*/
158- localarray = malloc(3*sizeof(struct test));
159- my_struct.a = 0;
160- my_struct.b = 0;
161-
162- bt = new_bytearray_ext(3, sizeof(struct test), localarray, NULL, BT_FREE_ARRAY | BT_FIXED | BT_FREE_STRUCT);
163- bytearray_push(bt, &my_struct);
164- my_struct.a = 1;
165- my_struct.b = 1;
166- bytearray_push(bt, &my_struct);
167-
168- my_struct.a = 2;
169- my_struct.b = 2;
170- bytearray_push(bt, &my_struct);
171-
172- my_struct.a = 3;
173- my_struct.b = 3;
174- bytearray_push(bt, &my_struct);
175-
176- my_structptr = bytearray_pop(bt);
177-
178- my_struct.a = 2;
179- my_struct.b = 2;
180- assert(my_structptr->a == my_struct.a);
181- assert(my_structptr->b == my_struct.b);
182- free(my_structptr);
183-
184-
185-
186- delete_bytearray(bt);
187-
150+ delete_bytearray(bt, NULL);
188151 }
189-
152+#if __STDC_VERSION__ >= 201112L
190153 static void test4(void)
191154 {
192155 struct timespec ts1 = {10, 10};
@@ -236,13 +199,16 @@ static void test4(void)
236199 res = timespec_diff(&ts1, &ts2);
237200 assert(res.tv_sec == 10 && res.tv_nsec == 999999998);
238201 }
202+#endif
239203
240204 int main(int argc, char** argv)
241205 {
242206 test1();
243207 test2();
244208 test3();
209+ #if __STDC_VERSION__ >= 201112L
245210 test4();
211+ #endif
246212 sleep_ms(1000);
247213 return 0;
248214 }
▾Msrc/vector.c
+18-9@ 1cc1a61@ master
@@ -49,6 +49,15 @@ void vector_remove(Vector* vector, size_t index, void (*rmv)(void*))
4949 }
5050 }
5151
52+void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*))
53+{
54+ size_t i;
55+ for(i = 0; i < length; i++)
56+ {
57+ vector_remove(vector, index+i, rmv);
58+ }
59+}
60+
5261 size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const void*, const void*))
5362 {
5463 size_t* ret;
@@ -66,18 +75,18 @@ size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const
6675 return NULL;
6776 }
6877
69-bool vector_insert(Vector* vector, size_t index, void* item)
78+bool_t vector_insert(Vector* vector, size_t index, void* item)
7079 {
7180 if(index > vector->length || !vector_adjust_size(vector, vector->length+1))
72- return false;
81+ return b_false;
7382
7483 memmove(vector->items+index+1, vector->items+index, (vector->length-index)*sizeof(*vector->items));
7584 vector->items[index] = item;
7685 ++vector->length;
77- return true;
86+ return b_true;
7887 }
7988
80-bool vector_adjust_size(Vector* vector, size_t size)
89+bool_t vector_adjust_size(Vector* vector, size_t size)
8190 {
8291 while(vector->capacity < size)
8392 {
@@ -86,14 +95,14 @@ bool vector_adjust_size(Vector* vector, size_t size)
8695 if(!vector->items)
8796 {
8897 vector->items = tmp;
89- return false;
98+ return b_false;
9099 }
91100 vector->capacity *= 2;
92101 }
93- return true;
102+ return b_true;
94103 }
95104
96-bool vector_shrink(Vector* vector)
105+bool_t vector_shrink(Vector* vector)
97106 {
98107 while(vector->capacity > (vector->length*2))
99108 {
@@ -102,11 +111,11 @@ bool vector_shrink(Vector* vector)
102111 if(!vector->items)
103112 {
104113 vector->items = tmp;
105- return false;
114+ return b_false;
106115 }
107116 vector->capacity /= 2;
108117 }
109- return true;
118+ return b_true;
110119 }
111120
112121 void delete_vector(Vector* vector, void (*rmv)(void*))