research st: refine sync.

@@ -44,14 +44,12 @@
 #include <errno.h>
 #include <errno.h>
 #include "common.h"
 #include "common.h"
 
 
-
 extern time_t _st_curr_time;
 extern time_t _st_curr_time;
 extern st_utime_t _st_last_tset;
 extern st_utime_t _st_last_tset;
 extern int _st_active_count;
 extern int _st_active_count;
 
 
 static st_utime_t (*_st_utime)(void) = NULL;
 static st_utime_t (*_st_utime)(void) = NULL;
 
 
-
 /*****************************************
 /*****************************************
  * Time functions
  * Time functions
  */
  */
@@ -62,14 +60,13 @@ st_utime_t st_utime(void)
 #ifdef MD_GET_UTIME
 #ifdef MD_GET_UTIME
         MD_GET_UTIME();
         MD_GET_UTIME();
 #else
 #else
-#error Unknown OS
+        #error Unknown OS
 #endif
 #endif
     }
     }
     
     
     return (*_st_utime)();
     return (*_st_utime)();
 }
 }
 
 
-
 int st_set_utime_function(st_utime_t (*func)(void))
 int st_set_utime_function(st_utime_t (*func)(void))
 {
 {
     if (_st_active_count) {
     if (_st_active_count) {
@@ -82,13 +79,11 @@ int st_set_utime_function(st_utime_t (*func)(void))
     return 0;
     return 0;
 }
 }
 
 
-
 st_utime_t st_utime_last_clock(void)
 st_utime_t st_utime_last_clock(void)
 {
 {
     return _ST_LAST_CLOCK;
     return _ST_LAST_CLOCK;
 }
 }
 
 
-
 int st_timecache_set(int on)
 int st_timecache_set(int on)
 {
 {
     int wason = (_st_curr_time) ? 1 : 0;
     int wason = (_st_curr_time) ? 1 : 0;
@@ -96,22 +91,22 @@ int st_timecache_set(int on)
     if (on) {
     if (on) {
         _st_curr_time = time(NULL);
         _st_curr_time = time(NULL);
         _st_last_tset = st_utime();
         _st_last_tset = st_utime();
-  } else
+    } else {
         _st_curr_time = 0;
         _st_curr_time = 0;
+    }
     
     
     return wason;
     return wason;
 }
 }
 
 
-
 time_t st_time(void)
 time_t st_time(void)
 {
 {
-  if (_st_curr_time)
+    if (_st_curr_time) {
         return _st_curr_time;
         return _st_curr_time;
+    }
     
     
     return time(NULL);
     return time(NULL);
 }
 }
 
 
-
 int st_usleep(st_utime_t usecs)
 int st_usleep(st_utime_t usecs)
 {
 {
     _st_thread_t *me = _ST_CURRENT_THREAD();
     _st_thread_t *me = _ST_CURRENT_THREAD();
@@ -125,8 +120,9 @@ int st_usleep(st_utime_t usecs)
     if (usecs != ST_UTIME_NO_TIMEOUT) {
     if (usecs != ST_UTIME_NO_TIMEOUT) {
         me->state = _ST_ST_SLEEPING;
         me->state = _ST_ST_SLEEPING;
         _ST_ADD_SLEEPQ(me, usecs);
         _ST_ADD_SLEEPQ(me, usecs);
-  } else
+    } else {
         me->state = _ST_ST_SUSPENDED;
         me->state = _ST_ST_SUSPENDED;
+    }
     
     
     _ST_SWITCH_CONTEXT(me);
     _ST_SWITCH_CONTEXT(me);
     
     
@@ -139,18 +135,14 @@ int st_usleep(st_utime_t usecs)
     return 0;
     return 0;
 }
 }
 
 
-
 int st_sleep(int secs)
 int st_sleep(int secs)
 {
 {
-  return st_usleep((secs >= 0) ? secs * (st_utime_t) 1000000LL :
-                 ST_UTIME_NO_TIMEOUT);
+    return st_usleep((secs >= 0) ? secs * (st_utime_t) 1000000LL : ST_UTIME_NO_TIMEOUT);
 }
 }
 
 
-
 /*****************************************
 /*****************************************
  * Condition variable functions
  * Condition variable functions
  */
  */
-
 _st_cond_t *st_cond_new(void)
 _st_cond_t *st_cond_new(void)
 {
 {
     _st_cond_t *cvar;
     _st_cond_t *cvar;
@@ -163,7 +155,6 @@ _st_cond_t *st_cond_new(void)
     return cvar;
     return cvar;
 }
 }
 
 
-
 int st_cond_destroy(_st_cond_t *cvar)
 int st_cond_destroy(_st_cond_t *cvar)
 {
 {
     if (cvar->wait_q.next != &cvar->wait_q) {
     if (cvar->wait_q.next != &cvar->wait_q) {
@@ -176,7 +167,6 @@ int st_cond_destroy(_st_cond_t *cvar)
     return 0;
     return 0;
 }
 }
 
 
-
 int st_cond_timedwait(_st_cond_t *cvar, st_utime_t timeout)
 int st_cond_timedwait(_st_cond_t *cvar, st_utime_t timeout)
 {
 {
     _st_thread_t *me = _ST_CURRENT_THREAD();
     _st_thread_t *me = _ST_CURRENT_THREAD();
@@ -192,8 +182,9 @@ int st_cond_timedwait(_st_cond_t *cvar, st_utime_t timeout)
     me->state = _ST_ST_COND_WAIT;
     me->state = _ST_ST_COND_WAIT;
     ST_APPEND_LINK(&me->wait_links, &cvar->wait_q);
     ST_APPEND_LINK(&me->wait_links, &cvar->wait_q);
     
     
-  if (timeout != ST_UTIME_NO_TIMEOUT)
+    if (timeout != ST_UTIME_NO_TIMEOUT) {
         _ST_ADD_SLEEPQ(me, timeout);
         _ST_ADD_SLEEPQ(me, timeout);
+    }
     
     
     _ST_SWITCH_CONTEXT(me);
     _ST_SWITCH_CONTEXT(me);
     
     
@@ -214,13 +205,11 @@ int st_cond_timedwait(_st_cond_t *cvar, st_utime_t timeout)
     return rv;
     return rv;
 }
 }
 
 
-
 int st_cond_wait(_st_cond_t *cvar)
 int st_cond_wait(_st_cond_t *cvar)
 {
 {
     return st_cond_timedwait(cvar, ST_UTIME_NO_TIMEOUT);
     return st_cond_timedwait(cvar, ST_UTIME_NO_TIMEOUT);
 }
 }
 
 
-
 static int _st_cond_signal(_st_cond_t *cvar, int broadcast)
 static int _st_cond_signal(_st_cond_t *cvar, int broadcast)
 {
 {
     _st_thread_t *thread;
     _st_thread_t *thread;
@@ -229,37 +218,35 @@ static int _st_cond_signal(_st_cond_t *cvar, int broadcast)
     for (q = cvar->wait_q.next; q != &cvar->wait_q; q = q->next) {
     for (q = cvar->wait_q.next; q != &cvar->wait_q; q = q->next) {
         thread = _ST_THREAD_WAITQ_PTR(q);
         thread = _ST_THREAD_WAITQ_PTR(q);
         if (thread->state == _ST_ST_COND_WAIT) {
         if (thread->state == _ST_ST_COND_WAIT) {
-      if (thread->flags & _ST_FL_ON_SLEEPQ)
+            if (thread->flags & _ST_FL_ON_SLEEPQ) {
                 _ST_DEL_SLEEPQ(thread);
                 _ST_DEL_SLEEPQ(thread);
+            }
             
             
             /* Make thread runnable */
             /* Make thread runnable */
             thread->state = _ST_ST_RUNNABLE;
             thread->state = _ST_ST_RUNNABLE;
             _ST_ADD_RUNQ(thread);
             _ST_ADD_RUNQ(thread);
-      if (!broadcast)
+            if (!broadcast) {
                 break;
                 break;
             }
             }
         }
         }
+    }
     
     
     return 0;
     return 0;
 }
 }
 
 
-
 int st_cond_signal(_st_cond_t *cvar)
 int st_cond_signal(_st_cond_t *cvar)
 {
 {
     return _st_cond_signal(cvar, 0);
     return _st_cond_signal(cvar, 0);
 }
 }
 
 
-
 int st_cond_broadcast(_st_cond_t *cvar)
 int st_cond_broadcast(_st_cond_t *cvar)
 {
 {
     return _st_cond_signal(cvar, 1);
     return _st_cond_signal(cvar, 1);
 }
 }
 
 
-
 /*****************************************
 /*****************************************
  * Mutex functions
  * Mutex functions
  */
  */
-
 _st_mutex_t *st_mutex_new(void)
 _st_mutex_t *st_mutex_new(void)
 {
 {
     _st_mutex_t *lock;
     _st_mutex_t *lock;
@@ -273,7 +260,6 @@ _st_mutex_t *st_mutex_new(void)
     return lock;
     return lock;
 }
 }
 
 
-
 int st_mutex_destroy(_st_mutex_t *lock)
 int st_mutex_destroy(_st_mutex_t *lock)
 {
 {
     if (lock->owner != NULL || lock->wait_q.next != &lock->wait_q) {
     if (lock->owner != NULL || lock->wait_q.next != &lock->wait_q) {
@@ -286,7 +272,6 @@ int st_mutex_destroy(_st_mutex_t *lock)
     return 0;
     return 0;
 }
 }
 
 
-
 int st_mutex_lock(_st_mutex_t *lock)
 int st_mutex_lock(_st_mutex_t *lock)
 {
 {
     _st_thread_t *me = _ST_CURRENT_THREAD();
     _st_thread_t *me = _ST_CURRENT_THREAD();
@@ -325,7 +310,6 @@ int st_mutex_lock(_st_mutex_t *lock)
     return 0;
     return 0;
 }
 }
 
 
-
 int st_mutex_unlock(_st_mutex_t *lock)
 int st_mutex_unlock(_st_mutex_t *lock)
 {
 {
     _st_thread_t *thread;
     _st_thread_t *thread;
@@ -353,7 +337,6 @@ int st_mutex_unlock(_st_mutex_t *lock)
     return 0;
     return 0;
 }
 }
 
 
-
 int st_mutex_trylock(_st_mutex_t *lock)
 int st_mutex_trylock(_st_mutex_t *lock)
 {
 {
     if (lock->owner != NULL) {
     if (lock->owner != NULL) {