events: fix events coding style

events/equeue/equeue_mbed.cpp

@@ -35,7 +35,8 @@ using namespace mbed;
 // Ticker operations
 #if MBED_CONF_RTOS_PRESENT
 
-unsigned equeue_tick() {
+unsigned equeue_tick()
+{
     return osKernelGetTickCount();
 }
 
@@ -55,20 +56,22 @@ unsigned equeue_tick() {
 static bool equeue_tick_inited = false;
 static volatile unsigned equeue_minutes = 0;
 static unsigned equeue_timer[
-        (sizeof(ALIAS_TIMER)+sizeof(unsigned)-1)/sizeof(unsigned)];
+     (sizeof(ALIAS_TIMER) + sizeof(unsigned) - 1) / sizeof(unsigned)];
 static unsigned equeue_ticker[
-        (sizeof(ALIAS_TICKER)+sizeof(unsigned)-1)/sizeof(unsigned)];
+     (sizeof(ALIAS_TICKER) + sizeof(unsigned) - 1) / sizeof(unsigned)];
 
-static void equeue_tick_update() {
-    equeue_minutes += reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->read_ms();
-    reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->reset();
+static void equeue_tick_update()
+{
+    equeue_minutes += reinterpret_cast<ALIAS_TIMER *>(equeue_timer)->read_ms();
+    reinterpret_cast<ALIAS_TIMER *>(equeue_timer)->reset();
 }
 
-static void equeue_tick_init() {
+static void equeue_tick_init()
+{
     MBED_STATIC_ASSERT(sizeof(equeue_timer) >= sizeof(ALIAS_TIMER),
-            "The equeue_timer buffer must fit the class Timer");
+                       "The equeue_timer buffer must fit the class Timer");
     MBED_STATIC_ASSERT(sizeof(equeue_ticker) >= sizeof(ALIAS_TICKER),
-            "The equeue_ticker buffer must fit the class Ticker");
+                       "The equeue_ticker buffer must fit the class Ticker");
     ALIAS_TIMER *timer = new (equeue_timer) ALIAS_TIMER;
     ALIAS_TICKER *ticker = new (equeue_ticker) ALIAS_TICKER;
 
@@ -79,7 +82,8 @@ static void equeue_tick_init() {
     equeue_tick_inited = true;
 }
 
-unsigned equeue_tick() {
+unsigned equeue_tick()
+{
     if (!equeue_tick_inited) {
         equeue_tick_init();
     }
@@ -89,7 +93,7 @@ unsigned equeue_tick() {
 
     do {
         minutes = equeue_minutes;
-        ms = reinterpret_cast<ALIAS_TIMER*>(equeue_timer)->read_ms();
+        ms = reinterpret_cast<ALIAS_TIMER *>(equeue_timer)->read_ms();
     } while (minutes != equeue_minutes);
 
     return minutes + ms;
@@ -98,14 +102,19 @@ unsigned equeue_tick() {
 #endif
 
 // Mutex operations
-int equeue_mutex_create(equeue_mutex_t *m) { return 0; }
+int equeue_mutex_create(equeue_mutex_t *m)
+{
+    return 0;
+}
 void equeue_mutex_destroy(equeue_mutex_t *m) { }
 
-void equeue_mutex_lock(equeue_mutex_t *m) {
+void equeue_mutex_lock(equeue_mutex_t *m)
+{
     core_util_critical_section_enter();
 }
 
-void equeue_mutex_unlock(equeue_mutex_t *m) {
+void equeue_mutex_unlock(equeue_mutex_t *m)
+{
     core_util_critical_section_exit();
 }
 
@@ -113,7 +122,8 @@ void equeue_mutex_unlock(equeue_mutex_t *m) {
 // Semaphore operations
 #ifdef MBED_CONF_RTOS_PRESENT
 
-int equeue_sema_create(equeue_sema_t *s) {
+int equeue_sema_create(equeue_sema_t *s)
+{
     osEventFlagsAttr_t attr;
     memset(&attr, 0, sizeof(attr));
     attr.cb_mem = &s->mem;
@@ -123,15 +133,18 @@ int equeue_sema_create(equeue_sema_t *s) {
     return !s->id ? -1 : 0;
 }
 
-void equeue_sema_destroy(equeue_sema_t *s) {
+void equeue_sema_destroy(equeue_sema_t *s)
+{
     osEventFlagsDelete(s->id);
 }
 
-void equeue_sema_signal(equeue_sema_t *s) {
+void equeue_sema_signal(equeue_sema_t *s)
+{
     osEventFlagsSet(s->id, 1);
 }
 
-bool equeue_sema_wait(equeue_sema_t *s, int ms) {
+bool equeue_sema_wait(equeue_sema_t *s, int ms)
+{
     if (ms < 0) {
         ms = osWaitForever;
     }
@@ -142,29 +155,34 @@ bool equeue_sema_wait(equeue_sema_t *s, int ms) {
 #else
 
 // Semaphore operations
-int equeue_sema_create(equeue_sema_t *s) {
+int equeue_sema_create(equeue_sema_t *s)
+{
     *s = false;
     return 0;
 }
 
-void equeue_sema_destroy(equeue_sema_t *s) {
+void equeue_sema_destroy(equeue_sema_t *s)
+{
 }
 
-void equeue_sema_signal(equeue_sema_t *s) {
+void equeue_sema_signal(equeue_sema_t *s)
+{
     *s = 1;
 }
 
-static void equeue_sema_timeout(equeue_sema_t *s) {
+static void equeue_sema_timeout(equeue_sema_t *s)
+{
     *s = -1;
 }
 
-bool equeue_sema_wait(equeue_sema_t *s, int ms) {
+bool equeue_sema_wait(equeue_sema_t *s, int ms)
+{
     int signal = 0;
     ALIAS_TIMEOUT timeout;
     if (ms == 0) {
         return false;
     } else if (ms > 0) {
-        timeout.attach_us(callback(equeue_sema_timeout, s), (us_timestamp_t)ms*1000);
+        timeout.attach_us(callback(equeue_sema_timeout, s), (us_timestamp_t)ms * 1000);
     }
 
     core_util_critical_section_enter();