Adopted posix-like typedef for all public types

- equeue_t
- events_mutex_t
- events_sema_t

Author: geky

README.md

@@ -14,7 +14,7 @@ void print(void *s) {
 
 int main() {
     // creates a queue with 32 events with default size
-    struct equeue queue;
+    equeue_t queue;
     equeue_create(&queue, 32, 0);
 
     // events are simple callbacks

events.c

@@ -4,7 +4,7 @@
 #include <string.h>
 
 
-int equeue_create(struct equeue *q, unsigned size) {
+int equeue_create(equeue_t *q, unsigned size) {
     void *buffer = malloc(size);
     if (!buffer) {
         return -1;
@@ -15,7 +15,7 @@ int equeue_create(struct equeue *q, unsigned size) {
     return err;
 }
 
-int equeue_create_inplace(struct equeue *q, unsigned size, void *buffer) {
+int equeue_create_inplace(equeue_t *q, unsigned size, void *buffer) {
     q->slab.size = size;
     q->slab.data = buffer;
     q->chunks = 0;
@@ -47,7 +47,7 @@ int equeue_create_inplace(struct equeue *q, unsigned size, void *buffer) {
     return 0;
 }
 
-void equeue_destroy(struct equeue *q) {
+void equeue_destroy(equeue_t *q) {
     while (q->queue) {
         struct event *e = q->queue;
         q->queue = e->next;
@@ -61,7 +61,7 @@ void equeue_destroy(struct equeue *q) {
 }
 
 // equeue allocation functions
-static void *equeue_alloc(struct equeue *q, unsigned size) {
+static void *equeue_alloc(equeue_t *q, unsigned size) {
     size = size + sizeof(unsigned);
     size = (size + sizeof(unsigned)-1) & ~(sizeof(unsigned)-1);
     if (size < sizeof(struct equeue_chunk)) {
@@ -97,7 +97,7 @@ static void *equeue_alloc(struct equeue *q, unsigned size) {
     return 0;
 }
 
-static void equeue_dealloc(struct equeue *q, void *e) {
+static void equeue_dealloc(equeue_t *q, void *e) {
     struct equeue_chunk *c = (struct equeue_chunk *)((unsigned *)e - 1);
 
     events_mutex_lock(&q->freelock);
@@ -120,15 +120,15 @@ static void equeue_dealloc(struct equeue *q, void *e) {
 }
 
 // event allocation functions
-static inline int event_next_id(struct equeue *q) {
+static inline int event_next_id(equeue_t *q) {
     int id = q->next_id++;
     if (q->next_id < 0) {
         q->next_id = 42;
     }
     return id;
 }
 
-void *event_alloc(struct equeue *q, unsigned size) {
+void *event_alloc(equeue_t *q, unsigned size) {
     struct event *e = equeue_alloc(q, sizeof(struct event) + size);
     if (!e) {
         return 0;
@@ -142,7 +142,7 @@ void *event_alloc(struct equeue *q, unsigned size) {
     return e + 1;
 }
 
-void event_dealloc(struct equeue *q, void *p) {
+void event_dealloc(equeue_t *q, void *p) {
     struct event *e = (struct event*)p - 1;
 
     if (e->dtor) {
@@ -157,7 +157,7 @@ static inline int equeue_tickdiff(unsigned a, unsigned b) {
     return (int)(a - b);
 }
 
-static int equeue_enqueue(struct equeue *q, struct event *e, int ms) {
+static int equeue_enqueue(equeue_t *q, struct event *e, int ms) {
     e->target = events_tick() + (unsigned)ms;
 
     struct event **p = &q->queue;
@@ -171,7 +171,7 @@ static int equeue_enqueue(struct equeue *q, struct event *e, int ms) {
     return e->id;
 }
 
-static struct event *equeue_dequeue(struct equeue *q, int id) {
+static struct event *equeue_dequeue(equeue_t *q, int id) {
     for (struct event **p = &q->queue; *p; p = &(*p)->next) {
         if ((*p)->id == id) {
             struct event *e = *p;
@@ -183,15 +183,15 @@ static struct event *equeue_dequeue(struct equeue *q, int id) {
     return 0;
 }
 
-static int equeue_post(struct equeue *q, struct event *e, int ms) {
+static int equeue_post(equeue_t *q, struct event *e, int ms) {
     events_mutex_lock(&q->queuelock);
     int id = equeue_enqueue(q, e, ms);
     events_mutex_unlock(&q->queuelock);
     events_sema_release(&q->eventsema);
     return id;
 }
 
-static void equeue_cancel(struct equeue *q, int id) {
+static void equeue_cancel(equeue_t *q, int id) {
     events_mutex_lock(&q->queuelock);
     struct event *e = equeue_dequeue(q, id);
     events_mutex_unlock(&q->queuelock);
@@ -201,11 +201,11 @@ static void equeue_cancel(struct equeue *q, int id) {
     }
 }
 
-void equeue_break(struct equeue *q) {
+void equeue_break(equeue_t *q) {
     equeue_post(q, &q->break_, 0);
 }
 
-void equeue_dispatch(struct equeue *q, int ms) {
+void equeue_dispatch(equeue_t *q, int ms) {
     if (ms >= 0) {
         equeue_post(q, &q->break_, ms);
     }
@@ -271,14 +271,14 @@ void event_dtor(void *p, void (*dtor)(void *)) {
 }
 
 // event operations
-int event_post(struct equeue *q, void (*cb)(void*), void *p) {
+int event_post(equeue_t *q, void (*cb)(void*), void *p) {
     struct event *e = (struct event*)p - 1;
     e->cb = cb;
     int id = equeue_post(q, e, e->target);
     return id;
 }
 
-void event_cancel(struct equeue *q, int id) {
+void event_cancel(equeue_t *q, int id) {
     return equeue_cancel(q, id);
 }
 
@@ -293,7 +293,7 @@ static void ecallback_dispatch(void *p) {
     e->cb(e->data);
 }
 
-int event_call(struct equeue *q, void (*cb)(void*), void *data) {
+int event_call(equeue_t *q, void (*cb)(void*), void *data) {
     struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
@@ -304,7 +304,7 @@ int event_call(struct equeue *q, void (*cb)(void*), void *data) {
     return event_post(q, ecallback_dispatch, e);
 }
 
-int event_call_in(struct equeue *q, void (*cb)(void*), void *data, int ms) {
+int event_call_in(equeue_t *q, void (*cb)(void*), void *data, int ms) {
     struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
@@ -316,7 +316,7 @@ int event_call_in(struct equeue *q, void (*cb)(void*), void *data, int ms) {
     return event_post(q, ecallback_dispatch, e);
 }
 
-int event_call_every(struct equeue *q, void (*cb)(void*), void *data, int ms) {
+int event_call_every(equeue_t *q, void (*cb)(void*), void *data, int ms) {
     struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;

events.h

@@ -26,7 +26,7 @@ struct event {
     // data follows
 };
 
-struct equeue {
+typedef struct equeue {
     struct event *queue;
     int next_id;
 
@@ -46,26 +46,26 @@ struct equeue {
     events_sema_t eventsema;
     events_mutex_t queuelock;
     events_mutex_t freelock;
-};
+} equeue_t;
 
 // Queue operations
 //
 // Creation results in negative value on failure.
-int equeue_create(struct equeue*, unsigned size);
-int equeue_create_inplace(struct equeue*, unsigned size, void *buffer);
-void equeue_destroy(struct equeue*);
+int equeue_create(equeue_t*, unsigned size);
+int equeue_create_inplace(equeue_t*, unsigned size, void *buffer);
+void equeue_destroy(equeue_t*);
 
 // Dispatch events
 //
 // Executes any callbacks enqueued for the specified time in milliseconds,
 // or forever if ms is negative
-void equeue_dispatch(struct equeue*, int ms);
+void equeue_dispatch(equeue_t*, int ms);
 
 // Break a running event loop
 //
 // Shuts down an unbounded event loop. Already pending events may finish executing,
 // but the queue will not continue looping indefinitely.
-void equeue_break(struct equeue*);
+void equeue_break(equeue_t*);
 
 // Simple event calls
 //
@@ -78,9 +78,9 @@ void equeue_break(struct equeue*);
 //
 // These calls will result in 0 if no memory is available, otherwise they
 // will result in a unique identifier that can be passed to event_cancel.
-int event_call(struct equeue*, void (*cb)(void*), void *data);
-int event_call_in(struct equeue*, void (*cb)(void*), void *data, int ms);
-int event_call_every(struct equeue*, void (*cb)(void*), void *data, int ms);
+int event_call(equeue_t*, void (*cb)(void*), void *data);
+int event_call_in(equeue_t*, void (*cb)(void*), void *data, int ms);
+int event_call_every(equeue_t*, void (*cb)(void*), void *data, int ms);
 
 // Events with queue handled blocks of memory
 //
@@ -90,8 +90,8 @@ int event_call_every(struct equeue*, void (*cb)(void*), void *data, int ms);
 //
 // event_alloc will result in null if no memory is available
 // or the requested size is less than the size passed to equeue_create.
-void *event_alloc(struct equeue*, unsigned size);
-void event_dealloc(struct equeue*, void*);
+void *event_alloc(equeue_t*, unsigned size);
+void event_dealloc(equeue_t*, void*);
 
 // Configure an allocated event
 // 
@@ -110,15 +110,15 @@ void event_dtor(void *event, void (*dtor)(void *));
 //
 // This call results in an unique identifier that can be passed to
 // event_cancel.
-int event_post(struct equeue*, void (*cb)(void*), void *event);
+int event_post(equeue_t*, void (*cb)(void*), void *event);
 
 // Cancel events that are in flight
 //
 // Every event_call function returns a non-negative identifier on success
 // that can be used to cancel an in-flight event. If the event has already
 // been dispatched or does not exist, no error occurs. Note, this can not
 // stop a currently executing event
-void event_cancel(struct equeue*, int event);
+void event_cancel(equeue_t*, int event);
 
 
 #ifdef __cplusplus

tests/tests.c

@@ -67,7 +67,7 @@ void timing_func(void *p) {
 }
 
 struct fragment {
-    struct equeue *q;
+    equeue_t *q;
     unsigned size;
     struct timing timing;
 };
@@ -89,7 +89,7 @@ void fragment_func(void *p) {
 
 // Simple call tests
 void simple_call_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -102,7 +102,7 @@ void simple_call_test(void) {
 }
 
 void simple_call_in_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -117,7 +117,7 @@ void simple_call_in_test(void) {
 }
 
 void simple_call_every_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -132,7 +132,7 @@ void simple_call_every_test(void) {
 }
 
 void simple_post_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -152,7 +152,7 @@ void simple_post_test(void) {
 
 // Misc tests
 void destructor_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -182,7 +182,7 @@ void destructor_test(void) {
 }
 
 void allocation_failure_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -198,7 +198,7 @@ void allocation_failure_test(void) {
 }
 
 void cancel_test(int N) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -222,7 +222,7 @@ void cancel_test(int N) {
 }
 
 void loop_protect_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -242,7 +242,7 @@ void loop_protect_test(void) {
 }
 
 void break_test(void) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, 2048);
     test_assert(!err);
 
@@ -258,7 +258,7 @@ void break_test(void) {
 
 // Barrage tests
 void simple_barrage_test(int N) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, N * 56);
     test_assert(!err);
 
@@ -281,7 +281,7 @@ void simple_barrage_test(int N) {
 }
 
 void fragmenting_barrage_test(int N) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, N * 1000);
     test_assert(!err);
 
@@ -307,7 +307,7 @@ void fragmenting_barrage_test(int N) {
 
 struct ethread {
     pthread_t thread;
-    struct equeue *q;
+    equeue_t *q;
     int ms;
 };
 
@@ -318,7 +318,7 @@ static void *ethread_dispatch(void *p) {
 }
 
 void multithreaded_barrage_test(int N) {
-    struct equeue q;
+    equeue_t q;
     int err = equeue_create(&q, N * 56);
     test_assert(!err);