Merge pull request #4 from geky/refactor

Refactor codebase based on feedback from initial users

Author: geky

.travis.yml

@@ -1,6 +1,2 @@
 script:
-    - git config user.email "test"
-    - git config user.name "test"
-    - git fetch origin posix:posix
-    - git merge posix --no-commit
     - make test

Makefile

@@ -1,15 +1,19 @@
 TARGET = libevents.a
 
-
 CC = gcc
 AR = ar
 SIZE = size
 
-SRC += $(wildcard *.c sys/*.c)
+SRC += $(wildcard *.c)
 OBJ := $(SRC:.c=.o)
 DEP := $(SRC:.c=.d)
 ASM := $(SRC:.c=.s)
 
+TESTS = tests/tests
+TSRC += $(wildcard tests/*.c)
+TOBJ := $(TSRC:.c=.o)
+TDEP := $(TSRC:.c=.d)
+
 ifdef DEBUG
 CFLAGS += -O0 -g3 -DMU_DEBUG
 CFLAGS += -fkeep-inline-functions
@@ -19,16 +23,20 @@ endif
 ifdef WORD
 CFLAGS += -m$(WORD)
 endif
+CFLAGS += -I.
 CFLAGS += -std=c99
 CFLAGS += -Wall -Winline
-CFLAGS += -D_POSIX_C_SOURCE=200112L
+CFLAGS += -D_XOPEN_SOURCE=500
 
 LFLAGS += -lpthread
-LFLAGS += -lrt
 
 
 all: $(TARGET)
 
+test: $(TOBJ) $(OBJ)
+	$(CC) $(CFLAGS) $^ $(LFLAGS) -o $(TESTS)
+	$(TESTS)
+
 asm: $(ASM)
 
 size: $(OBJ)
@@ -47,6 +55,8 @@ size: $(OBJ)
 
 clean:
 	rm -f $(TARGET)
+	rm -f $(TESTS)
+	rm -f $(TOBJ) $(TDEP)
 	rm -f $(OBJ)
 	rm -f $(DEP)
 	rm -f $(ASM)

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, int ms, void (*cb)(void*), void *data) {
     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, int ms, void (*cb)(void*), void *data) {
     struct ecallback *e = event_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;

events.h

@@ -9,9 +9,9 @@ extern "C" {
 #endif
 
 // System specific files
-#include "sys/events_tick.h"
-#include "sys/events_mutex.h"
-#include "sys/events_sema.h"
+#include "events_tick.h"
+#include "events_mutex.h"
+#include "events_sema.h"
 
 
 // Event/queue structures
@@ -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 *queue, unsigned size);
+int equeue_create_inplace(equeue_t *queue, unsigned size, void *buffer);
+void equeue_destroy(equeue_t *queue);
 
 // 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 *queue, 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*);
+// Shuts down an unbounded event loop. Already pending events may finish
+// executing, but the queue will not continue looping indefinitely.
+void equeue_break(equeue_t *queue);
 
 // 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 *queue, void (*cb)(void *), void *data);
+int event_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data);
+int event_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data);
 
 // 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 *queue, unsigned size);
+void event_dealloc(equeue_t *queue, void *event);
 
 // 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 *queue, 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 *queue, int event);
 
 
 #ifdef __cplusplus