Adopted size_t where applicable

equeue.c

@@ -10,7 +10,7 @@
 #include <string.h>
 
 
-int equeue_create(equeue_t *q, unsigned size) {
+int equeue_create(equeue_t *q, size_t size) {
     void *buffer = malloc(size);
     if (!buffer) {
         return -1;
@@ -21,7 +21,7 @@ int equeue_create(equeue_t *q, unsigned size) {
     return err;
 }
 
-int equeue_create_inplace(equeue_t *q, unsigned size, void *buffer) {
+int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) {
     q->slab.size = size;
     q->slab.data = buffer;
     q->chunks = 0;
@@ -67,7 +67,7 @@ void equeue_destroy(equeue_t *q) {
 }
 
 // equeue allocation functions
-static void *equeue_mem_alloc(equeue_t *q, unsigned size) {
+static void *equeue_mem_alloc(equeue_t *q, size_t size) {
     size = size + sizeof(unsigned);
     size = (size + sizeof(unsigned)-1) & ~(sizeof(unsigned)-1);
     if (size < sizeof(struct equeue_chunk)) {
@@ -134,7 +134,7 @@ static inline int equeue_next_id(equeue_t *q) {
     return id;
 }
 
-void *equeue_alloc(equeue_t *q, unsigned size) {
+void *equeue_alloc(equeue_t *q, size_t size) {
     struct equeue_event *e = equeue_mem_alloc(q,
             sizeof(struct equeue_event) + size);
     if (!e) {

equeue.h

@@ -16,6 +16,8 @@ extern "C" {
 #include "equeue_mutex.h"
 #include "equeue_sema.h"
 
+#include <stddef.h>
+
 
 // Definition of the minimum size of an event
 // This size fits the events created in the event_call set of functions.
@@ -44,7 +46,7 @@ typedef struct equeue {
         struct equeue_chunk *nchunk;
     } *chunks;
     struct equeue_slab {
-        unsigned size;
+        size_t size;
         unsigned char *data;
     } slab;
 
@@ -59,8 +61,8 @@ typedef struct equeue {
 // Queue operations
 //
 // Creation results in negative value on failure.
-int equeue_create(equeue_t *queue, unsigned size);
-int equeue_create_inplace(equeue_t *queue, unsigned size, void *buffer);
+int equeue_create(equeue_t *queue, size_t size);
+int equeue_create_inplace(equeue_t *queue, size_t size, void *buffer);
 void equeue_destroy(equeue_t *queue);
 
 // Dispatch events
@@ -98,7 +100,7 @@ int equeue_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);
 //
 // equeue_alloc will result in null if no memory is available
 // or the requested size is less than the size passed to equeue_create.
-void *equeue_alloc(equeue_t *queue, unsigned size);
+void *equeue_alloc(equeue_t *queue, size_t size);
 void equeue_dealloc(equeue_t *queue, void *event);
 
 // Configure an allocated event

tests/tests.c

@@ -74,7 +74,7 @@ void timing_func(void *p) {
 
 struct fragment {
     equeue_t *q;
-    unsigned size;
+    size_t size;
     struct timing timing;
 };
 
@@ -293,7 +293,7 @@ void fragmenting_barrage_test(int N) {
     test_assert(!err);
 
     for (int i = 0; i < N; i++) {
-        unsigned size = sizeof(struct fragment) + i*sizeof(int);
+        size_t size = sizeof(struct fragment) + i*sizeof(int);
         struct fragment *fragment = equeue_alloc(&q, size);
         test_assert(fragment);