format code

35 files changed, 302 insertions, 442 deletions

diff --git a/core/src/xmake/thread/event_exit.c b/core/src/xmake/thread/event_exit.c
index 54e977068..501a72a8f 100644
--- a/core/src/xmake/thread/event_exit.c
+++ b/core/src/xmake/thread/event_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_event"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_event"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,17 +33,14 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_event_exit(lua_State* lua)
-{
+tb_int_t xm_thread_event_exit(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_event_t* thread_event = xm_thread_event_get(lua, 1);
+    xm_thread_event_t *thread_event = xm_thread_event_get(lua, 1);
     tb_assert_and_check_return_val(thread_event && thread_event->handle, 0);
 
-    if (tb_atomic_fetch_and_sub(&thread_event->refn, 1) == 1)
-    {
-        if (thread_event->handle)
-        {
+    if (tb_atomic_fetch_and_sub(&thread_event->refn, 1) == 1) {
+        if (thread_event->handle) {
             tb_event_exit(thread_event->handle);
             thread_event->handle = tb_null;
         }
@@ -52,4 +49,3 @@ tb_int_t xm_thread_event_exit(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/event_incref.c b/core/src/xmake/thread/event_incref.c
index ff8b658d9..28c631056 100644
--- a/core/src/xmake/thread/event_incref.c
+++ b/core/src/xmake/thread/event_incref.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_event"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_event"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_event_incref(lua_State* lua)
-{
+tb_int_t xm_thread_event_incref(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_event_t* thread_event = xm_thread_event_get(lua, 1);
+    xm_thread_event_t *thread_event = xm_thread_event_get(lua, 1);
     tb_assert_and_check_return_val(thread_event && thread_event->handle, 0);
 
     lua_pushboolean(lua, tb_atomic_fetch_and_add(&thread_event->refn, 1) >= 1);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/event_init.c b/core/src/xmake/thread/event_init.c
index 942537718..d661939b0 100644
--- a/core/src/xmake/thread/event_init.c
+++ b/core/src/xmake/thread/event_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_event"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_event"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,18 +33,16 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_event_init(lua_State* lua)
-{
+tb_int_t xm_thread_event_init(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_event_t* thread_event = tb_null;
-    do
-    {
+    tb_bool_t          ok           = tb_false;
+    xm_thread_event_t *thread_event = tb_null;
+    do {
         thread_event = tb_malloc0_type(xm_thread_event_t);
         tb_assert_and_check_break(thread_event);
 
-        thread_event->refn = 1;
+        thread_event->refn   = 1;
         thread_event->handle = tb_event_init();
         tb_assert_and_check_break(thread_event->handle);
 
@@ -53,12 +51,9 @@ tb_int_t xm_thread_event_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread_event)
-        {
-            if (thread_event->handle)
-            {
+    if (!ok) {
+        if (thread_event) {
+            if (thread_event->handle) {
                 tb_event_exit(thread_event->handle);
                 thread_event->handle = tb_null;
             }
diff --git a/core/src/xmake/thread/event_post.c b/core/src/xmake/thread/event_post.c
index 0b8e5dabd..0762f6af1 100644
--- a/core/src/xmake/thread/event_post.c
+++ b/core/src/xmake/thread/event_post.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_event"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_event"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_event_post(lua_State* lua)
-{
+tb_int_t xm_thread_event_post(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_event_t* thread_event = xm_thread_event_get(lua, 1);
+    xm_thread_event_t *thread_event = xm_thread_event_get(lua, 1);
     tb_assert_and_check_return_val(thread_event && thread_event->handle, 0);
 
     lua_pushboolean(lua, tb_event_post(thread_event->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/event_wait.c b/core/src/xmake/thread/event_wait.c
index d6d628311..73e476427 100644
--- a/core/src/xmake/thread/event_wait.c
+++ b/core/src/xmake/thread/event_wait.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_event"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_event"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,15 +33,13 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_event_wait(lua_State* lua)
-{
+tb_int_t xm_thread_event_wait(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_event_t* thread_event = xm_thread_event_get(lua, 1);
+    xm_thread_event_t *thread_event = xm_thread_event_get(lua, 1);
     tb_assert_and_check_return_val(thread_event && thread_event->handle, 0);
 
     tb_long_t timeout = (tb_long_t)luaL_checknumber(lua, 2);
     lua_pushinteger(lua, tb_event_wait(thread_event->handle, timeout));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/mutex_exit.c b/core/src/xmake/thread/mutex_exit.c
index 39d69ab8a..f415de339 100644
--- a/core/src/xmake/thread/mutex_exit.c
+++ b/core/src/xmake/thread/mutex_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,17 +33,14 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_exit(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_exit(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_mutex_t* thread_mutex = xm_thread_mutex_get(lua, 1);
+    xm_thread_mutex_t *thread_mutex = xm_thread_mutex_get(lua, 1);
     tb_assert_and_check_return_val(thread_mutex && thread_mutex->handle, 0);
 
-    if (tb_atomic_fetch_and_sub(&thread_mutex->refn, 1) == 1)
-    {
-        if (thread_mutex->handle)
-        {
+    if (tb_atomic_fetch_and_sub(&thread_mutex->refn, 1) == 1) {
+        if (thread_mutex->handle) {
             tb_mutex_exit(thread_mutex->handle);
             thread_mutex->handle = tb_null;
         }
@@ -52,4 +49,3 @@ tb_int_t xm_thread_mutex_exit(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/mutex_incref.c b/core/src/xmake/thread/mutex_incref.c
index 34a234757..3706ec276 100644
--- a/core/src/xmake/thread/mutex_incref.c
+++ b/core/src/xmake/thread/mutex_incref.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_incref(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_incref(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_mutex_t* thread_mutex = xm_thread_mutex_get(lua, 1);
+    xm_thread_mutex_t *thread_mutex = xm_thread_mutex_get(lua, 1);
     tb_assert_and_check_return_val(thread_mutex && thread_mutex->handle, 0);
 
     lua_pushboolean(lua, tb_atomic_fetch_and_add(&thread_mutex->refn, 1) >= 1);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/mutex_init.c b/core/src/xmake/thread/mutex_init.c
index ff69e82ad..bca78a134 100644
--- a/core/src/xmake/thread/mutex_init.c
+++ b/core/src/xmake/thread/mutex_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,18 +33,16 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_init(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_init(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_mutex_t* thread_mutex = tb_null;
-    do
-    {
+    tb_bool_t          ok           = tb_false;
+    xm_thread_mutex_t *thread_mutex = tb_null;
+    do {
         thread_mutex = tb_malloc0_type(xm_thread_mutex_t);
         tb_assert_and_check_break(thread_mutex);
 
-        thread_mutex->refn = 1;
+        thread_mutex->refn   = 1;
         thread_mutex->handle = tb_mutex_init();
         tb_assert_and_check_break(thread_mutex->handle);
 
@@ -53,12 +51,9 @@ tb_int_t xm_thread_mutex_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread_mutex)
-        {
-            if (thread_mutex->handle)
-            {
+    if (!ok) {
+        if (thread_mutex) {
+            if (thread_mutex->handle) {
                 tb_mutex_exit(thread_mutex->handle);
                 thread_mutex->handle = tb_null;
             }
diff --git a/core/src/xmake/thread/mutex_lock.c b/core/src/xmake/thread/mutex_lock.c
index 380301da1..f5e9154ae 100644
--- a/core/src/xmake/thread/mutex_lock.c
+++ b/core/src/xmake/thread/mutex_lock.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_lock(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_lock(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_mutex_t* thread_mutex = xm_thread_mutex_get(lua, 1);
+    xm_thread_mutex_t *thread_mutex = xm_thread_mutex_get(lua, 1);
     tb_assert_and_check_return_val(thread_mutex && thread_mutex->handle, 0);
 
     lua_pushboolean(lua, tb_mutex_enter(thread_mutex->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/mutex_trylock.c b/core/src/xmake/thread/mutex_trylock.c
index 7b83f3a90..fdc90e883 100644
--- a/core/src/xmake/thread/mutex_trylock.c
+++ b/core/src/xmake/thread/mutex_trylock.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_trylock(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_trylock(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_mutex_t* thread_mutex = xm_thread_mutex_get(lua, 1);
+    xm_thread_mutex_t *thread_mutex = xm_thread_mutex_get(lua, 1);
     tb_assert_and_check_return_val(thread_mutex && thread_mutex->handle, 0);
 
     lua_pushboolean(lua, tb_mutex_enter_try(thread_mutex->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/mutex_unlock.c b/core/src/xmake/thread/mutex_unlock.c
index beb0c9e0a..93503e197 100644
--- a/core/src/xmake/thread/mutex_unlock.c
+++ b/core/src/xmake/thread/mutex_unlock.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_mutex"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_mutex"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_mutex_unlock(lua_State* lua)
-{
+tb_int_t xm_thread_mutex_unlock(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_mutex_t* thread_mutex = xm_thread_mutex_get(lua, 1);
+    xm_thread_mutex_t *thread_mutex = xm_thread_mutex_get(lua, 1);
     tb_assert_and_check_return_val(thread_mutex && thread_mutex->handle, 0);
 
     lua_pushboolean(lua, tb_mutex_leave(thread_mutex->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/prefix.h b/core/src/xmake/thread/prefix.h
index 2b841e6a7..9b038a8cb 100644
--- a/core/src/xmake/thread/prefix.h
+++ b/core/src/xmake/thread/prefix.h
@@ -31,126 +31,112 @@
  */
 
 // the thread type
-typedef struct __xm_thread_t
-{
+typedef struct __xm_thread_t {
     tb_thread_ref_t handle;
     tb_string_t     callback;
     tb_string_t     callinfo;
-
-}xm_thread_t;
+} xm_thread_t;
 
 // the thread value kind
-typedef enum __xm_thread_value_kind_e
-{
+typedef enum __xm_thread_value_kind_e {
     XM_THREAD_VALUE_NIL  = 0,
     XM_THREAD_VALUE_BOOL = 1,
     XM_THREAD_VALUE_INT  = 2,
     XM_THREAD_VALUE_NUM  = 3,
     XM_THREAD_VALUE_STR  = 4
-
-}xm_thread_value_kind_e;
+} xm_thread_value_kind_e;
 
 // the thread value type
-typedef struct __xm_thread_value_t
-{
-    tb_uint32_t     kind : 3;
-    tb_uint32_t     size : 29;
-    union
-    {
-        tb_char_t*  string;
+typedef struct __xm_thread_value_t {
+    tb_uint32_t kind : 3;
+    tb_uint32_t size : 29;
+    union {
+        tb_char_t  *string;
         tb_bool_t   boolean;
         lua_Integer integer;
         lua_Number  number;
     } u;
-
-}xm_thread_value_t;
+} xm_thread_value_t;
 
 // the thread event type
-typedef struct __xm_thread_event_t
-{
-    tb_event_ref_t  handle;
-    tb_atomic_t     refn;
-
-}xm_thread_event_t;
+typedef struct __xm_thread_event_t {
+    tb_event_ref_t handle;
+    tb_atomic_t    refn;
+} xm_thread_event_t;
 
 // the thread mutex type
-typedef struct __xm_thread_mutex_t
-{
-    tb_mutex_ref_t  handle;
-    tb_atomic_t     refn;
-
-}xm_thread_mutex_t;
+typedef struct __xm_thread_mutex_t {
+    tb_mutex_ref_t handle;
+    tb_atomic_t    refn;
+} xm_thread_mutex_t;
 
 // the thread semaphore type
-typedef struct __xm_thread_semaphore_t
-{
+typedef struct __xm_thread_semaphore_t {
     tb_semaphore_ref_t handle;
     tb_atomic_t        refn;
-
-}xm_thread_semaphore_t;
+} xm_thread_semaphore_t;
 
 // the thread queue type
-typedef struct __xm_thread_queue_t
-{
-    tb_queue_ref_t  handle;
-    tb_atomic_t     refn;
-
-}xm_thread_queue_t;
+typedef struct __xm_thread_queue_t {
+    tb_queue_ref_t handle;
+    tb_atomic_t    refn;
+} xm_thread_queue_t;
 
 // the thread sharedata type
-typedef struct __xm_thread_sharedata_t
-{
+typedef struct __xm_thread_sharedata_t {
     xm_thread_value_t value;
     tb_buffer_t       buffer;
     tb_atomic_t       refn;
-
-}xm_thread_sharedata_t;
+} xm_thread_sharedata_t;
 
 // get the thread event from arguments
-static __tb_inline__ xm_thread_event_t* xm_thread_event_get(lua_State* lua, tb_int_t index)
-{
-    xm_thread_event_t* thread_event = tb_null;
-    if (xm_lua_isinteger(lua, index)) thread_event = (xm_thread_event_t*)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
-    else if (xm_lua_ispointer(lua, index)) thread_event = (xm_thread_event_t*)xm_lua_topointer(lua, index);
+static __tb_inline__ xm_thread_event_t *xm_thread_event_get(lua_State *lua, tb_int_t index) {
+    xm_thread_event_t *thread_event = tb_null;
+    if (xm_lua_isinteger(lua, index))
+        thread_event = (xm_thread_event_t *)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
+    else if (xm_lua_ispointer(lua, index))
+        thread_event = (xm_thread_event_t *)xm_lua_topointer(lua, index);
     return thread_event;
 }
 
 // get the thread mutex from arguments
-static __tb_inline__ xm_thread_mutex_t* xm_thread_mutex_get(lua_State* lua, tb_int_t index)
-{
-    xm_thread_mutex_t* thread_mutex = tb_null;
-    if (xm_lua_isinteger(lua, index)) thread_mutex = (xm_thread_mutex_t*)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
-    else if (xm_lua_ispointer(lua, index)) thread_mutex = (xm_thread_mutex_t*)xm_lua_topointer(lua, index);
+static __tb_inline__ xm_thread_mutex_t *xm_thread_mutex_get(lua_State *lua, tb_int_t index) {
+    xm_thread_mutex_t *thread_mutex = tb_null;
+    if (xm_lua_isinteger(lua, index))
+        thread_mutex = (xm_thread_mutex_t *)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
+    else if (xm_lua_ispointer(lua, index))
+        thread_mutex = (xm_thread_mutex_t *)xm_lua_topointer(lua, index);
     return thread_mutex;
 }
 
 // get the thread semaphore from arguments
-static __tb_inline__ xm_thread_semaphore_t* xm_thread_semaphore_get(lua_State* lua, tb_int_t index)
-{
-    xm_thread_semaphore_t* thread_semaphore = tb_null;
-    if (xm_lua_isinteger(lua, index)) thread_semaphore = (xm_thread_semaphore_t*)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
-    else if (xm_lua_ispointer(lua, index)) thread_semaphore = (xm_thread_semaphore_t*)xm_lua_topointer(lua, index);
+static __tb_inline__ xm_thread_semaphore_t *xm_thread_semaphore_get(lua_State *lua, tb_int_t index) {
+    xm_thread_semaphore_t *thread_semaphore = tb_null;
+    if (xm_lua_isinteger(lua, index))
+        thread_semaphore = (xm_thread_semaphore_t *)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
+    else if (xm_lua_ispointer(lua, index))
+        thread_semaphore = (xm_thread_semaphore_t *)xm_lua_topointer(lua, index);
     return thread_semaphore;
 }
 
 // get the thread queue from arguments
-static __tb_inline__ xm_thread_queue_t* xm_thread_queue_get(lua_State* lua, tb_int_t index)
-{
-    xm_thread_queue_t* thread_queue = tb_null;
-    if (xm_lua_isinteger(lua, index)) thread_queue = (xm_thread_queue_t*)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
-    else if (xm_lua_ispointer(lua, index)) thread_queue = (xm_thread_queue_t*)xm_lua_topointer(lua, index);
+static __tb_inline__ xm_thread_queue_t *xm_thread_queue_get(lua_State *lua, tb_int_t index) {
+    xm_thread_queue_t *thread_queue = tb_null;
+    if (xm_lua_isinteger(lua, index))
+        thread_queue = (xm_thread_queue_t *)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
+    else if (xm_lua_ispointer(lua, index))
+        thread_queue = (xm_thread_queue_t *)xm_lua_topointer(lua, index);
     return thread_queue;
 }
 
 // get the thread sharedata from arguments
-static __tb_inline__ xm_thread_sharedata_t* xm_thread_sharedata_get(lua_State* lua, tb_int_t index)
-{
-    xm_thread_sharedata_t* thread_sharedata = tb_null;
-    if (xm_lua_isinteger(lua, index)) thread_sharedata = (xm_thread_sharedata_t*)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
-    else if (xm_lua_ispointer(lua, index)) thread_sharedata = (xm_thread_sharedata_t*)xm_lua_topointer(lua, index);
+static __tb_inline__ xm_thread_sharedata_t *xm_thread_sharedata_get(lua_State *lua, tb_int_t index) {
+    xm_thread_sharedata_t *thread_sharedata = tb_null;
+    if (xm_lua_isinteger(lua, index))
+        thread_sharedata = (xm_thread_sharedata_t *)(tb_size_t)(tb_long_t)lua_tointeger(lua, index);
+    else if (xm_lua_ispointer(lua, index))
+        thread_sharedata = (xm_thread_sharedata_t *)xm_lua_topointer(lua, index);
     return thread_sharedata;
 }
 
 #endif
-
-
diff --git a/core/src/xmake/thread/queue_clear.c b/core/src/xmake/thread/queue_clear.c
index 4888babe2..021475a14 100644
--- a/core/src/xmake/thread/queue_clear.c
+++ b/core/src/xmake/thread/queue_clear.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,15 +33,13 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_clear(lua_State* lua)
-{
+tb_int_t xm_thread_queue_clear(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
     tb_queue_clear(thread_queue->handle);
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/queue_exit.c b/core/src/xmake/thread/queue_exit.c
index 8178ea22f..c30c6b97c 100644
--- a/core/src/xmake/thread/queue_exit.c
+++ b/core/src/xmake/thread/queue_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,17 +33,14 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_exit(lua_State* lua)
-{
+tb_int_t xm_thread_queue_exit(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
-    if (tb_atomic_fetch_and_sub(&thread_queue->refn, 1) == 1)
-    {
-        if (thread_queue->handle)
-        {
+    if (tb_atomic_fetch_and_sub(&thread_queue->refn, 1) == 1) {
+        if (thread_queue->handle) {
             tb_queue_exit(thread_queue->handle);
             thread_queue->handle = tb_null;
         }
@@ -52,4 +49,3 @@ tb_int_t xm_thread_queue_exit(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/queue_incref.c b/core/src/xmake/thread/queue_incref.c
index 4f06807c4..9dd88b013 100644
--- a/core/src/xmake/thread/queue_incref.c
+++ b/core/src/xmake/thread/queue_incref.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_incref(lua_State* lua)
-{
+tb_int_t xm_thread_queue_incref(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
     lua_pushboolean(lua, tb_atomic_fetch_and_add(&thread_queue->refn, 1) >= 1);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/queue_init.c b/core/src/xmake/thread/queue_init.c
index 0c8af884d..20c08ce50 100644
--- a/core/src/xmake/thread/queue_init.c
+++ b/core/src/xmake/thread/queue_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * private implementation
  */
-static tb_void_t xm_thread_value_free(tb_element_ref_t element, tb_pointer_t buff)
-{
-    xm_thread_value_t* item = (xm_thread_value_t*)buff;
-    if (item)
-    {
-        if (item->kind == XM_THREAD_VALUE_STR)
-        {
-            if (item->u.string) tb_free((tb_pointer_t)item->u.string);
+static tb_void_t xm_thread_value_free(tb_element_ref_t element, tb_pointer_t buff) {
+    xm_thread_value_t *item = (xm_thread_value_t *)buff;
+    if (item) {
+        if (item->kind == XM_THREAD_VALUE_STR) {
+            if (item->u.string)
+                tb_free((tb_pointer_t)item->u.string);
             item->u.string = tb_null;
         }
         item->size = 0;
@@ -50,19 +48,18 @@ static tb_void_t xm_thread_value_free(tb_element_ref_t element, tb_pointer_t buf
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_init(lua_State* lua)
-{
+tb_int_t xm_thread_queue_init(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_queue_t* thread_queue = tb_null;
-    do
-    {
+    tb_bool_t          ok           = tb_false;
+    xm_thread_queue_t *thread_queue = tb_null;
+    do {
         thread_queue = tb_malloc0_type(xm_thread_queue_t);
         tb_assert_and_check_break(thread_queue);
 
-        thread_queue->refn = 1;
-        thread_queue->handle = tb_queue_init(0, tb_element_mem(sizeof(xm_thread_value_t), xm_thread_value_free, tb_null));
+        thread_queue->refn   = 1;
+        thread_queue->handle = tb_queue_init(0,
+                                             tb_element_mem(sizeof(xm_thread_value_t), xm_thread_value_free, tb_null));
         tb_assert_and_check_break(thread_queue->handle);
 
         xm_lua_pushpointer(lua, (tb_pointer_t)thread_queue);
@@ -70,12 +67,9 @@ tb_int_t xm_thread_queue_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread_queue)
-        {
-            if (thread_queue->handle)
-            {
+    if (!ok) {
+        if (thread_queue) {
+            if (thread_queue->handle) {
                 tb_queue_exit(thread_queue->handle);
                 thread_queue->handle = tb_null;
             }
diff --git a/core/src/xmake/thread/queue_pop.c b/core/src/xmake/thread/queue_pop.c
index c666a85dd..ef5f761ec 100644
--- a/core/src/xmake/thread/queue_pop.c
+++ b/core/src/xmake/thread/queue_pop.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,30 +33,28 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_pop(lua_State* lua)
-{
+tb_int_t xm_thread_queue_pop(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
-    if (tb_queue_null(thread_queue->handle))
-    {
+    if (tb_queue_null(thread_queue->handle)) {
         lua_pushnil(lua);
         lua_pushliteral(lua, "the thread queue is empty");
         return 2;
     }
 
-    xm_thread_value_t* item = (xm_thread_value_t*)tb_queue_get(thread_queue->handle);
+    xm_thread_value_t *item = (xm_thread_value_t *)tb_queue_get(thread_queue->handle);
     tb_assert_and_check_return_val(item, 0);
 
     tb_bool_t ok = tb_false;
-    switch (item->kind)
-    {
+    switch (item->kind) {
     case XM_THREAD_VALUE_STR:
         if (item->size)
             lua_pushlstring(lua, item->u.string, item->size);
-        else lua_pushliteral(lua, "");
+        else
+            lua_pushliteral(lua, "");
         ok = tb_true;
         break;
     case XM_THREAD_VALUE_INT:
@@ -79,8 +77,7 @@ tb_int_t xm_thread_queue_pop(lua_State* lua)
         break;
     }
 
-    if (!ok)
-    {
+    if (!ok) {
         lua_pushnil(lua);
         lua_pushliteral(lua, "invalid thread queue item");
         return 2;
@@ -89,4 +86,3 @@ tb_int_t xm_thread_queue_pop(lua_State* lua)
     tb_queue_pop(thread_queue->handle);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/queue_push.c b/core/src/xmake/thread/queue_push.c
index 8125f2b9a..058ac8f81 100644
--- a/core/src/xmake/thread/queue_push.c
+++ b/core/src/xmake/thread/queue_push.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,57 +33,43 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_push(lua_State* lua)
-{
+tb_int_t xm_thread_queue_push(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
-    if (tb_queue_full(thread_queue->handle))
-    {
+    if (tb_queue_full(thread_queue->handle)) {
         lua_pushboolean(lua, tb_false);
         lua_pushliteral(lua, "the thread queue is full");
         return 2;
     }
 
     xm_thread_value_t item;
-    if (lua_isstring(lua, 2))
-    {
-        size_t data_size = 0;
-        tb_char_t const* data = luaL_checklstring(lua, 2, &data_size);
+    if (lua_isstring(lua, 2)) {
+        size_t           data_size = 0;
+        tb_char_t const *data      = luaL_checklstring(lua, 2, &data_size);
         tb_assert_and_check_return_val(data, 0);
 
         item.kind = (tb_uint32_t)XM_THREAD_VALUE_STR;
         item.size = (tb_uint32_t)data_size;
-        if (data_size)
-        {
+        if (data_size) {
             item.u.string = tb_malloc_cstr(data_size);
             tb_assert_and_check_return_val(item.u.string, 0);
             tb_memcpy(item.u.string, data, data_size);
         }
-    }
-    else if (xm_lua_isinteger(lua, 2))
-    {
-        item.kind = (tb_uint32_t)XM_THREAD_VALUE_INT;
+    } else if (xm_lua_isinteger(lua, 2)) {
+        item.kind      = (tb_uint32_t)XM_THREAD_VALUE_INT;
         item.u.integer = lua_tointeger(lua, 2);
-    }
-    else if (lua_isnumber(lua, 2))
-    {
-        item.kind = (tb_uint32_t)XM_THREAD_VALUE_NUM;
+    } else if (lua_isnumber(lua, 2)) {
+        item.kind     = (tb_uint32_t)XM_THREAD_VALUE_NUM;
         item.u.number = lua_tonumber(lua, 2);
-    }
-    else if (lua_isboolean(lua, 2))
-    {
-        item.kind = (tb_uint32_t)XM_THREAD_VALUE_BOOL;
+    } else if (lua_isboolean(lua, 2)) {
+        item.kind      = (tb_uint32_t)XM_THREAD_VALUE_BOOL;
         item.u.boolean = lua_toboolean(lua, 2);
-    }
-    else if (lua_isnil(lua, 2))
-    {
+    } else if (lua_isnil(lua, 2)) {
         item.kind = (tb_uint32_t)XM_THREAD_VALUE_NIL;
-    }
-    else
-    {
+    } else {
         lua_pushboolean(lua, tb_false);
         lua_pushliteral(lua, "unsupported thread queue item");
         return 2;
@@ -93,4 +79,3 @@ tb_int_t xm_thread_queue_push(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/queue_size.c b/core/src/xmake/thread/queue_size.c
index 559a1dceb..68a9b5a91 100644
--- a/core/src/xmake/thread/queue_size.c
+++ b/core/src/xmake/thread/queue_size.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_queue"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_queue"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_queue_size(lua_State* lua)
-{
+tb_int_t xm_thread_queue_size(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_queue_t* thread_queue = xm_thread_queue_get(lua, 1);
+    xm_thread_queue_t *thread_queue = xm_thread_queue_get(lua, 1);
     tb_assert_and_check_return_val(thread_queue && thread_queue->handle, 0);
 
     lua_pushinteger(lua, (tb_int_t)tb_queue_size(thread_queue->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/semaphore_exit.c b/core/src/xmake/thread/semaphore_exit.c
index cffffa249..bbc426917 100644
--- a/core/src/xmake/thread/semaphore_exit.c
+++ b/core/src/xmake/thread/semaphore_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_semaphore"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_semaphore"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,17 +33,14 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_semaphore_exit(lua_State* lua)
-{
+tb_int_t xm_thread_semaphore_exit(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_semaphore_t* thread_semaphore = xm_thread_semaphore_get(lua, 1);
+    xm_thread_semaphore_t *thread_semaphore = xm_thread_semaphore_get(lua, 1);
     tb_assert_and_check_return_val(thread_semaphore && thread_semaphore->handle, 0);
 
-    if (tb_atomic_fetch_and_sub(&thread_semaphore->refn, 1) == 1)
-    {
-        if (thread_semaphore->handle)
-        {
+    if (tb_atomic_fetch_and_sub(&thread_semaphore->refn, 1) == 1) {
+        if (thread_semaphore->handle) {
             tb_semaphore_exit(thread_semaphore->handle);
             thread_semaphore->handle = tb_null;
         }
@@ -52,4 +49,3 @@ tb_int_t xm_thread_semaphore_exit(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/semaphore_incref.c b/core/src/xmake/thread/semaphore_incref.c
index 84c2118d3..129a2177d 100644
--- a/core/src/xmake/thread/semaphore_incref.c
+++ b/core/src/xmake/thread/semaphore_incref.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_semaphore"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_semaphore"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_semaphore_incref(lua_State* lua)
-{
+tb_int_t xm_thread_semaphore_incref(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_semaphore_t* thread_semaphore = xm_thread_semaphore_get(lua, 1);
+    xm_thread_semaphore_t *thread_semaphore = xm_thread_semaphore_get(lua, 1);
     tb_assert_and_check_return_val(thread_semaphore && thread_semaphore->handle, 0);
 
     lua_pushboolean(lua, tb_atomic_fetch_and_add(&thread_semaphore->refn, 1) >= 1);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/semaphore_init.c b/core/src/xmake/thread/semaphore_init.c
index 976b48de9..a4c7a80fe 100644
--- a/core/src/xmake/thread/semaphore_init.c
+++ b/core/src/xmake/thread/semaphore_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_semaphore"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_semaphore"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,20 +33,18 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_semaphore_init(lua_State* lua)
-{
+tb_int_t xm_thread_semaphore_init(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_semaphore_t* thread_semaphore = tb_null;
-    do
-    {
+    tb_bool_t              ok               = tb_false;
+    xm_thread_semaphore_t *thread_semaphore = tb_null;
+    do {
         tb_long_t value = (tb_long_t)luaL_checknumber(lua, 1);
 
         thread_semaphore = tb_malloc0_type(xm_thread_semaphore_t);
         tb_assert_and_check_break(thread_semaphore);
 
-        thread_semaphore->refn = 1;
+        thread_semaphore->refn   = 1;
         thread_semaphore->handle = tb_semaphore_init(value);
         tb_assert_and_check_break(thread_semaphore->handle);
 
@@ -55,12 +53,9 @@ tb_int_t xm_thread_semaphore_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread_semaphore)
-        {
-            if (thread_semaphore->handle)
-            {
+    if (!ok) {
+        if (thread_semaphore) {
+            if (thread_semaphore->handle) {
                 tb_semaphore_exit(thread_semaphore->handle);
                 thread_semaphore->handle = tb_null;
             }
diff --git a/core/src/xmake/thread/semaphore_post.c b/core/src/xmake/thread/semaphore_post.c
index 9ca94bda5..d709e5a5e 100644
--- a/core/src/xmake/thread/semaphore_post.c
+++ b/core/src/xmake/thread/semaphore_post.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_semaphore"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_semaphore"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,15 +33,13 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_semaphore_post(lua_State* lua)
-{
+tb_int_t xm_thread_semaphore_post(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_semaphore_t* thread_semaphore = xm_thread_semaphore_get(lua, 1);
+    xm_thread_semaphore_t *thread_semaphore = xm_thread_semaphore_get(lua, 1);
     tb_assert_and_check_return_val(thread_semaphore && thread_semaphore->handle, 0);
 
     tb_long_t value = (tb_long_t)luaL_checknumber(lua, 2);
     lua_pushboolean(lua, tb_semaphore_post(thread_semaphore->handle, value));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/semaphore_wait.c b/core/src/xmake/thread/semaphore_wait.c
index c8e4d1491..40337a117 100644
--- a/core/src/xmake/thread/semaphore_wait.c
+++ b/core/src/xmake/thread/semaphore_wait.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_semaphore"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_semaphore"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,15 +33,13 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_semaphore_wait(lua_State* lua)
-{
+tb_int_t xm_thread_semaphore_wait(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_semaphore_t* thread_semaphore = xm_thread_semaphore_get(lua, 1);
+    xm_thread_semaphore_t *thread_semaphore = xm_thread_semaphore_get(lua, 1);
     tb_assert_and_check_return_val(thread_semaphore && thread_semaphore->handle, 0);
 
     tb_long_t timeout = (tb_long_t)luaL_checknumber(lua, 2);
     lua_pushinteger(lua, tb_semaphore_wait(thread_semaphore->handle, timeout));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/sharedata_clear.c b/core/src/xmake/thread/sharedata_clear.c
index 0c8b4afcf..426785e0e 100644
--- a/core/src/xmake/thread/sharedata_clear.c
+++ b/core/src/xmake/thread/sharedata_clear.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,11 +33,10 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_clear(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_clear(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_sharedata_t* thread_sharedata = xm_thread_sharedata_get(lua, 1);
+    xm_thread_sharedata_t *thread_sharedata = xm_thread_sharedata_get(lua, 1);
     tb_assert_and_check_return_val(thread_sharedata, 0);
 
     thread_sharedata->value.kind = XM_THREAD_VALUE_NIL;
@@ -45,4 +44,3 @@ tb_int_t xm_thread_sharedata_clear(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/sharedata_exit.c b/core/src/xmake/thread/sharedata_exit.c
index ad4a9f33f..ad017f2b6 100644
--- a/core/src/xmake/thread/sharedata_exit.c
+++ b/core/src/xmake/thread/sharedata_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,19 +33,16 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_exit(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_exit(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_sharedata_t* thread_sharedata = xm_thread_sharedata_get(lua, 1);
+    xm_thread_sharedata_t *thread_sharedata = xm_thread_sharedata_get(lua, 1);
     tb_assert_and_check_return_val(thread_sharedata, 0);
 
-    if (tb_atomic_fetch_and_sub(&thread_sharedata->refn, 1) == 1)
-    {
+    if (tb_atomic_fetch_and_sub(&thread_sharedata->refn, 1) == 1) {
         tb_buffer_exit(&thread_sharedata->buffer);
         tb_free(thread_sharedata);
     }
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/sharedata_get.c b/core/src/xmake/thread/sharedata_get.c
index abd020d3b..a239fb02d 100644
--- a/core/src/xmake/thread/sharedata_get.c
+++ b/core/src/xmake/thread/sharedata_get.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,20 +33,21 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_get_(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_get_(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_sharedata_t* thread_sharedata = xm_thread_sharedata_get(lua, 1);
+    xm_thread_sharedata_t *thread_sharedata = xm_thread_sharedata_get(lua, 1);
     tb_assert_and_check_return_val(thread_sharedata, 0);
 
     tb_bool_t ok = tb_false;
-    switch (thread_sharedata->value.kind)
-    {
+    switch (thread_sharedata->value.kind) {
     case XM_THREAD_VALUE_STR:
         if (tb_buffer_size(&thread_sharedata->buffer) > 0)
-            lua_pushlstring(lua, (tb_char_t*)tb_buffer_data(&thread_sharedata->buffer), tb_buffer_size(&thread_sharedata->buffer));
-        else lua_pushliteral(lua, "");
+            lua_pushlstring(lua,
+                            (tb_char_t *)tb_buffer_data(&thread_sharedata->buffer),
+                            tb_buffer_size(&thread_sharedata->buffer));
+        else
+            lua_pushliteral(lua, "");
         ok = tb_true;
         break;
     case XM_THREAD_VALUE_INT:
@@ -69,8 +70,7 @@ tb_int_t xm_thread_sharedata_get_(lua_State* lua)
         break;
     }
 
-    if (!ok)
-    {
+    if (!ok) {
         lua_pushnil(lua);
         lua_pushliteral(lua, "invalid thread sharedata thread_sharedata");
         return 2;
@@ -78,5 +78,3 @@ tb_int_t xm_thread_sharedata_get_(lua_State* lua)
 
     return 1;
 }
-
-
diff --git a/core/src/xmake/thread/sharedata_incref.c b/core/src/xmake/thread/sharedata_incref.c
index e0d32c600..3c11f7d15 100644
--- a/core/src/xmake/thread/sharedata_incref.c
+++ b/core/src/xmake/thread/sharedata_incref.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,14 +33,12 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_incref(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_incref(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_sharedata_t* thread_sharedata = xm_thread_sharedata_get(lua, 1);
+    xm_thread_sharedata_t *thread_sharedata = xm_thread_sharedata_get(lua, 1);
     tb_assert_and_check_return_val(thread_sharedata, 0);
 
     lua_pushboolean(lua, tb_atomic_fetch_and_add(&thread_sharedata->refn, 1) >= 1);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/sharedata_init.c b/core/src/xmake/thread/sharedata_init.c
index b38fc217a..ac712e5f3 100644
--- a/core/src/xmake/thread/sharedata_init.c
+++ b/core/src/xmake/thread/sharedata_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,18 +33,16 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_init(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_init(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_sharedata_t* thread_sharedata = tb_null;
-    do
-    {
+    tb_bool_t              ok               = tb_false;
+    xm_thread_sharedata_t *thread_sharedata = tb_null;
+    do {
         thread_sharedata = tb_malloc0_type(xm_thread_sharedata_t);
         tb_assert_and_check_break(thread_sharedata);
 
-        thread_sharedata->refn = 1;
+        thread_sharedata->refn       = 1;
         thread_sharedata->value.kind = XM_THREAD_VALUE_NIL;
         tb_buffer_init(&thread_sharedata->buffer);
 
@@ -53,10 +51,8 @@ tb_int_t xm_thread_sharedata_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread_sharedata)
-        {
+    if (!ok) {
+        if (thread_sharedata) {
             tb_buffer_exit(&thread_sharedata->buffer);
             tb_free(thread_sharedata);
         }
diff --git a/core/src/xmake/thread/sharedata_set.c b/core/src/xmake/thread/sharedata_set.c
index 08e661f20..9f1e6b613 100644
--- a/core/src/xmake/thread/sharedata_set.c
+++ b/core/src/xmake/thread/sharedata_set.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread_sharedata"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread_sharedata"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,45 +33,34 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_sharedata_set(lua_State* lua)
-{
+tb_int_t xm_thread_sharedata_set(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
-    xm_thread_sharedata_t* thread_sharedata = xm_thread_sharedata_get(lua, 1);
+    xm_thread_sharedata_t *thread_sharedata = xm_thread_sharedata_get(lua, 1);
     tb_assert_and_check_return_val(thread_sharedata, 0);
 
-    if (lua_isstring(lua, 2))
-    {
-        size_t data_size = 0;
-        tb_char_t const* data = luaL_checklstring(lua, 2, &data_size);
+    if (lua_isstring(lua, 2)) {
+        size_t           data_size = 0;
+        tb_char_t const *data      = luaL_checklstring(lua, 2, &data_size);
         tb_assert_and_check_return_val(data, 0);
 
         thread_sharedata->value.kind = (tb_uint32_t)XM_THREAD_VALUE_STR;
         if (data_size)
-            tb_buffer_memncpy(&thread_sharedata->buffer, (tb_byte_t const*)data, data_size);
-        else tb_buffer_clear(&thread_sharedata->buffer);
-    }
-    else if (xm_lua_isinteger(lua, 2))
-    {
-        thread_sharedata->value.kind = (tb_uint32_t)XM_THREAD_VALUE_INT;
+            tb_buffer_memncpy(&thread_sharedata->buffer, (tb_byte_t const *)data, data_size);
+        else
+            tb_buffer_clear(&thread_sharedata->buffer);
+    } else if (xm_lua_isinteger(lua, 2)) {
+        thread_sharedata->value.kind      = (tb_uint32_t)XM_THREAD_VALUE_INT;
         thread_sharedata->value.u.integer = lua_tointeger(lua, 2);
-    }
-    else if (lua_isnumber(lua, 2))
-    {
-        thread_sharedata->value.kind = (tb_uint32_t)XM_THREAD_VALUE_NUM;
+    } else if (lua_isnumber(lua, 2)) {
+        thread_sharedata->value.kind     = (tb_uint32_t)XM_THREAD_VALUE_NUM;
         thread_sharedata->value.u.number = lua_tonumber(lua, 2);
-    }
-    else if (lua_isboolean(lua, 2))
-    {
-        thread_sharedata->value.kind = (tb_uint32_t)XM_THREAD_VALUE_BOOL;
+    } else if (lua_isboolean(lua, 2)) {
+        thread_sharedata->value.kind      = (tb_uint32_t)XM_THREAD_VALUE_BOOL;
         thread_sharedata->value.u.boolean = lua_toboolean(lua, 2);
-    }
-    else if (lua_isnil(lua, 2))
-    {
+    } else if (lua_isnil(lua, 2)) {
         thread_sharedata->value.kind = (tb_uint32_t)XM_THREAD_VALUE_NIL;
-    }
-    else
-    {
+    } else {
         lua_pushboolean(lua, tb_false);
         lua_pushliteral(lua, "unsupported thread sharedata item");
         return 2;
@@ -80,5 +69,3 @@ tb_int_t xm_thread_sharedata_set(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
-
diff --git a/core/src/xmake/thread/thread_exit.c b/core/src/xmake/thread/thread_exit.c
index 9d2c8e908..a91018ac6 100644
--- a/core/src/xmake/thread/thread_exit.c
+++ b/core/src/xmake/thread/thread_exit.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,8 +33,7 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_exit(lua_State* lua)
-{
+tb_int_t xm_thread_exit(lua_State *lua) {
     // check
     tb_assert_and_check_return_val(lua, 0);
 
@@ -43,16 +42,14 @@ tb_int_t xm_thread_exit(lua_State* lua)
         return 0;
 
     // get thread
-    xm_thread_t* thread = (xm_thread_t*)xm_lua_topointer(lua, 1);
+    xm_thread_t *thread = (xm_thread_t *)xm_lua_topointer(lua, 1);
     tb_check_return_val(thread, 0);
 
     // exit thread
-    if (thread)
-    {
+    if (thread) {
         tb_string_exit(&thread->callback);
         tb_string_exit(&thread->callinfo);
-        if (thread->handle)
-        {
+        if (thread->handle) {
             tb_thread_exit(thread->handle);
             thread->handle = tb_null;
         }
@@ -61,4 +58,3 @@ tb_int_t xm_thread_exit(lua_State* lua)
     lua_pushboolean(lua, tb_true);
     return 1;
 }
-
diff --git a/core/src/xmake/thread/thread_init.c b/core/src/xmake/thread/thread_init.c
index 6fc44267a..60d694ae1 100644
--- a/core/src/xmake/thread/thread_init.c
+++ b/core/src/xmake/thread/thread_init.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -35,44 +35,41 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * macros
  */
-#define XM_THREAD_ENGINE_NAME   "xmake"
+#define XM_THREAD_ENGINE_NAME "xmake"
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * private implementation
  */
 
-static tb_int_t xm_thread_func(tb_cpointer_t priv)
-{
-    xm_thread_t* thread = (xm_thread_t*)priv;
+static tb_int_t xm_thread_func(tb_cpointer_t priv) {
+    xm_thread_t *thread = (xm_thread_t *)priv;
     tb_assert_and_check_return_val(thread, 0);
 
     xm_engine_ref_t engine = xm_engine_pool_alloc(xm_engine_pool());
-    if (!engine) engine = xm_engine_init(XM_THREAD_ENGINE_NAME, tb_null);
-    if (engine)
-    {
-        lua_State* lua = xm_engine_lua(engine);
+    if (!engine)
+        engine = xm_engine_init(XM_THREAD_ENGINE_NAME, tb_null);
+    if (engine) {
+        lua_State *lua = xm_engine_lua(engine);
         tb_assert(lua);
 
         // pass callback
-        tb_char_t const* callback_data = tb_string_cstr(&thread->callback);
+        tb_char_t const *callback_data = tb_string_cstr(&thread->callback);
         tb_size_t        callback_size = tb_string_size(&thread->callback);
-        if (callback_data && callback_size)
-        {
+        if (callback_data && callback_size) {
             lua_pushlstring(lua, callback_data, callback_size);
             lua_setglobal(lua, "_THREAD_CALLBACK");
         }
 
         // pass callinfo
-        tb_char_t const* callinfo_data = tb_string_cstr(&thread->callinfo);
+        tb_char_t const *callinfo_data = tb_string_cstr(&thread->callinfo);
         tb_size_t        callinfo_size = tb_string_size(&thread->callinfo);
-        if (callinfo_data && callinfo_size)
-        {
+        if (callinfo_data && callinfo_size) {
             lua_pushlstring(lua, callinfo_data, callinfo_size);
             lua_setglobal(lua, "_THREAD_CALLINFO");
         }
 
         // start engine
-        tb_char_t* argv[] = {XM_THREAD_ENGINE_NAME, tb_null};
+        tb_char_t *argv[] = { XM_THREAD_ENGINE_NAME, tb_null };
         xm_engine_main(engine, 1, argv, tb_null);
         if (!xm_engine_pool_free(xm_engine_pool(), engine))
             xm_engine_exit(engine);
@@ -83,26 +80,24 @@ static tb_int_t xm_thread_func(tb_cpointer_t priv)
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_init(lua_State* lua)
-{
+tb_int_t xm_thread_init(lua_State *lua) {
     // check
     tb_assert_and_check_return_val(lua, 0);
 
-    tb_bool_t ok = tb_false;
-    xm_thread_t* thread = tb_null;
-    do
-    {
+    tb_bool_t    ok     = tb_false;
+    xm_thread_t *thread = tb_null;
+    do {
         // get thread name
-        tb_char_t const* name = luaL_checkstring(lua, 1);
+        tb_char_t const *name = luaL_checkstring(lua, 1);
 
         // get callback
-        size_t              callback_size = 0;
-        tb_char_t const*    callback_data = luaL_checklstring(lua, 2, &callback_size);
+        size_t           callback_size = 0;
+        tb_char_t const *callback_data = luaL_checklstring(lua, 2, &callback_size);
         tb_assert_and_check_break(callback_data && callback_size);
 
         // get callinfo
-        size_t              callinfo_size = 0;
-        tb_char_t const*    callinfo_data = luaL_checklstring(lua, 3, &callinfo_size);
+        size_t           callinfo_size = 0;
+        tb_char_t const *callinfo_data = luaL_checklstring(lua, 3, &callinfo_size);
         tb_assert_and_check_break(callinfo_data && callinfo_size);
 
         // get stack size
@@ -127,14 +122,11 @@ tb_int_t xm_thread_init(lua_State* lua)
 
     } while (0);
 
-    if (!ok)
-    {
-        if (thread)
-        {
+    if (!ok) {
+        if (thread) {
             tb_string_exit(&thread->callback);
             tb_string_exit(&thread->callinfo);
-            if (thread->handle)
-            {
+            if (thread->handle) {
                 tb_thread_exit(thread->handle);
                 thread->handle = tb_null;
             }
diff --git a/core/src/xmake/thread/thread_resume.c b/core/src/xmake/thread/thread_resume.c
index 9843ac2d7..9a3630338 100644
--- a/core/src/xmake/thread/thread_resume.c
+++ b/core/src/xmake/thread/thread_resume.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,8 +33,7 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_resume(lua_State* lua)
-{
+tb_int_t xm_thread_resume(lua_State *lua) {
     // check
     tb_assert_and_check_return_val(lua, 0);
 
@@ -43,11 +42,10 @@ tb_int_t xm_thread_resume(lua_State* lua)
         return 0;
 
     // get thread
-    xm_thread_t* thread = (xm_thread_t*)xm_lua_topointer(lua, 1);
+    xm_thread_t *thread = (xm_thread_t *)xm_lua_topointer(lua, 1);
     tb_check_return_val(thread && thread->handle, 0);
 
     // resume thread
     lua_pushboolean(lua, tb_thread_resume(thread->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/thread_suspend.c b/core/src/xmake/thread/thread_suspend.c
index e21509413..dcb24c4f6 100644
--- a/core/src/xmake/thread/thread_suspend.c
+++ b/core/src/xmake/thread/thread_suspend.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,8 +33,7 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_suspend(lua_State* lua)
-{
+tb_int_t xm_thread_suspend(lua_State *lua) {
     // check
     tb_assert_and_check_return_val(lua, 0);
 
@@ -43,11 +42,10 @@ tb_int_t xm_thread_suspend(lua_State* lua)
         return 0;
 
     // get thread
-    xm_thread_t* thread = (xm_thread_t*)xm_lua_topointer(lua, 1);
+    xm_thread_t *thread = (xm_thread_t *)xm_lua_topointer(lua, 1);
     tb_check_return_val(thread && thread->handle, 0);
 
     // suspend thread
     lua_pushboolean(lua, tb_thread_suspend(thread->handle));
     return 1;
 }
-
diff --git a/core/src/xmake/thread/thread_wait.c b/core/src/xmake/thread/thread_wait.c
index f2d7199ec..4a921f39c 100644
--- a/core/src/xmake/thread/thread_wait.c
+++ b/core/src/xmake/thread/thread_wait.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "thread"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "thread"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,8 +33,7 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_thread_wait(lua_State* lua)
-{
+tb_int_t xm_thread_wait(lua_State *lua) {
     // check
     tb_assert_and_check_return_val(lua, 0);
 
@@ -43,7 +42,7 @@ tb_int_t xm_thread_wait(lua_State* lua)
         return 0;
 
     // get thread
-    xm_thread_t* thread = (xm_thread_t*)xm_lua_topointer(lua, 1);
+    xm_thread_t *thread = (xm_thread_t *)xm_lua_topointer(lua, 1);
     tb_check_return_val(thread->handle, 0);
 
     // get timeout
@@ -54,4 +53,3 @@ tb_int_t xm_thread_wait(lua_State* lua)
     lua_pushinteger(lua, (tb_int_t)tb_thread_wait(thread->handle, timeout, &retval));
     return 1;
 }
-