libcutils

← Back to log@ e8864d4

changed bool_t to bool to be drop-in replacement in C89, added memqswap which usually gets optimized better but may fail allocation, changed some linked list functions to be polymorphic, added some tests, fixed bugs in linked list

AuthorKonata <konata@posteo.jp>
Date
Commite8864d42e33c8ac4a6a10b497bf7b15d9d9b696a
Parent858bbe0
11 files changed, 246 insertions(+), 230 deletions(-)
▾Minclude/cutils/byte_array.h
+3-3@ e8864d4@ master
@@ -24,12 +24,12 @@ void* bytearray_at(const Bytearray* bytearray, size_t index);
2424 void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr);
2525
2626 #define bytearray_push(bytearray, item) bytearray_insert(bytearray, bytearray->length, item)
27-bool_t bytearray_insert(Bytearray* bytearray, size_t index, const void* item);
27+bool bytearray_insert(Bytearray* bytearray, size_t index, const void* item);
2828
2929 void bytearray_remove(Bytearray* bytearray, size_t index, void (*rmv)(void*));
3030
31-bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size);
32-bool_t bytearray_shrink(Bytearray* bytearray);
31+bool bytearray_adjust_size(Bytearray* bytearray, size_t size);
32+bool bytearray_shrink(Bytearray* bytearray);
3333 HEDLEY_NON_NULL(3)
3434 size_t* bytearray_find(const Bytearray* haystack, const void* needle, int (*cmp)(const void*, const void*));
3535
▾Minclude/cutils/common.h
+8-1@ e8864d4@ master
@@ -6,7 +6,14 @@
66 #ifndef SIZE_MAX
77 #define SIZE_MAX (size_t)-1;
88 #endif
9-typedef enum {b_false, b_true} bool_t;
9+
10+#if __STDC_VERSION__ >= 199901L
11+ #include <stdbool.h>
12+#else
13+ #ifndef CUTILS_NO_BOOL
14+ typedef enum {false = 0, true = 1} bool;
15+ #endif
16+#endif
1017
1118
1219 #endif /* CUTILS_COMMON_H */
▾Minclude/cutils/dyn_string.h
+3-3@ e8864d4@ master
@@ -22,17 +22,17 @@ 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_t string_insert(String* string, size_t index, char character);
25+bool 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);
2929 void string_remove_range(String* string, size_t index, size_t length);
3030
31-bool_t string_adjust_size(String* string, size_t size);
31+bool string_adjust_size(String* string, size_t size);
3232 size_t* string_find_char(const String* haystack, const char needle);
3333 size_t* string_find_str(const String* haystack, const String* needle);
3434
35-bool_t string_concat(String* string, const String* other);
35+bool string_concat(String* string, const String* other);
3636
3737 String* from_cstring(const char* cstring);
3838 String* from_cstring_del(char* cstring);
▾Minclude/cutils/linked-list.h
+22-55@ e8864d4@ master
@@ -7,13 +7,12 @@
77 typedef struct SLnode
88 {
99 void* item;
10- struct SLnode* next;
10+ void* next; /*has to be void* so the next field is compatible between the structs*/
1111 } SLnode;
1212
1313 typedef struct DLnode
1414 {
15- void* item;
16- struct DLnode* next;
15+ struct SLnode sl;
1716 struct DLnode* prev;
1817 } DLnode;
1918
@@ -22,67 +21,43 @@ typedef struct LinkedList
2221 void* head; /*SLnode if doubly_linked is false, otherwise DLnode*/
2322 void* tail;
2423 size_t length;
25- bool_t doubly_linked;
26- bool_t circularly_linked;
24+ bool doubly_linked;
25+ bool circularly_linked;
2726 } LinkedList;
2827
29-LinkedList* new_ll(bool_t doubly_linked, bool_t circularly_linked);
28+LinkedList* new_ll(bool doubly_linked, bool circularly_linked);
29+void delete_ll(LinkedList* ll, void(*rmv) (void*));
3030
31-void delete_sll(LinkedList* ll, void(*rmv) (void*));
32-void delete_dll(LinkedList* ll, void(*rmv) (void*));
33-HEDLEY_INLINE
34-static void delete_ll(LinkedList* ll, void(*rmv) (void*))
35-{
36- if(ll->doubly_linked)
37- delete_dll(ll, rmv);
38- else
39- delete_sll(ll, rmv);
40-}
41-
42-void* sll_at(const LinkedList* ll, size_t index);
43-void* dll_at(const LinkedList* ll, size_t index);
31+void* llnode_at(const LinkedList* ll, size_t index);
4432 HEDLEY_INLINE
4533 static void* ll_at(const LinkedList* ll, size_t index)
4634 {
47- if(ll->doubly_linked)
48- return sll_at(ll, index);
49- else
50- return dll_at(ll, index);
35+ return ((SLnode*)llnode_at(ll, index))->item;
5136 }
5237 #define ll_pop(ll) ll_pop_at(ll, ll->length-1)
53-void* sll_pop_at(LinkedList* ll, size_t index);
54-void* dll_pop_at(LinkedList* ll, size_t index);
55-HEDLEY_INLINE
56-static void* ll_pop_at(LinkedList* ll, size_t index)
57-{
58- if(ll->doubly_linked)
59- return sll_pop_at(ll, index);
60- else
61- return dll_pop_at(ll, index);
62-}
38+void* ll_pop_at(LinkedList* ll, size_t index);
6339
6440 #define ll_push(ll, item) ll_insert(ll, ll->length, item)
65-bool_t sll_insert(LinkedList* ll, size_t index, void* item);
66-bool_t dll_insert(LinkedList* ll, size_t index, void* item);
41+bool sll_insert(LinkedList* ll, size_t index, void* item);
42+bool dll_insert(LinkedList* ll, size_t index, void* item);
6743 HEDLEY_INLINE
68-static bool_t ll_insert(LinkedList* ll, size_t index, void* item)
44+static bool ll_insert(LinkedList* ll, size_t index, void* item)
6945 {
7046 if(ll->doubly_linked)
71- return sll_insert(ll, index, item);
72- else
7347 return dll_insert(ll, index, item);
48+ else
49+ return sll_insert(ll, index, item);
7450 }
7551
76-
7752 void sll_remove(LinkedList* ll, size_t index, void (*rmv)(void*));
7853 void dll_remove(LinkedList* ll, size_t index, void (*rmv)(void*));
7954 HEDLEY_INLINE
8055 static void ll_remove(LinkedList* ll, size_t index, void (*rmv)(void*))
8156 {
8257 if(ll->doubly_linked)
83- sll_remove(ll, index, rmv);
84- else
8558 dll_remove(ll, index, rmv);
59+ else
60+ sll_remove(ll, index, rmv);
8661 }
8762 void sll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*));
8863 void dll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*));
@@ -90,30 +65,22 @@ HEDLEY_INLINE
9065 static void ll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*))
9166 {
9267 if(ll->doubly_linked)
93- sll_remove_range(ll, index, length, rmv);
94- else
9568 dll_remove_range(ll, index, length, rmv);
96-}
97-
98-size_t* sll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*));
99-size_t* dll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*));
100-HEDLEY_INLINE
101-static size_t* ll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*))
102-{
103- if(haystack->doubly_linked)
104- return sll_find(haystack, needle, cmp);
10569 else
106- return dll_find(haystack, needle, cmp);
70+ sll_remove_range(ll, index, length, rmv);
10771 }
72+
73+size_t* ll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*));
74+
10875 void sll_swap(LinkedList* ll, size_t item1, size_t item2);
10976 void dll_swap(LinkedList* ll, size_t item1, size_t item2);
11077 HEDLEY_INLINE
11178 static void ll_swap(LinkedList* ll, size_t item1, size_t item2)
11279 {
11380 if(ll->doubly_linked)
114- sll_swap(ll, item1, item2);
115- else
11681 dll_swap(ll, item1, item2);
82+ else
83+ sll_swap(ll, item1, item2);
11784 }
11885
11986
▾Minclude/cutils/misc.h
+17-3@ e8864d4@ master
@@ -15,6 +15,7 @@
1515 #endif
1616
1717 #include <string.h>
18+#include <stdlib.h>
1819 #include <cutils/common.h>
1920
2021 #if __STDC_VERSION__ >= 199901L
@@ -38,12 +39,25 @@ static void memswap(void* item1, void* item2, size_t length)
3839
3940 while(length--)
4041 {
41- tmp = *item1_tmp;
42- *item1_tmp = *item2_tmp;
43- *item2_tmp = tmp;
42+ tmp = item1_tmp[length];
43+ item1_tmp[length] = item2_tmp[length];
44+ item2_tmp[length] = tmp;
4445 }
4546 }
4647
48+HEDLEY_INLINE
49+static bool memqswap(void* item1, void* item2, size_t length)
50+{
51+ void* tmp = malloc(length);
52+ if(!tmp)
53+ return false;
54+ memcpy(tmp, item1, length);
55+ memcpy(item1, item2, length);
56+ memcpy(item2, tmp, length);
57+ free(tmp);
58+ return true;
59+}
60+
4761 #if __STDC_VERSION__ >= 201112L
4862 #include <time.h>
4963 #endif
▾Minclude/cutils/vector.h
+3-3@ e8864d4@ master
@@ -22,14 +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_t vector_insert(Vector* vector, size_t index, void* item);
25+bool 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*));
2929 void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*));
3030
31-bool_t vector_adjust_size(Vector* vector, size_t size);
32-bool_t vector_shrink(Vector* vector);
31+bool vector_adjust_size(Vector* vector, size_t size);
32+bool vector_shrink(Vector* vector);
3333 HEDLEY_NON_NULL(3)
3434 size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const void*, const void*));
3535
▾Msrc/byte_array.c
+9-9@ e8864d4@ master
@@ -63,18 +63,18 @@ void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr)
6363 return retptr;
6464 }
6565
66-bool_t bytearray_insert(Bytearray* bytearray, size_t index, const void* item)
66+bool bytearray_insert(Bytearray* bytearray, size_t index, const void* item)
6767 {
6868 size_t length = bytearray->length;
6969 size_t size = bytearray->element_size;
7070
7171 if(index > length || !bytearray_adjust_size(bytearray, length+1))
72- return b_false;
72+ return false;
7373
7474 memmove(bytearray->items+index*size+1*size, bytearray->items+index*size, (length*size-index*size)*sizeof(*bytearray->items));
7575 memcpy(bytearray->items+index*size, item, bytearray->element_size);
7676 bytearray->length++;
77- return b_true;
77+ return true;
7878 }
7979
8080 void bytearray_remove(Bytearray* bytearray, size_t index, void (*rmv)(void*))
@@ -91,7 +91,7 @@ void bytearray_remove(Bytearray* bytearray, size_t index, void (*rmv)(void*))
9191 }
9292 }
9393
94-bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
94+bool bytearray_adjust_size(Bytearray* bytearray, size_t size)
9595 {
9696 while(bytearray->capacity < size)
9797 {
@@ -102,14 +102,14 @@ bool_t bytearray_adjust_size(Bytearray* bytearray, size_t size)
102102 if(!bytearray->items)
103103 {
104104 bytearray->items = tmp;
105- return b_false;
105+ return false;
106106 }
107107 bytearray->capacity *= 2;
108108 }
109- return b_true;
109+ return true;
110110 }
111111
112-bool_t bytearray_shrink(Bytearray* bytearray)
112+bool bytearray_shrink(Bytearray* bytearray)
113113 {
114114 while(bytearray->capacity > bytearray->length*2)
115115 {
@@ -120,11 +120,11 @@ bool_t bytearray_shrink(Bytearray* bytearray)
120120 if(!bytearray->items)
121121 {
122122 bytearray->items = tmp;
123- return b_false;
123+ return false;
124124 }
125125 bytearray->capacity /= 2;
126126 }
127- return b_true;
127+ return true;
128128 }
129129
130130 size_t* bytearray_find(const Bytearray* haystack, const void* needle, int (*cmp)(const void*, const void*))
▾Msrc/dyn_string.c
+10-10@ e8864d4@ master
@@ -25,7 +25,7 @@ void string_remove(String* string, size_t index)
2525 string->length--;
2626 }
2727 }
28-
28+/* TODO: optimize */
2929 void string_remove_range(String* string, size_t index, size_t length)
3030 {
3131 size_t i;
@@ -35,15 +35,15 @@ void string_remove_range(String* string, size_t index, size_t length)
3535 }
3636 }
3737
38-bool_t string_insert(String* string, size_t index, char character)
38+bool string_insert(String* string, size_t index, char character)
3939 {
4040 if(index > string->length || !string_adjust_size(string, string->length))
41- return b_false;
41+ return false;
4242
4343 memmove(string->chars+index+1, string->chars+index, (string->length-index)*sizeof(*string->chars));
4444 string->chars[index] = character;
4545 string->length++;
46- return b_true;
46+ return true;
4747 }
4848
4949 char string_at(const String* string, size_t index)
@@ -66,13 +66,13 @@ char string_pop_at(String* string, size_t index)
6666 }
6767 }
6868
69-bool_t string_concat(String* string, const String* other)
69+bool string_concat(String* string, const String* other)
7070 {
7171 if(!string_adjust_size(string,string->length+other->length-1))
72- return b_false;
72+ return false;
7373 memcpy(string->chars+string->length,other->chars,other->length);
7474 string->length += other->length;
75- return b_true;
75+ return true;
7676 }
7777
7878 size_t* string_find_char(const String* haystack, const char needle)
@@ -112,7 +112,7 @@ size_t* string_find_str(const String* haystack, const String* needle)
112112 return NULL;
113113 }
114114
115-bool_t string_adjust_size(String* string, size_t size)
115+bool string_adjust_size(String* string, size_t size)
116116 {
117117 while(string->capacity < size)
118118 {
@@ -121,11 +121,11 @@ bool_t string_adjust_size(String* string, size_t size)
121121 if(!string->chars)
122122 {
123123 string->chars = tmp;
124- return b_false;
124+ return false;
125125 }
126126 string->capacity *= 2;
127127 }
128- return b_true;
128+ return true;
129129 }
130130
131131
▾Msrc/linked-list.c
+108-125@ e8864d4@ master
@@ -1,7 +1,7 @@
11 #include <cutils/linked-list.h>
22 #include <cutils/misc.h>
33
4-LinkedList* new_ll(bool_t doubly_linked, bool_t circularly_linked)
4+LinkedList* new_ll(bool doubly_linked, bool circularly_linked)
55 {
66 LinkedList* ret = malloc(sizeof(*ret));
77 ret->head = NULL;
@@ -12,7 +12,7 @@ LinkedList* new_ll(bool_t doubly_linked, bool_t circularly_linked)
1212 return ret;
1313 }
1414
15-void delete_sll(LinkedList* ll, void(*rmv) (void*))
15+void delete_ll(LinkedList* ll, void(*rmv) (void*))
1616 {
1717 size_t i;
1818 SLnode *current, *tmp;
@@ -27,30 +27,11 @@ void delete_sll(LinkedList* ll, void(*rmv) (void*))
2727 tmp = current;
2828 current = current->next;
2929 free(tmp);
30-
31- }
32-}
33-
34-void delete_dll(LinkedList* ll, void(*rmv) (void*))
35-{
36- size_t i;
37- DLnode *current, *tmp;
38-
39- current = ll->head;
40-
41- for(i = 0; i < ll->length; i++)
42- {
43-
44- if(rmv)
45- rmv(current->item);
46- tmp = current;
47- current = current->next;
48- free(tmp);
49-
5030 }
31+ free(ll);
5132 }
5233
53-void* sll_at(const LinkedList* ll, size_t index)
34+void* llnode_at(const LinkedList* ll, size_t index)
5435 {
5536 size_t i;
5637 SLnode* current;
@@ -62,67 +43,31 @@ void* sll_at(const LinkedList* ll, size_t index)
6243 current = current->next;
6344 }
6445
65- return current->item;
46+ return current;
6647 }
6748
68-void* dll_at(const LinkedList* ll, size_t index)
69-{
70- size_t i;
71- DLnode* current;
72-
73- current = ll->head;
7449
75- for(i = 0; i < index; i++)
76- {
77- current = current->next;
78- }
79-
80- return current->item;
81-}
82-
83-void* sll_pop_at(LinkedList* ll, size_t index)
50+void* ll_pop_at(LinkedList* ll, size_t index)
8451 {
85- size_t i;
86- SLnode* current;
52+ SLnode* node;
8753 void* tmp;
8854
89- current = ll->head;
90-
91- for(i = 0; i < index; i++)
92- {
93- current = current->next;
94- }
55+ node = llnode_at(ll ,index);
9556
96- tmp = current->item;
57+ tmp = node->item;
9758 ll_remove(ll, index, NULL);
9859 return tmp;
9960 }
10061
101-void* dll_pop_at(LinkedList* ll, size_t index)
102-{
103- size_t i;
104- DLnode* current;
105- void* tmp;
106-
107- current = ll->head;
108-
109- for(i = 0; i < index; i++)
110- {
111- current = current->next;
112- }
11362
114- tmp = current->item;
115- ll_remove(ll, index, NULL);
116- return tmp;
117-}
11863
119-bool_t sll_insert(LinkedList* ll, size_t index, void* item)
64+bool sll_insert(LinkedList* ll, size_t index, void* item)
12065 {
12166 size_t i;
12267 SLnode *current, *prev, *newnode = malloc(sizeof(*newnode));
12368
12469 if(!newnode)
125- return b_false;
70+ return false;
12671
12772 newnode->item =item;
12873 prev = NULL;
@@ -137,60 +82,75 @@ bool_t sll_insert(LinkedList* ll, size_t index, void* item)
13782 if(current)
13883 {
13984 newnode->next = current;
140- if(prev)
141- prev->next = newnode;
142- else
85+ if(index == 0)
14386 ll->head = newnode;
87+ else
88+ prev->next = newnode;
14489 } else {
14590 ll->tail = newnode;
91+ newnode->next = NULL;
14692 if(index == 0)
14793 ll->head = newnode;
148- newnode->next = NULL;
94+ if(prev)
95+ prev->next = newnode;
14996 }
15097
15198 ll->length++;
152- return b_true;
99+ return true;
153100 }
154101
155-bool_t dll_insert(LinkedList* ll, size_t index, void* item)
102+bool dll_insert(LinkedList* ll, size_t index, void* item)
156103 {
157104 size_t i;
158- DLnode *current, *newnode = malloc(sizeof(*newnode));
105+ DLnode *current, *prev, *newnode = malloc(sizeof(*newnode));
159106
160107 if(!newnode)
161- return b_false;
108+ return false;
162109
163- newnode->item =item;
110+ newnode->sl.item = item;
111+ prev = NULL;
164112 current = ll->head;
165113
166114 for(i = 0; i < index; i++)
167115 {
168- current = current->next;
116+ prev = current;
117+ current = current->sl.next;
169118 }
170119
171120 if(current)
172121 {
173- newnode->next = current;
174- if(current->prev)
122+ newnode->sl.next = current;
123+ if(index == 0)
175124 {
176- current->prev->next = newnode;
177- newnode->prev =current;
178- } else {
179125 ll->head = newnode;
180126 newnode->prev = NULL;
127+ } else {
128+ prev->sl.next = newnode;
129+ newnode->prev = prev;
181130 }
131+ current->prev = newnode;
182132 } else {
183133 ll->tail = newnode;
134+ newnode->sl.next = NULL;
184135 if(index == 0)
136+ {
185137 ll->head = newnode;
186- newnode->next = NULL;
187- newnode->prev = NULL;
138+ newnode->prev = NULL;
139+ }
140+ if(prev)
141+ {
142+ prev->sl.next = newnode;
143+ newnode->prev = prev;
144+ }
145+
188146 }
189147
190148 ll->length++;
191- return b_true;
149+ return true;
192150 }
193151
152+
153+
194154 void sll_remove(LinkedList* ll, size_t index, void (*rmv)(void*))
195155 {
196156 size_t i;
@@ -208,30 +168,50 @@ void sll_remove(LinkedList* ll, size_t index, void (*rmv)(void*))
208168 if(rmv)
209169 rmv(current->item);
210170
211- prev->next = current->next;
171+ if(!current->next)
172+ ll->tail = prev;
173+
174+ if(prev)
175+ prev->next = current->next;
176+ else
177+ ll->head = current->next;
178+
212179 free(current);
180+ ll->length--;
213181 }
214182
215183 void dll_remove(LinkedList* ll, size_t index, void (*rmv)(void*))
216184 {
217185 size_t i;
218- DLnode* current;
186+ DLnode *current, *prev;
219187
188+ prev = NULL;
220189 current = ll->head;
221190
222191 for(i = 0; i < index; i++)
223192 {
224- current = current->next;
193+ prev = current;
194+ current = current->sl.next;
225195 }
226196
227197 if(rmv)
228- rmv(current->item);
198+ rmv(current->sl.item);
199+
200+ if(current->sl.next)
201+ ((DLnode*)(current->sl.next))->prev = prev;
202+ else
203+ ll->tail = prev;
204+
205+ if(prev)
206+ prev->sl.next = current->sl.next;
207+ else
208+ ll->head = current->sl.next;
229209
230- current->prev->next = current->next;
231- current->next->prev = current->prev;
232210 free(current);
211+ ll->length--;
233212 }
234213
214+
235215 void sll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*))
236216 {
237217 size_t i;
@@ -250,18 +230,25 @@ void sll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(v
250230 {
251231 if(rmv)
252232 rmv(current->item);
253- tmp = current;
233+ tmp = current->next;
254234 free(current);
255- current = tmp->next;
235+ current = tmp;
256236 }
257237
258- prev->next = current;
238+ if(!current)
239+ ll->tail = prev;
240+
241+ if(prev)
242+ prev->next = current;
243+ else
244+ ll->head = current;
245+ ll->length -= length;
259246 }
260247
261248 void dll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(void*))
262249 {
263250 size_t i;
264- DLnode *current, *prev;
251+ DLnode *current, *tmp, *prev;
265252
266253 prev = NULL;
267254 current = ll->head;
@@ -269,45 +256,36 @@ void dll_remove_range(LinkedList* ll, size_t index, size_t length, void (*rmv)(v
269256 for(i = 0; i < index; i++)
270257 {
271258 prev = current;
272- current = current->next;
259+ current = current->sl.next;
273260 }
274261
275262 for(i = 0; i < length; i++)
276263 {
277264 if(rmv)
278- rmv(current->item);
279- current = current->next;
280- free(current->prev);
265+ rmv(current->sl.item);
266+ tmp = current->sl.next;
267+ free(current);
268+ current = tmp;
281269 }
270+ if(current)
271+ current->prev = prev;
272+ else
273+ ll->tail = prev;
282274
283- prev->next = current;
284- current->prev = prev;
285-}
286-
287-size_t* sll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*))
288-{
289- size_t i, *ret;
290- SLnode* current;
291-
292- current = haystack->head;
293-
294- for(i = 0; i < haystack->length; i++)
275+ if(prev)
295276 {
296- if(cmp(current->item, needle) == 0)
297- {
298- ret = malloc(sizeof(*ret));
299- *ret = i;
300- return ret;
301- }
302- current = current->next;
277+ prev->sl.next = current;
278+ } else {
279+ ll->head = current;
303280 }
304- return NULL;
281+ ll->length -= length;
305282 }
306283
307-size_t* dll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*))
284+
285+size_t* ll_find(const LinkedList* haystack, const void* needle, int (*cmp)(const void*, const void*))
308286 {
309287 size_t i, *ret;
310- DLnode* current;
288+ SLnode* current;
311289
312290 current = haystack->head;
313291
@@ -328,6 +306,7 @@ void sll_swap(LinkedList* ll, size_t item1, size_t item2)
328306 {
329307 size_t i, first_index, second_index;
330308 SLnode *first, *second;
309+ void* tmp;
331310
332311 first_index = item1 <= item2 ? item1 : item2;
333312 second_index = item1 <= item2 ? item2 : item1;
@@ -338,14 +317,18 @@ void sll_swap(LinkedList* ll, size_t item1, size_t item2)
338317 for(i = 0; i < second_index; i++)
339318 {
340319 if(i == first_index)
341- first = second->next;
320+ first = second;
342321 second = second->next;
343322 }
344323
345324 if(!first)
346325 first = second;
347326
348- memswap(&first->item, &second->item, sizeof(first->item));
327+ tmp = first->item;
328+ first->item = second->item;
329+ second->item = tmp;
330+
331+ /*memswap(&first->item, &second->item, sizeof(first->item));*/
349332 }
350333
351334 void dll_swap(LinkedList* ll, size_t item1, size_t item2)
@@ -362,12 +345,12 @@ void dll_swap(LinkedList* ll, size_t item1, size_t item2)
362345 for(i = 0; i < second_index; i++)
363346 {
364347 if(i == first_index)
365- first = second->next;
366- second = second->next;
348+ first = second;
349+ second = second->sl.next;
367350 }
368351
369352 if(!first)
370353 first = second;
371354
372- memswap(&first->item, &second->item, sizeof(first->item));
355+ memswap(&first->sl.item, &second->sl.item, sizeof(first->sl.item));
373356 }
▾Msrc/test.c
+53-8@ e8864d4@ master
@@ -15,7 +15,7 @@ static int cmp_str(const void* str1, const void* str2)
1515 return !((str1_s->a == str2_s->a) && (str1_s->b == str2_s->b));
1616 }
1717
18-static void test1(void)
18+static void test_vector(void)
1919 {
2020 size_t* find;
2121 Vector* vector;
@@ -65,7 +65,7 @@ static void test1(void)
6565 delete_vector(vector, free);
6666 }
6767
68-static void test2(void)
68+static void test_string(void)
6969 {
7070 String* string;
7171 String* string2;
@@ -115,7 +115,7 @@ static void test2(void)
115115 delete_string(string);
116116 }
117117
118-static void test3(void)
118+static void test_bytearray(void)
119119 {
120120 Bytearray* bt;
121121 char* tmpchar;
@@ -160,7 +160,7 @@ static void test3(void)
160160 delete_bytearray(bt, NULL);
161161 }
162162 #if __STDC_VERSION__ >= 201112L
163-static void test4(void)
163+static void test_timespec(void)
164164 {
165165 struct timespec ts1 = {10, 10};
166166 struct timespec ts2 = {10, 10};
@@ -210,15 +210,60 @@ static void test4(void)
210210 assert(res.tv_sec == 10 && res.tv_nsec == 999999998);
211211 }
212212 #endif
213+static void test_ll(void)
214+{
215+ LinkedList* ll;
216+ struct test my_structa, my_structb, *my_structptr;
217+ int truth;
218+ my_structa.a = 5;
219+ my_structa.b = 5;
220+ my_structb.a = 7;
221+ my_structb.b = 7;
222+
223+ for(truth = 0; truth<2; truth++)
224+ {
225+ ll = new_ll(truth,truth);
226+
227+ ll_push(ll, &my_structa);
228+ my_structptr = ll_pop(ll);
229+ assert(my_structptr->a == 5 && my_structptr->b == 5);
230+
231+ ll_push(ll, &my_structa);
232+ ll_push(ll, &my_structa);
233+ ll_push(ll, &my_structa);
234+ ll_push(ll, &my_structb);
235+
236+ my_structptr = ll_at(ll, ll->length-1);
237+ assert(my_structptr->a == 7);
238+
239+ ll_swap(ll, 0, ll->length-1);
240+
241+ my_structptr = ll_at(ll, ll->length-1);
242+ assert(my_structptr->a == 5);
243+
244+
245+ ll_remove_range(ll, 0, ll->length-1, NULL);
246+
247+ delete_ll(ll, NULL);
248+ }
249+
250+}
213251
214252 int main(int argc, char** argv)
215253 {
216- test1();
217- test2();
218- test3();
254+ int a = 5;
255+ int b = 2;
256+ memswap(&a, &b, sizeof(int));
257+ assert(a == 2 && b == 5);
258+
259+ test_vector();
260+ test_string();
261+ test_bytearray();
219262 #if __STDC_VERSION__ >= 201112L
220- test4();
263+ test_timespec();
221264 #endif
265+ test_ll();
266+
222267 sleep_ms(1000);
223268 return 0;
224269 }
▾Msrc/vector.c
+10-10@ e8864d4@ master
@@ -48,7 +48,7 @@ void vector_remove(Vector* vector, size_t index, void (*rmv)(void*))
4848 vector->length--;
4949 }
5050 }
51-
51+/* TODO: optimize */
5252 void vector_remove_range(Vector* vector, size_t index, size_t length, void (*rmv)(void*))
5353 {
5454 size_t i;
@@ -74,18 +74,18 @@ size_t* vector_find(const Vector* haystack, const void* needle, int (*cmp)(const
7474 return NULL;
7575 }
7676
77-bool_t vector_insert(Vector* vector, size_t index, void* item)
77+bool vector_insert(Vector* vector, size_t index, void* item)
7878 {
7979 if(index > vector->length || !vector_adjust_size(vector, vector->length+1))
80- return b_false;
80+ return false;
8181
8282 memmove(vector->items+index+1, vector->items+index, (vector->length-index)*sizeof(*vector->items));
8383 vector->items[index] = item;
8484 vector->length++;
85- return b_true;
85+ return true;
8686 }
8787
88-bool_t vector_adjust_size(Vector* vector, size_t size)
88+bool vector_adjust_size(Vector* vector, size_t size)
8989 {
9090 while(vector->capacity < size)
9191 {
@@ -94,14 +94,14 @@ bool_t vector_adjust_size(Vector* vector, size_t size)
9494 if(!vector->items)
9595 {
9696 vector->items = tmp;
97- return b_false;
97+ return false;
9898 }
9999 vector->capacity *= 2;
100100 }
101- return b_true;
101+ return true;
102102 }
103103
104-bool_t vector_shrink(Vector* vector)
104+bool vector_shrink(Vector* vector)
105105 {
106106 while(vector->capacity > (vector->length*2))
107107 {
@@ -110,11 +110,11 @@ bool_t vector_shrink(Vector* vector)
110110 if(!vector->items)
111111 {
112112 vector->items = tmp;
113- return b_false;
113+ return false;
114114 }
115115 vector->capacity /= 2;
116116 }
117- return b_true;
117+ return true;
118118 }
119119
120120 void delete_vector(Vector* vector, void (*rmv)(void*))