Merge pull request #7008 from xmake-io/format

format code

7 files changed, 173 insertions, 175 deletions

diff --git a/core/src/xmake/string/convert.c b/core/src/xmake/string/convert.c
index 0001b7f9c..b3adaf8b8 100644
--- a/core/src/xmake/string/convert.c
+++ b/core/src/xmake/string/convert.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "convert"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "convert"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -35,54 +35,52 @@
  */
 
 // the charset entry type
-typedef struct __xm_charset_entry_t
-{
+typedef struct __xm_charset_entry_t {
     // the charset type
-    tb_size_t           type;
+    tb_size_t type;
 
     // the charset name
-    tb_char_t const*    name;
-
-}xm_charset_entry_t, *xm_charset_entry_ref_t;
+    tb_char_t const *name;
+} xm_charset_entry_t, *xm_charset_entry_ref_t;
 
 // the charsets, @note: type & name is sorted
-static xm_charset_entry_t g_charsets[] =
-{
-    {TB_CHARSET_TYPE_ANSI,                          "ansi"    }
-,   {TB_CHARSET_TYPE_ASCII,                         "ascii"   }
-,   {TB_CHARSET_TYPE_GB2312,                        "gb2312"  }
-,   {TB_CHARSET_TYPE_GBK,                           "gbk"     }
-,   {TB_CHARSET_TYPE_ISO8859,                       "iso8859" }
-,   {TB_CHARSET_TYPE_UCS2  | TB_CHARSET_TYPE_NE,    "ucs2"    }
-,   {TB_CHARSET_TYPE_UCS4  | TB_CHARSET_TYPE_NE,    "ucs4"    }
-,   {TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_NE,    "utf16"   }
-,   {TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_BE,    "utf16be" }
-,   {TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_LE,    "utf16le" }
-,   {TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_NE,    "utf32"   }
-,   {TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_BE,    "utf32be" }
-,   {TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_LE,    "utf32le" }
-,   {TB_CHARSET_TYPE_UTF8,                          "utf8"    }
+static xm_charset_entry_t g_charsets[] = {
+    { TB_CHARSET_TYPE_ANSI, "ansi" },
+    { TB_CHARSET_TYPE_ASCII, "ascii" },
+    { TB_CHARSET_TYPE_GB2312, "gb2312" },
+    { TB_CHARSET_TYPE_GBK, "gbk" },
+    { TB_CHARSET_TYPE_ISO8859, "iso8859" },
+    { TB_CHARSET_TYPE_UCS2 | TB_CHARSET_TYPE_NE, "ucs2" },
+    { TB_CHARSET_TYPE_UCS4 | TB_CHARSET_TYPE_NE, "ucs4" },
+    { TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_NE, "utf16" },
+    { TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_BE, "utf16be" },
+    { TB_CHARSET_TYPE_UTF16 | TB_CHARSET_TYPE_LE, "utf16le" },
+    { TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_NE, "utf32" },
+    { TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_BE, "utf32be" },
+    { TB_CHARSET_TYPE_UTF32 | TB_CHARSET_TYPE_LE, "utf32le" },
+    { TB_CHARSET_TYPE_UTF8, "utf8" },
 };
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * finder
  */
-static tb_long_t xm_string_charset_comp_by_name(tb_iterator_ref_t iterator, tb_cpointer_t item, tb_cpointer_t name)
-{
-    return tb_stricmp(((xm_charset_entry_ref_t)item)->name, (tb_char_t const*)name);
+static tb_long_t xm_string_charset_comp_by_name(tb_iterator_ref_t iterator, tb_cpointer_t item, tb_cpointer_t name) {
+    return tb_stricmp(((xm_charset_entry_ref_t)item)->name, (tb_char_t const *)name);
 }
-static xm_charset_entry_ref_t xm_string_charset_find_by_name(tb_char_t const* name)
-{
+static xm_charset_entry_ref_t xm_string_charset_find_by_name(tb_char_t const *name) {
     // make iterator
     tb_array_iterator_t array_iterator;
-    tb_iterator_ref_t   iterator = tb_array_iterator_init_mem(&array_iterator, g_charsets, tb_arrayn(g_charsets), sizeof(xm_charset_entry_t));
+    tb_iterator_ref_t   iterator =
+        tb_array_iterator_init_mem(&array_iterator, g_charsets, tb_arrayn(g_charsets), sizeof(xm_charset_entry_t));
     tb_assert_and_check_return_val(iterator, tb_null);
 
     // find it by the binary search
     tb_size_t itor = tb_binary_find_all_if(iterator, xm_string_charset_comp_by_name, name);
-    if (itor != tb_iterator_tail(iterator))
+    if (itor != tb_iterator_tail(iterator)) {
         return (xm_charset_entry_ref_t)tb_iterator_item(iterator, itor);
-    else return tb_null;
+    } else {
+        return tb_null;
+    }
 }
 
 /* //////////////////////////////////////////////////////////////////////////////////////
@@ -100,16 +98,14 @@ static xm_charset_entry_ref_t xm_string_charset_find_by_name(tb_char_t const* na
  *      local result = string.convert(str, "utf8", "gb2312")
  * @endcode
  */
-tb_int_t xm_string_convert(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_convert(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     // get the string and charset types
     size_t           src_size   = 0;
-    tb_char_t const* src_cstr   = luaL_checklstring(lua, 1, &src_size);
-    tb_char_t const* ftype_cstr = luaL_checkstring(lua, 2);
-    tb_char_t const* ttype_cstr = luaL_checkstring(lua, 3);
+    tb_char_t const *src_cstr   = luaL_checklstring(lua, 1, &src_size);
+    tb_char_t const *ftype_cstr = luaL_checkstring(lua, 2);
+    tb_char_t const *ttype_cstr = luaL_checkstring(lua, 3);
     tb_check_return_val(src_cstr && ftype_cstr && ttype_cstr, 0);
 
     // find charsets
@@ -120,21 +116,27 @@ tb_int_t xm_string_convert(lua_State* lua)
     tb_check_return_val(fcharset && tcharset, 0);
 
     // empty string?
-    if (!src_size) lua_pushstring(lua, "");
-    else
-    {
+    if (!src_size) {
+        lua_pushstring(lua, "");
+    } else {
         // convert string
-        tb_long_t   dst_size = 0;
-        tb_size_t   dst_maxn = (tb_size_t)src_size << 2;
-        tb_byte_t*  dst_data = tb_malloc_bytes(dst_maxn);
-        if (dst_data && dst_maxn && (dst_size = tb_charset_conv_data(fcharset->type, tcharset->type, (tb_byte_t const*)src_cstr, (tb_size_t)src_size, dst_data, dst_maxn)) >= 0 && dst_size < dst_maxn)
-        {
+        tb_long_t  dst_size = 0;
+        tb_size_t  dst_maxn = (tb_size_t)src_size << 2;
+        tb_byte_t *dst_data = tb_malloc_bytes(dst_maxn);
+        if (dst_data && dst_maxn &&
+            (dst_size = tb_charset_conv_data(fcharset->type,
+                                             tcharset->type,
+                                             (tb_byte_t const *)src_cstr,
+                                             (tb_size_t)src_size,
+                                             dst_data,
+                                             dst_maxn)) >= 0 &&
+            dst_size < dst_maxn) {
             lua_pushlstring(lua, (tb_char_t const *)dst_data, dst_size);
+        } else {
+            lua_pushnil(lua);
         }
-        else lua_pushnil(lua);
         tb_free(dst_data);
     }
 
-    // ok
     return 1;
 }
diff --git a/core/src/xmake/string/endswith.c b/core/src/xmake/string/endswith.c
index e6bb8b9c4..f7e5e1805 100644
--- a/core/src/xmake/string/endswith.c
+++ b/core/src/xmake/string/endswith.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "endswith"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "endswith"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,21 +33,18 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_string_endswith(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_endswith(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     // get the string and suffix
-    size_t              string_size = 0;
-    size_t              suffix_size = 0;
-    tb_char_t const*    string = luaL_checklstring(lua, 1, &string_size);
-    tb_char_t const*    suffix = luaL_checklstring(lua, 2, &suffix_size);
+    size_t           string_size = 0;
+    size_t           suffix_size = 0;
+    tb_char_t const *string      = luaL_checklstring(lua, 1, &string_size);
+    tb_char_t const *suffix      = luaL_checklstring(lua, 2, &suffix_size);
     tb_check_return_val(string && suffix, 0);
 
     // string:endswith(suffix)?
     lua_pushboolean(lua, string_size >= suffix_size && !tb_strcmp(string + string_size - suffix_size, suffix));
 
-    // ok
     return 1;
 }
diff --git a/core/src/xmake/string/lastof.c b/core/src/xmake/string/lastof.c
index 8e6f42300..8785e3987 100644
--- a/core/src/xmake/string/lastof.c
+++ b/core/src/xmake/string/lastof.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "string_lastof"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "string_lastof"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,16 +33,14 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * private implementation
  */
-static tb_void_t xm_string_lastof_str(lua_State* lua, tb_char_t const* cstr, tb_size_t nstr, tb_char_t const* csubstr, tb_size_t nsubstr)
-{
+static tb_void_t xm_string_lastof_str(
+    lua_State *lua, tb_char_t const *cstr, tb_size_t nstr, tb_char_t const *csubstr, tb_size_t nsubstr) {
     // find it
-    tb_char_t const* curr = tb_null;
-    tb_char_t const* next = cstr;
-    do
-    {
+    tb_char_t const *curr = tb_null;
+    tb_char_t const *next = cstr;
+    do {
         next = tb_strstr(next, csubstr); // faster than tb_strnstr()
-        if (next)
-        {
+        if (next) {
             curr = next;
             next += nsubstr;
         }
@@ -50,14 +48,19 @@ static tb_void_t xm_string_lastof_str(lua_State* lua, tb_char_t const* cstr, tb_
     } while (!next);
 
     // found?
-    if (curr) lua_pushinteger(lua, curr - cstr + 1);
-    else lua_pushnil(lua);
+    if (curr) {
+        lua_pushinteger(lua, curr - cstr + 1);
+    } else {
+        lua_pushnil(lua);
+    }
 }
-static tb_void_t xm_string_lastof_chr(lua_State* lua, tb_char_t const* cstr, tb_size_t nstr, tb_char_t ch)
-{
-    tb_char_t const* pos = tb_strrchr(cstr, ch); // faster than tb_strnrchr()
-    if (pos) lua_pushinteger(lua, pos - cstr + 1);
-    else lua_pushnil(lua);
+static tb_void_t xm_string_lastof_chr(lua_State *lua, tb_char_t const *cstr, tb_size_t nstr, tb_char_t ch) {
+    tb_char_t const *pos = tb_strrchr(cstr, ch); // faster than tb_strnrchr()
+    if (pos) {
+        lua_pushinteger(lua, pos - cstr + 1);
+    } else {
+        lua_pushnil(lua);
+    }
 }
 
 /* //////////////////////////////////////////////////////////////////////////////////////
@@ -69,22 +72,23 @@ static tb_void_t xm_string_lastof_chr(lua_State* lua, tb_char_t const* cstr, tb_
  * @param str             the string
  * @param substr          the substring
  */
-tb_int_t xm_string_lastof(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_lastof(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     // get string
     size_t           nstr = 0;
-    tb_char_t const* cstr = luaL_checklstring(lua, 1, &nstr);
+    tb_char_t const *cstr = luaL_checklstring(lua, 1, &nstr);
 
     // get substring
     size_t           nsubstr = 0;
-    tb_char_t const* csubstr = luaL_checklstring(lua, 2, &nsubstr);
+    tb_char_t const *csubstr = luaL_checklstring(lua, 2, &nsubstr);
 
     // lastof it
     lua_newtable(lua);
-    if (nsubstr == 1) xm_string_lastof_chr(lua, cstr, (tb_size_t)nstr, csubstr[0]);
-    else xm_string_lastof_str(lua, cstr, (tb_size_t)nstr, csubstr, nsubstr);
+    if (nsubstr == 1) {
+        xm_string_lastof_chr(lua, cstr, (tb_size_t)nstr, csubstr[0]);
+    } else {
+        xm_string_lastof_str(lua, cstr, (tb_size_t)nstr, csubstr, nsubstr);
+    }
     return 1;
 }
diff --git a/core/src/xmake/string/prefix.h b/core/src/xmake/string/prefix.h
index 8f9e53d94..890fc368c 100644
--- a/core/src/xmake/string/prefix.h
+++ b/core/src/xmake/string/prefix.h
@@ -26,7 +26,4 @@
  */
 #include "../prefix.h"
 
-
 #endif
-
-
diff --git a/core/src/xmake/string/split.c b/core/src/xmake/string/split.c
index c035a5fab..5ca0c92bb 100644
--- a/core/src/xmake/string/split.c
+++ b/core/src/xmake/string/split.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "string_split"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "string_split"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,62 +33,59 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * private implementation
  */
-static tb_void_t xm_string_split_str(lua_State* lua, tb_char_t const* cstr, tb_size_t nstr, tb_char_t const* cdls, tb_size_t ndls, tb_bool_t strict, tb_int_t limit)
-{
-    tb_int_t num = 0;
-    tb_char_t const* end = cstr + nstr;
-    tb_char_t const* pos = tb_strstr(cstr, cdls); // faster than tb_strnstr()
-    while (pos && pos < end)
-    {
-        if (pos > cstr || strict)
-        {
-            if (limit > 0 && num + 1 >= limit)
+static tb_void_t xm_string_split_str(lua_State       *lua,
+                                     tb_char_t const *cstr,
+                                     tb_size_t        nstr,
+                                     tb_char_t const *cdls,
+                                     tb_size_t        ndls,
+                                     tb_bool_t        strict,
+                                     tb_int_t         limit) {
+    tb_int_t         num = 0;
+    tb_char_t const *end = cstr + nstr;
+    tb_char_t const *pos = tb_strstr(cstr, cdls); // faster than tb_strnstr()
+    while (pos && pos < end) {
+        if (pos > cstr || strict) {
+            if (limit > 0 && num + 1 >= limit) {
                 break;
+            }
 
             lua_pushlstring(lua, cstr, pos - cstr);
             lua_rawseti(lua, -2, ++num);
         }
 
         cstr = pos + ndls;
-        pos = tb_strstr(cstr, cdls);
+        pos  = tb_strstr(cstr, cdls);
     }
-    if (cstr < end)
-    {
+    if (cstr < end) {
         lua_pushlstring(lua, cstr, end - cstr);
         lua_rawseti(lua, -2, ++num);
-    }
-    else if (strict && (limit < 0 || num < limit) && cstr == end)
-    {
+    } else if (strict && (limit < 0 || num < limit) && cstr == end) {
         lua_pushliteral(lua, "");
         lua_rawseti(lua, -2, ++num);
     }
 }
-static tb_void_t xm_string_split_chr(lua_State* lua, tb_char_t const* cstr, tb_size_t nstr, tb_char_t ch, tb_bool_t strict, tb_int_t limit)
-{
-    tb_int_t num = 0;
-    tb_char_t const* end = cstr + nstr;
-    tb_char_t const* pos = tb_strchr(cstr, ch); // faster than tb_strnchr()
-    while (pos && pos < end)
-    {
-        if (pos > cstr || strict)
-        {
-            if (limit > 0 && num + 1 >= limit)
+static tb_void_t xm_string_split_chr(
+    lua_State *lua, tb_char_t const *cstr, tb_size_t nstr, tb_char_t ch, tb_bool_t strict, tb_int_t limit) {
+    tb_int_t         num = 0;
+    tb_char_t const *end = cstr + nstr;
+    tb_char_t const *pos = tb_strchr(cstr, ch); // faster than tb_strnchr()
+    while (pos && pos < end) {
+        if (pos > cstr || strict) {
+            if (limit > 0 && num + 1 >= limit) {
                 break;
+            }
 
             lua_pushlstring(lua, cstr, pos - cstr);
             lua_rawseti(lua, -2, ++num);
         }
 
         cstr = pos + 1;
-        pos = tb_strchr(cstr, ch);
+        pos  = tb_strchr(cstr, ch);
     }
-    if (cstr < end)
-    {
+    if (cstr < end) {
         lua_pushlstring(lua, cstr, end - cstr);
         lua_rawseti(lua, -2, ++num);
-    }
-    else if (strict && (limit < 0 || num < limit) && cstr == end)
-    {
+    } else if (strict && (limit < 0 || num < limit) && cstr == end) {
         lua_pushliteral(lua, "");
         lua_rawseti(lua, -2, ++num);
     }
@@ -105,28 +102,29 @@ static tb_void_t xm_string_split_chr(lua_State* lua, tb_char_t const* cstr, tb_s
  * @param strict          is strict?
  * @param limit           the limit count
  */
-tb_int_t xm_string_split(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_split(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     // get string
     size_t           nstr = 0;
-    tb_char_t const* cstr = luaL_checklstring(lua, 1, &nstr);
+    tb_char_t const *cstr = luaL_checklstring(lua, 1, &nstr);
 
     // get delimiter
     size_t           ndls = 0;
-    tb_char_t const* cdls = luaL_checklstring(lua, 2, &ndls);
+    tb_char_t const *cdls = luaL_checklstring(lua, 2, &ndls);
 
     // is strict?
-    tb_bool_t const  strict = (tb_bool_t)lua_toboolean(lua, 3);
+    tb_bool_t const strict = (tb_bool_t)lua_toboolean(lua, 3);
 
     // get limit count
-    tb_int_t const   limit  = (tb_int_t)luaL_optinteger(lua, 4, -1);
+    tb_int_t const limit = (tb_int_t)luaL_optinteger(lua, 4, -1);
 
     // split it
     lua_newtable(lua);
-    if (ndls == 1) xm_string_split_chr(lua, cstr, (tb_size_t)nstr, cdls[0], strict, limit);
-    else xm_string_split_str(lua, cstr, (tb_size_t)nstr, cdls, ndls, strict, limit);
+    if (ndls == 1) {
+        xm_string_split_chr(lua, cstr, (tb_size_t)nstr, cdls[0], strict, limit);
+    } else {
+        xm_string_split_str(lua, cstr, (tb_size_t)nstr, cdls, ndls, strict, limit);
+    }
     return 1;
 }
diff --git a/core/src/xmake/string/startswith.c b/core/src/xmake/string/startswith.c
index d904de3cb..04b53ffa7 100644
--- a/core/src/xmake/string/startswith.c
+++ b/core/src/xmake/string/startswith.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "startswith"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "startswith"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,20 +33,17 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * implementation
  */
-tb_int_t xm_string_startswith(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_startswith(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     // get the string and prefix
-    size_t              prefix_size = 0;
-    tb_char_t const*    string = luaL_checkstring(lua, 1);
-    tb_char_t const*    prefix = luaL_checklstring(lua, 2, &prefix_size);
+    size_t           prefix_size = 0;
+    tb_char_t const *string      = luaL_checkstring(lua, 1);
+    tb_char_t const *prefix      = luaL_checklstring(lua, 2, &prefix_size);
     tb_check_return_val(string && prefix, 0);
 
     // string:startswith(prefix)?
     lua_pushboolean(lua, !tb_strncmp(string, prefix, (tb_size_t)prefix_size));
 
-    // ok
     return 1;
 }
diff --git a/core/src/xmake/string/trim.c b/core/src/xmake/string/trim.c
index 42a4b846c..54e6e4b5a 100644
--- a/core/src/xmake/string/trim.c
+++ b/core/src/xmake/string/trim.c
@@ -22,8 +22,8 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * trace
  */
-#define TB_TRACE_MODULE_NAME                "string_trim"
-#define TB_TRACE_MODULE_DEBUG               (0)
+#define TB_TRACE_MODULE_NAME "string_trim"
+#define TB_TRACE_MODULE_DEBUG (0)
 
 /* //////////////////////////////////////////////////////////////////////////////////////
  * includes
@@ -33,25 +33,25 @@
 /* //////////////////////////////////////////////////////////////////////////////////////
  * private implementation
  */
-static tb_void_t xm_string_trim_space(tb_char_t const** psstr, tb_char_t const** pestr, tb_int_t mode)
-{
-    // check
+static tb_void_t xm_string_trim_space(tb_char_t const **psstr, tb_char_t const **pestr, tb_int_t mode) {
     tb_assert(psstr && pestr && *psstr && *pestr);
 
-    tb_char_t const* p = *psstr;
-    tb_char_t const* e = *pestr;
+    tb_char_t const *p = *psstr;
+    tb_char_t const *e = *pestr;
 
     // trim left?
-    if (mode <= 0)
-        while (p < e && tb_isspace(*p))
+    if (mode <= 0) {
+        while (p < e && tb_isspace(*p)) {
             p++;
+        }
+    }
 
     // trim right
-    if (mode >= 0)
-    {
+    if (mode >= 0) {
         e--;
-        while (e >= p && tb_isspace(*e))
+        while (e >= p && tb_isspace(*e)) {
             e--;
+        }
         e++;
     }
 
@@ -60,25 +60,29 @@ static tb_void_t xm_string_trim_space(tb_char_t const** psstr, tb_char_t const**
     *pestr = e;
 }
 
-static tb_char_t const* xm_string_ltrim(tb_char_t const* sstr, tb_char_t const* estr, tb_char_t const* ctrim, size_t ntrim)
-{
-    // check
+static tb_char_t const *xm_string_ltrim(tb_char_t const *sstr,
+                                        tb_char_t const *estr,
+                                        tb_char_t const *ctrim,
+                                        size_t           ntrim) {
     tb_assert(sstr && estr && ctrim);
 
-    tb_char_t const* p = sstr;
-    while (p < estr && tb_strnchr(ctrim, ntrim, *p))
+    tb_char_t const *p = sstr;
+    while (p < estr && tb_strnchr(ctrim, ntrim, *p)) {
         p++;
+    }
     return p;
 }
 
-static tb_char_t const* xm_string_rtrim(tb_char_t const* sstr, tb_char_t const* estr, tb_char_t const* ctrim, size_t ntrim)
-{
-    // check
+static tb_char_t const *xm_string_rtrim(tb_char_t const *sstr,
+                                        tb_char_t const *estr,
+                                        tb_char_t const *ctrim,
+                                        size_t           ntrim) {
     tb_assert(sstr && estr && ctrim);
 
-    tb_char_t const* p = estr - 1;
-    while (p >= sstr && tb_strnchr(ctrim, ntrim, *p))
+    tb_char_t const *p = estr - 1;
+    while (p >= sstr && tb_strnchr(ctrim, ntrim, *p)) {
         p--;
+    }
     return p + 1;
 }
 
@@ -97,36 +101,35 @@ static tb_char_t const* xm_string_rtrim(tb_char_t const* sstr, tb_char_t const*
  *      local result = string.trim(str, "(", -1)
  * @endcode
  */
-tb_int_t xm_string_trim(lua_State* lua)
-{
-    // check
+tb_int_t xm_string_trim(lua_State *lua) {
     tb_assert_and_check_return_val(lua, 0);
 
     size_t           lstr, ltrim;
-    tb_char_t const* sstr      = luaL_checklstring(lua, 1, &lstr);
-    tb_char_t const* estr      = sstr + lstr;
-    tb_char_t const* trimchars = luaL_optlstring(lua, 2, "", &ltrim);
+    tb_char_t const *sstr      = luaL_checklstring(lua, 1, &lstr);
+    tb_char_t const *estr      = sstr + lstr;
+    tb_char_t const *trimchars = luaL_optlstring(lua, 2, "", &ltrim);
     tb_int_t const   trimtype  = (tb_int_t)luaL_optinteger(lua, 3, 0);
-    do
-    {
+    do {
         tb_assert_and_check_break(sstr && trimchars);
         tb_check_break(lstr != 0);
 
-        tb_char_t const* const rsstr = sstr;
-        tb_char_t const* const restr = estr;
-        if (ltrim == 0)
+        tb_char_t const *const rsstr = sstr;
+        tb_char_t const *const restr = estr;
+        if (ltrim == 0) {
             xm_string_trim_space(&sstr, &estr, trimtype);
-        else
-        {
+        } else {
             // trim chars
-            if (trimtype <= 0) sstr = xm_string_ltrim(sstr, estr, trimchars, ltrim);
-            if (trimtype >= 0) estr = xm_string_rtrim(sstr, estr, trimchars, ltrim);
+            if (trimtype <= 0) {
+                sstr = xm_string_ltrim(sstr, estr, trimchars, ltrim);
+            }
+            if (trimtype >= 0) {
+                estr = xm_string_rtrim(sstr, estr, trimchars, ltrim);
+            }
         }
 
         // no trimed chars
         tb_check_break(sstr != rsstr || estr != restr);
 
-        // ok
         lua_pushlstring(lua, sstr, estr - sstr);
         return 1;