events: fix astyle

Author: 0xc0170

events/equeue/equeue.c

@@ -23,19 +23,22 @@
 
 // calculate the relative-difference between absolute times while
 // correctly handling overflow conditions
-static inline int equeue_tickdiff(unsigned a, unsigned b) {
+static inline int equeue_tickdiff(unsigned a, unsigned b)
+{
     return (int)(unsigned)(a - b);
 }
 
 // calculate the relative-difference between absolute times, but
 // also clamp to zero, resulting in only non-zero values.
-static inline int equeue_clampdiff(unsigned a, unsigned b) {
+static inline int equeue_clampdiff(unsigned a, unsigned b)
+{
     int diff = equeue_tickdiff(a, b);
-    return ~(diff >> (8*sizeof(int)-1)) & diff;
+    return ~(diff >> (8 * sizeof(int) -1)) & diff;
 }
 
 // Increment the unique id in an event, hiding the event from cancel
-static inline void equeue_incid(equeue_t *q, struct equeue_event *e) {
+static inline void equeue_incid(equeue_t *q, struct equeue_event *e)
+{
     e->id += 1;
     if ((e->id << q->npw2) == 0) {
         e->id = 1;
@@ -44,7 +47,8 @@ static inline void equeue_incid(equeue_t *q, struct equeue_event *e) {
 
 
 // equeue lifetime management
-int equeue_create(equeue_t *q, size_t size) {
+int equeue_create(equeue_t *q, size_t size)
+{
     // dynamically allocate the specified buffer
     void *buffer = malloc(size);
     if (!buffer) {
@@ -56,7 +60,8 @@ int equeue_create(equeue_t *q, size_t size) {
     return err;
 }
 
-int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) {
+int equeue_create_inplace(equeue_t *q, size_t size, void *buffer)
+{
     // setup queue around provided buffer
     q->buffer = buffer;
     q->allocated = 0;
@@ -99,7 +104,8 @@ int equeue_create_inplace(equeue_t *q, size_t size, void *buffer) {
     return 0;
 }
 
-void equeue_destroy(equeue_t *q) {
+void equeue_destroy(equeue_t *q)
+{
     // call destructors on pending events
     for (struct equeue_event *es = q->queue; es; es = es->next) {
         for (struct equeue_event *e = q->queue; e; e = e->sibling) {
@@ -123,10 +129,11 @@ void equeue_destroy(equeue_t *q) {
 
 
 // equeue chunk allocation functions
-static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size) {
+static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size)
+{
     // add event overhead
     size += sizeof(struct equeue_event);
-    size = (size + sizeof(void*)-1) & ~(sizeof(void*)-1);
+    size = (size + sizeof(void *) -1) & ~(sizeof(void *) -1);
 
     equeue_mutex_lock(&q->memlock);
 
@@ -162,7 +169,8 @@ static struct equeue_event *equeue_mem_alloc(equeue_t *q, size_t size) {
     return 0;
 }
 
-static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e) {
+static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e)
+{
     equeue_mutex_lock(&q->memlock);
 
     // stick chunk into list of chunks
@@ -183,7 +191,8 @@ static void equeue_mem_dealloc(equeue_t *q, struct equeue_event *e) {
     equeue_mutex_unlock(&q->memlock);
 }
 
-void *equeue_alloc(equeue_t *q, size_t size) {
+void *equeue_alloc(equeue_t *q, size_t size)
+{
     struct equeue_event *e = equeue_mem_alloc(q, size);
     if (!e) {
         return 0;
@@ -196,19 +205,21 @@ void *equeue_alloc(equeue_t *q, size_t size) {
     return e + 1;
 }
 
-void equeue_dealloc(equeue_t *q, void *p) {
-    struct equeue_event *e = (struct equeue_event*)p - 1;
+void equeue_dealloc(equeue_t *q, void *p)
+{
+    struct equeue_event *e = (struct equeue_event *)p - 1;
 
     if (e->dtor) {
-        e->dtor(e+1);
+        e->dtor(e + 1);
     }
 
     equeue_mem_dealloc(q, e);
 }
 
 
 // equeue scheduling functions
-static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick) {
+static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick)
+{
     // setup event and hash local id with buffer offset for unique id
     int id = (e->id << q->npw2) | ((unsigned char *)e - q->buffer);
     e->target = tick + equeue_clampdiff(e->target, tick);
@@ -245,20 +256,21 @@ static int equeue_enqueue(equeue_t *q, struct equeue_event *e, unsigned tick) {
 
     // notify background timer
     if ((q->background.update && q->background.active) &&
-        (q->queue == e && !e->sibling)) {
+            (q->queue == e && !e->sibling)) {
         q->background.update(q->background.timer,
-                equeue_clampdiff(e->target, tick));
+                             equeue_clampdiff(e->target, tick));
     }
 
     equeue_mutex_unlock(&q->queuelock);
 
     return id;
 }
 
-static struct equeue_event *equeue_unqueue(equeue_t *q, int id) {
+static struct equeue_event *equeue_unqueue(equeue_t *q, int id)
+{
     // decode event from unique id and check that the local id matches
     struct equeue_event *e = (struct equeue_event *)
-            &q->buffer[id & ((1 << q->npw2)-1)];
+                             &q->buffer[id & ((1 << q->npw2) - 1)];
 
     equeue_mutex_lock(&q->queuelock);
     if (e->id != id >> q->npw2) {
@@ -298,7 +310,8 @@ static struct equeue_event *equeue_unqueue(equeue_t *q, int id) {
     return e;
 }
 
-static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target) {
+static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target)
+{
     equeue_mutex_lock(&q->queuelock);
 
     // find all expired events and mark a new generation
@@ -342,8 +355,9 @@ static struct equeue_event *equeue_dequeue(equeue_t *q, unsigned target) {
     return head;
 }
 
-int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
-    struct equeue_event *e = (struct equeue_event*)p - 1;
+int equeue_post(equeue_t *q, void (*cb)(void *), void *p)
+{
+    struct equeue_event *e = (struct equeue_event *)p - 1;
     unsigned tick = equeue_tick();
     e->cb = cb;
     e->target = tick + e->target;
@@ -353,7 +367,8 @@ int equeue_post(equeue_t *q, void (*cb)(void*), void *p) {
     return id;
 }
 
-void equeue_cancel(equeue_t *q, int id) {
+void equeue_cancel(equeue_t *q, int id)
+{
     if (!id) {
         return;
     }
@@ -364,7 +379,8 @@ void equeue_cancel(equeue_t *q, int id) {
     }
 }
 
-int equeue_timeleft(equeue_t *q, int id) {
+int equeue_timeleft(equeue_t *q, int id)
+{
     int ret = -1;
 
     if (!id) {
@@ -373,7 +389,7 @@ int equeue_timeleft(equeue_t *q, int id) {
 
     // decode event from unique id and check that the local id matches
     struct equeue_event *e = (struct equeue_event *)
-            &q->buffer[id & ((1 << q->npw2)-1)];
+                             &q->buffer[id & ((1 << q->npw2) - 1)];
 
     equeue_mutex_lock(&q->queuelock);
     if (e->id == id >> q->npw2) {
@@ -383,14 +399,16 @@ int equeue_timeleft(equeue_t *q, int id) {
     return ret;
 }
 
-void equeue_break(equeue_t *q) {
+void equeue_break(equeue_t *q)
+{
     equeue_mutex_lock(&q->queuelock);
     q->break_requested = true;
     equeue_mutex_unlock(&q->queuelock);
     equeue_sema_signal(&q->eventsema);
 }
 
-void equeue_dispatch(equeue_t *q, int ms) {
+void equeue_dispatch(equeue_t *q, int ms)
+{
     unsigned tick = equeue_tick();
     unsigned timeout = tick + ms;
     q->background.active = false;
@@ -416,7 +434,7 @@ void equeue_dispatch(equeue_t *q, int ms) {
                 equeue_enqueue(q, e, equeue_tick());
             } else {
                 equeue_incid(q, e);
-                equeue_dealloc(q, e+1);
+                equeue_dealloc(q, e + 1);
             }
         }
 
@@ -432,7 +450,7 @@ void equeue_dispatch(equeue_t *q, int ms) {
                     equeue_mutex_lock(&q->queuelock);
                     if (q->background.update && q->queue) {
                         q->background.update(q->background.timer,
-                                equeue_clampdiff(q->queue->target, tick));
+                                             equeue_clampdiff(q->queue->target, tick));
                     }
                     q->background.active = true;
                     equeue_mutex_unlock(&q->queuelock);
@@ -473,34 +491,39 @@ void equeue_dispatch(equeue_t *q, int ms) {
 
 
 // event functions
-void equeue_event_delay(void *p, int ms) {
-    struct equeue_event *e = (struct equeue_event*)p - 1;
+void equeue_event_delay(void *p, int ms)
+{
+    struct equeue_event *e = (struct equeue_event *)p - 1;
     e->target = ms;
 }
 
-void equeue_event_period(void *p, int ms) {
-    struct equeue_event *e = (struct equeue_event*)p - 1;
+void equeue_event_period(void *p, int ms)
+{
+    struct equeue_event *e = (struct equeue_event *)p - 1;
     e->period = ms;
 }
 
-void equeue_event_dtor(void *p, void (*dtor)(void *)) {
-    struct equeue_event *e = (struct equeue_event*)p - 1;
+void equeue_event_dtor(void *p, void (*dtor)(void *))
+{
+    struct equeue_event *e = (struct equeue_event *)p - 1;
     e->dtor = dtor;
 }
 
 
 // simple callbacks
 struct ecallback {
-    void (*cb)(void*);
+    void (*cb)(void *);
     void *data;
 };
 
-static void ecallback_dispatch(void *p) {
-    struct ecallback *e = (struct ecallback*)p;
+static void ecallback_dispatch(void *p)
+{
+    struct ecallback *e = (struct ecallback *)p;
     e->cb(e->data);
 }
 
-int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
+int equeue_call(equeue_t *q, void (*cb)(void *), void *data)
+{
     struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
@@ -511,7 +534,8 @@ int equeue_call(equeue_t *q, void (*cb)(void*), void *data) {
     return equeue_post(q, ecallback_dispatch, e);
 }
 
-int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
+int equeue_call_in(equeue_t *q, int ms, void (*cb)(void *), void *data)
+{
     struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
@@ -523,7 +547,8 @@ int equeue_call_in(equeue_t *q, int ms, void (*cb)(void*), void *data) {
     return equeue_post(q, ecallback_dispatch, e);
 }
 
-int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
+int equeue_call_every(equeue_t *q, int ms, void (*cb)(void *), void *data)
+{
     struct ecallback *e = equeue_alloc(q, sizeof(struct ecallback));
     if (!e) {
         return 0;
@@ -539,7 +564,8 @@ int equeue_call_every(equeue_t *q, int ms, void (*cb)(void*), void *data) {
 
 // backgrounding
 void equeue_background(equeue_t *q,
-        void (*update)(void *timer, int ms), void *timer) {
+                       void (*update)(void *timer, int ms), void *timer)
+{
     equeue_mutex_lock(&q->queuelock);
     if (q->background.update) {
         q->background.update(q->background.timer, -1);
@@ -550,7 +576,7 @@ void equeue_background(equeue_t *q,
 
     if (q->background.update && q->queue) {
         q->background.update(q->background.timer,
-                equeue_clampdiff(q->queue->target, equeue_tick()));
+                             equeue_clampdiff(q->queue->target, equeue_tick()));
     }
     q->background.active = true;
     equeue_mutex_unlock(&q->queuelock);
@@ -562,11 +588,13 @@ struct equeue_chain_context {
     int id;
 };
 
-static void equeue_chain_dispatch(void *p) {
+static void equeue_chain_dispatch(void *p)
+{
     equeue_dispatch((equeue_t *)p, 0);
 }
 
-static void equeue_chain_update(void *p, int ms) {
+static void equeue_chain_update(void *p, int ms)
+{
     struct equeue_chain_context *c = (struct equeue_chain_context *)p;
     equeue_cancel(c->target, c->id);
 
@@ -577,14 +605,15 @@ static void equeue_chain_update(void *p, int ms) {
     }
 }
 
-void equeue_chain(equeue_t *q, equeue_t *target) {
+void equeue_chain(equeue_t *q, equeue_t *target)
+{
     if (!target) {
         equeue_background(q, 0, 0);
         return;
     }
 
     struct equeue_chain_context *c = equeue_alloc(q,
-            sizeof(struct equeue_chain_context));
+                                                  sizeof(struct equeue_chain_context));
 
     c->q = q;
     c->target = target;