Standardized parameter names in function declarations

events.h

@@ -51,21 +51,21 @@ typedef struct equeue {
 // Queue operations
 //
 // Creation results in negative value on failure.
-int equeue_create(equeue_t*, unsigned size);
-int equeue_create_inplace(equeue_t*, unsigned size, void *buffer);
-void equeue_destroy(equeue_t*);
+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(equeue_t*, 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(equeue_t*);
+// 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(equeue_t*);
 //
 // 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(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);
+int event_call(equeue_t *queue, void (*cb)(void *), void *data);
+int event_call_in(equeue_t *queue, void (*cb)(void *), void *data, int ms);
+int event_call_every(equeue_t *queue, void (*cb)(void *), void *data, int ms);
 
 // Events with queue handled blocks of memory
 //
@@ -90,8 +90,8 @@ int event_call_every(equeue_t*, 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(equeue_t*, unsigned size);
-void event_dealloc(equeue_t*, 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(equeue_t*, 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(equeue_t*, int event);
+void event_cancel(equeue_t *queue, int event);
 
 
 #ifdef __cplusplus

events_mutex.h

@@ -23,10 +23,10 @@ typedef unsigned events_mutex_t;
 
 
 // Mutex operations
-int events_mutex_create(events_mutex_t *m);
-void events_mutex_destroy(events_mutex_t *m);
-void events_mutex_lock(events_mutex_t *m);
-void events_mutex_unlock(events_mutex_t *m);
+int events_mutex_create(events_mutex_t *mutex);
+void events_mutex_destroy(events_mutex_t *mutex);
+void events_mutex_lock(events_mutex_t *mutex);
+void events_mutex_unlock(events_mutex_t *mutex);
 
 
 #ifdef __cplusplus

events_sema.h

@@ -31,10 +31,10 @@ typedef struct {} events_sema_t;
 
 
 // Semaphore operations
-int events_sema_create(events_sema_t *s);
-void events_sema_destroy(events_sema_t *s);
-void events_sema_release(events_sema_t *s);
-bool events_sema_wait(events_sema_t *s, int ms);
+int events_sema_create(events_sema_t *sema);
+void events_sema_destroy(events_sema_t *sema);
+void events_sema_release(events_sema_t *sema);
+bool events_sema_wait(events_sema_t *sema, int ms);
 
 
 #ifdef __cplusplus