fixed coding style in kservice.c

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2522 bbd45198-f89e-11dd-88c7-29a3b14d5316

1 files changed, 650 insertions, 629 deletions

diff --git a/src/kservice.c b/src/kservice.c
index 4bd6c5530f..4276fc28ec 100644
--- a/src/kservice.c
+++ b/src/kservice.c
@@ -46,19 +46,19 @@ static rt_device_t _console_device = RT_NULL;
  */
 rt_err_t rt_get_errno(void)
 {
-	rt_thread_t tid;
+    rt_thread_t tid;
 
-	if (rt_interrupt_get_nest() != 0)
-	{
-		/* it's in interrupt context */
-		return _errno;
-	}
+    if (rt_interrupt_get_nest() != 0)
+    {
+        /* it's in interrupt context */
+        return _errno;
+    }
 
-	tid = rt_thread_self();
-	if (tid == RT_NULL)
-		return _errno;
+    tid = rt_thread_self();
+    if (tid == RT_NULL)
+        return _errno;
 
-	return tid->error;
+    return tid->error;
 }
 RTM_EXPORT(rt_get_errno);
 
@@ -69,25 +69,25 @@ RTM_EXPORT(rt_get_errno);
  */
 void rt_set_errno(rt_err_t error)
 {
-	rt_thread_t tid;
+    rt_thread_t tid;
 
-	if (rt_interrupt_get_nest() != 0)
-	{
-		/* it's in interrupt context */
-		_errno = error;
+    if (rt_interrupt_get_nest() != 0)
+    {
+        /* it's in interrupt context */
+        _errno = error;
 
-		return;
-	}
+        return;
+    }
 
-	tid = rt_thread_self();
-	if (tid == RT_NULL)
-	{
-		_errno = error;
-		
-		return;
-	}
+    tid = rt_thread_self();
+    if (tid == RT_NULL)
+    {
+        _errno = error;
+        
+        return;
+    }
 
-	tid->error = error;
+    tid->error = error;
 }
 RTM_EXPORT(rt_set_errno);
 
@@ -98,16 +98,16 @@ RTM_EXPORT(rt_set_errno);
  */
 int *_rt_errno(void)
 {
-	rt_thread_t tid;
-	
-	if (rt_interrupt_get_nest() != 0)
-		return (int *)&_errno;
+    rt_thread_t tid;
+    
+    if (rt_interrupt_get_nest() != 0)
+        return (int *)&_errno;
 
-	tid = rt_thread_self();
-	if (tid != RT_NULL)
-		return (int *)&(tid->error);
+    tid = rt_thread_self();
+    if (tid != RT_NULL)
+        return (int *)&(tid->error);
 
-	return (int *)&_errno;
+    return (int *)&_errno;
 }
 RTM_EXPORT(_rt_errno);
 
@@ -123,68 +123,68 @@ RTM_EXPORT(_rt_errno);
 void *rt_memset(void *s, int c, rt_ubase_t count)
 {
 #ifdef RT_TINY_SIZE
-	char *xs = (char *)s;
+    char *xs = (char *)s;
 
-	while (count--)
-		*xs++ = c;
+    while (count--)
+        *xs++ = c;
 
-	return s;
+    return s;
 #else
 #define LBLOCKSIZE      (sizeof(rt_int32_t))
 #define UNALIGNED(X)    ((rt_int32_t)X & (LBLOCKSIZE - 1))
 #define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)
 
-	int i;
-	char *m = (char *)s;
-	rt_uint32_t buffer;
-	rt_uint32_t *aligned_addr;
-	rt_uint32_t d = c & 0xff;
+    int i;
+    char *m = (char *)s;
+    rt_uint32_t buffer;
+    rt_uint32_t *aligned_addr;
+    rt_uint32_t d = c & 0xff;
 
-	if (!TOO_SMALL(count) && !UNALIGNED(s))
-	{
-		/* If we get this far, we know that n is large and m is word-aligned. */
-		aligned_addr = (rt_uint32_t *)s;
+    if (!TOO_SMALL(count) && !UNALIGNED(s))
+    {
+        /* If we get this far, we know that n is large and m is word-aligned. */
+        aligned_addr = (rt_uint32_t *)s;
 
-		/* Store D into each char sized location in BUFFER so that
-		 * we can set large blocks quickly.
-		 */
-		if (LBLOCKSIZE == 4)
-		{
-			buffer = (d << 8) | d;
-			buffer |= (buffer << 16);
-		}
-		else
-		{
-			buffer = 0;
-			for (i = 0; i < LBLOCKSIZE; i++)
-				buffer = (buffer << 8) | d;
-		}
+        /* Store D into each char sized location in BUFFER so that
+         * we can set large blocks quickly.
+         */
+        if (LBLOCKSIZE == 4)
+        {
+            buffer = (d << 8) | d;
+            buffer |= (buffer << 16);
+        }
+        else
+        {
+            buffer = 0;
+            for (i = 0; i < LBLOCKSIZE; i ++)
+                buffer = (buffer << 8) | d;
+        }
 
-		while (count >= LBLOCKSIZE*4)
-		{
-			*aligned_addr++ = buffer;
-			*aligned_addr++ = buffer;
-			*aligned_addr++ = buffer;
-			*aligned_addr++ = buffer;
-			count -= 4 * LBLOCKSIZE;
-		}
+        while (count >= LBLOCKSIZE * 4)
+        {
+            *aligned_addr++ = buffer;
+            *aligned_addr++ = buffer;
+            *aligned_addr++ = buffer;
+            *aligned_addr++ = buffer;
+            count -= 4 * LBLOCKSIZE;
+        }
 
-		while (count >= LBLOCKSIZE)
-		{
-			*aligned_addr++ = buffer;
-			count -= LBLOCKSIZE;
-		}
+        while (count >= LBLOCKSIZE)
+        {
+            *aligned_addr++ = buffer;
+            count -= LBLOCKSIZE;
+        }
 
-		/* Pick up the remainder with a bytewise loop. */
-		m = (char *)aligned_addr;
-	}
+        /* Pick up the remainder with a bytewise loop. */
+        m = (char *)aligned_addr;
+    }
 
-	while (count--)
-	{
-		*m++ = (char)d;
-	}
+    while (count--)
+    {
+        *m++ = (char)d;
+    }
 
-	return s;
+    return s;
 
 #undef LBLOCKSIZE
 #undef UNALIGNED
@@ -206,59 +206,60 @@ RTM_EXPORT(rt_memset);
 void *rt_memcpy(void *dst, const void *src, rt_ubase_t count)
 {
 #ifdef RT_TINY_SIZE
-	char *tmp = (char *)dst, *s = (char *)src;
+    char *tmp = (char *)dst, *s = (char *)src;
 
-	while (count--)
-		*tmp++ = *s++;
+    while (count--)
+        *tmp++ = *s++;
 
-	return dst;
+    return dst;
 #else
 
-#define UNALIGNED(X, Y) \
-	(((rt_int32_t)X & (sizeof(rt_int32_t) - 1)) | ((rt_int32_t)Y & (sizeof(rt_int32_t) - 1)))
+#define UNALIGNED(X, Y)                                               \
+                        (((rt_int32_t)X & (sizeof(rt_int32_t) - 1)) | \
+                         ((rt_int32_t)Y & (sizeof(rt_int32_t) - 1)))
 #define BIGBLOCKSIZE    (sizeof(rt_int32_t) << 2)
 #define LITTLEBLOCKSIZE (sizeof(rt_int32_t))
 #define TOO_SMALL(LEN)  ((LEN) < BIGBLOCKSIZE)
 
-	char *dst_ptr = (char *)dst;
-	char *src_ptr = (char *)src;
-	rt_int32_t *aligned_dst;
-	rt_int32_t *aligned_src;
-	int len = count;
+    char *dst_ptr = (char *)dst;
+    char *src_ptr = (char *)src;
+    rt_int32_t *aligned_dst;
+    rt_int32_t *aligned_src;
+    int len = count;
 
-	/* If the size is small, or either SRC or DST is unaligned,
-	then punt into the byte copy loop.  This should be rare. */
-	if (!TOO_SMALL(len) && !UNALIGNED(src_ptr, dst_ptr))
-	{
-		aligned_dst = (rt_int32_t *)dst_ptr;
-		aligned_src = (rt_int32_t *)src_ptr;
+    /* If the size is small, or either SRC or DST is unaligned,
+    then punt into the byte copy loop.  This should be rare. */
+    if (!TOO_SMALL(len) && !UNALIGNED(src_ptr, dst_ptr))
+    {
+        aligned_dst = (rt_int32_t *)dst_ptr;
+        aligned_src = (rt_int32_t *)src_ptr;
 
-		/* Copy 4X long words at a time if possible. */
-		while (len >= BIGBLOCKSIZE)
-		{
-			*aligned_dst++ = *aligned_src++;
-			*aligned_dst++ = *aligned_src++;
-			*aligned_dst++ = *aligned_src++;
-			*aligned_dst++ = *aligned_src++;
-			len -= BIGBLOCKSIZE;
-		}
+        /* Copy 4X long words at a time if possible. */
+        while (len >= BIGBLOCKSIZE)
+        {
+            *aligned_dst++ = *aligned_src++;
+            *aligned_dst++ = *aligned_src++;
+            *aligned_dst++ = *aligned_src++;
+            *aligned_dst++ = *aligned_src++;
+            len -= BIGBLOCKSIZE;
+        }
 
-		/* Copy one long word at a time if possible. */
-		while (len >= LITTLEBLOCKSIZE)
-		{
-			*aligned_dst++ = *aligned_src++;
-			len -= LITTLEBLOCKSIZE;
-		}
+        /* Copy one long word at a time if possible. */
+        while (len >= LITTLEBLOCKSIZE)
+        {
+            *aligned_dst++ = *aligned_src++;
+            len -= LITTLEBLOCKSIZE;
+        }
 
-		/* Pick up any residual with a byte copier. */
-		dst_ptr = (char *)aligned_dst;
-		src_ptr = (char *)aligned_src;
-	}
+        /* Pick up any residual with a byte copier. */
+        dst_ptr = (char *)aligned_dst;
+        src_ptr = (char *)aligned_src;
+    }
 
-	while (len--)
-		*dst_ptr++ = *src_ptr++;
+    while (len--)
+        *dst_ptr++ = *src_ptr++;
 
-	return dst;
+    return dst;
 #undef UNALIGNED
 #undef BIGBLOCKSIZE
 #undef LITTLEBLOCKSIZE
@@ -279,23 +280,23 @@ RTM_EXPORT(rt_memcpy);
  */
 void *rt_memmove(void *dest, const void *src, rt_ubase_t n)
 {
-	char *tmp = (char *)dest, *s = (char *)src;
+    char *tmp = (char *)dest, *s = (char *)src;
 
-	if (s < tmp && tmp < s + n)
-	{
-		tmp += n;
-		s += n;
+    if (s < tmp && tmp < s + n)
+    {
+        tmp += n;
+        s += n;
 
-		while (n--)
-			*(--tmp) = *(--s);
-	}
-	else
-	{
-		while (n--)
-			*tmp++ = *s++;
-	}
+        while (n--)
+            *(--tmp) = *(--s);
+    }
+    else
+    {
+        while (n--)
+            *tmp++ = *s++;
+    }
 
-	return dest;
+    return dest;
 }
 RTM_EXPORT(rt_memmove);
 
@@ -310,14 +311,14 @@ RTM_EXPORT(rt_memmove);
  */
 rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_ubase_t count)
 {
-	const unsigned char *su1, *su2;
-	int res = 0;
+    const unsigned char *su1, *su2;
+    int res = 0;
 
-	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
-		if ((res = *su1 - *su2) != 0)
-			break;
+    for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
+        if ((res = *su1 - *su2) != 0)
+            break;
 
-	return res;
+    return res;
 }
 RTM_EXPORT(rt_memcmp);
 
@@ -331,21 +332,21 @@ RTM_EXPORT(rt_memcmp);
  */
 char *rt_strstr(const char *s1, const char *s2)
 {
-	int l1, l2;
+    int l1, l2;
 
-	l2 = rt_strlen(s2);
-	if (!l2)
-		return (char *)s1;
-	l1 = rt_strlen(s1);
-	while (l1 >= l2)
-	{
-		l1 --;
-		if (!rt_memcmp(s1, s2, l2))
-			return (char *)s1;
-		s1 ++;
-	}
+    l2 = rt_strlen(s2);
+    if (!l2)
+        return (char *)s1;
+    l1 = rt_strlen(s1);
+    while (l1 >= l2)
+    {
+        l1 --;
+        if (!rt_memcmp(s1, s2, l2))
+            return (char *)s1;
+        s1 ++;
+    }
 
-	return RT_NULL;
+    return RT_NULL;
 }
 RTM_EXPORT(rt_strstr);
 
@@ -359,20 +360,20 @@ RTM_EXPORT(rt_strstr);
  */
 rt_uint32_t rt_strcasecmp(const char *a, const char *b)
 {
-	int ca, cb;
+    int ca, cb;
 
-	do
-	{
-		ca = *a++ & 0xff;
-		cb = *b++ & 0xff;
-		if (ca >= 'A' && ca <= 'Z')
-			ca += 'a' - 'A';
-		if (cb >= 'A' && cb <= 'Z')
-			cb += 'a' - 'A';
-	}
-	while (ca == cb && ca != '\0');
+    do
+    {
+        ca = *a++ & 0xff;
+        cb = *b++ & 0xff;
+        if (ca >= 'A' && ca <= 'Z')
+            ca += 'a' - 'A';
+        if (cb >= 'A' && cb <= 'Z')
+            cb += 'a' - 'A';
+    }
+    while (ca == cb && ca != '\0');
 
-	return ca - cb;
+    return ca - cb;
 }
 RTM_EXPORT(rt_strcasecmp);
 
@@ -387,24 +388,24 @@ RTM_EXPORT(rt_strcasecmp);
  */
 char *rt_strncpy(char *dst, const char *src, rt_ubase_t n)
 {
-	if (n != 0)
-	{
-		char *d = dst;
-		const char *s = src;
+    if (n != 0)
+    {
+        char *d = dst;
+        const char *s = src;
 
-		do
-		{
-			if ((*d++ = *s++) == 0)
-			{
-				/* NUL pad the remaining n-1 bytes */
-				while (--n != 0)
-					*d++ = 0;
-				break;
-			}
-		} while (--n != 0);
-	}
+        do
+        {
+            if ((*d++ = *s++) == 0)
+            {
+                /* NUL pad the remaining n-1 bytes */
+                while (--n != 0)
+                    *d++ = 0;
+                break;
+            }
+        } while (--n != 0);
+    }
 
-	return (dst);
+    return (dst);
 }
 RTM_EXPORT(rt_strncpy);
 
@@ -419,16 +420,16 @@ RTM_EXPORT(rt_strncpy);
  */
 rt_ubase_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count)
 {
-	register signed char __res = 0;
+    register signed char __res = 0;
 
-	while (count)
-	{
-		if ((__res = *cs - *ct++) != 0 || !*cs++)
-			break;
-		count --;
-	}
+    while (count)
+    {
+        if ((__res = *cs - *ct++) != 0 || !*cs++)
+            break;
+        count --;
+    }
 
-	return __res;
+    return __res;
 }
 RTM_EXPORT(rt_strncmp);
 
@@ -442,10 +443,10 @@ RTM_EXPORT(rt_strncmp);
  */
 rt_ubase_t rt_strcmp(const char *cs, const char *ct)
 {
-	while (*cs && *cs == *ct)
-		cs++, ct++;
+    while (*cs && *cs == *ct)
+        cs++, ct++;
 
-	return (*cs - *ct);
+    return (*cs - *ct);
 }
 RTM_EXPORT(rt_strcmp);
 
@@ -459,12 +460,12 @@ RTM_EXPORT(rt_strcmp);
  */
 rt_ubase_t rt_strlen(const char *s)
 {
-	const char *sc;
+    const char *sc;
 
-	for (sc = s; *sc != '\0'; ++sc) /* nothing */
-		;
+    for (sc = s; *sc != '\0'; ++sc) /* nothing */
+        ;
 
-	return sc - s;
+    return sc - s;
 }
 RTM_EXPORT(rt_strlen);
 
@@ -478,15 +479,15 @@ RTM_EXPORT(rt_strlen);
  */
 char *rt_strdup(const char *s)
 {
-	rt_size_t len = rt_strlen(s) + 1;
-	char *tmp = (char *)rt_malloc(len);
+    rt_size_t len = rt_strlen(s) + 1;
+    char *tmp = (char *)rt_malloc(len);
 
-	if (!tmp)
-		return RT_NULL;
+    if (!tmp)
+        return RT_NULL;
 
-	rt_memcpy(tmp, s, len);
+    rt_memcpy(tmp, s, len);
 
-	return tmp;
+    return tmp;
 }
 RTM_EXPORT(rt_strdup);
 #endif
@@ -496,10 +497,11 @@ RTM_EXPORT(rt_strdup);
  */
 void rt_show_version(void)
 {
-	rt_kprintf("\n \\ | /\n");
-	rt_kprintf("- RT -     Thread Operating System\n");
-	rt_kprintf(" / | \\     %d.%d.%d build %s\n", RT_VERSION, RT_SUBVERSION, RT_REVISION, __DATE__);
-	rt_kprintf(" 2006 - 2012 Copyright by rt-thread team\n");
+    rt_kprintf("\n \\ | /\n");
+    rt_kprintf("- RT -     Thread Operating System\n");
+    rt_kprintf(" / | \\     %d.%d.%d build %s\n",
+               RT_VERSION, RT_SUBVERSION, RT_REVISION, __DATE__);
+    rt_kprintf(" 2006 - 2012 Copyright by rt-thread team\n");
 }
 RTM_EXPORT(rt_show_version);
 
@@ -508,442 +510,460 @@ RTM_EXPORT(rt_show_version);
 
 rt_inline rt_int32_t divide(rt_int32_t *n, rt_int32_t base)
 {
-	rt_int32_t res;
+    rt_int32_t res;
 
-	/* optimized for processor which does not support divide instructions. */
-	if (base == 10)
-	{
-		res = ((rt_uint32_t)*n) % 10U;
-		*n = ((rt_uint32_t)*n) / 10U;
-	}
-	else
-	{
-		res = ((rt_uint32_t)*n) % 16U;
-		*n = ((rt_uint32_t)*n) / 16U;
-	}
+    /* optimized for processor which does not support divide instructions. */
+    if (base == 10)
+    {
+        res = ((rt_uint32_t)*n) % 10U;
+        *n = ((rt_uint32_t)*n) / 10U;
+    }
+    else
+    {
+        res = ((rt_uint32_t)*n) % 16U;
+        *n = ((rt_uint32_t)*n) / 16U;
+    }
 
-	return res;
+    return res;
 }
 
 rt_inline int skip_atoi(const char **s)
 {
-	register int i=0;
-	while (isdigit(**s))
-		i = i * 10 + *((*s)++) - '0';
+    register int i=0;
+    while (isdigit(**s))
+        i = i * 10 + *((*s)++) - '0';
 
-	return i;
+    return i;
 }
 
-#define ZEROPAD     (1 << 0)	/* pad with zero */
-#define SIGN        (1 << 1)	/* unsigned/signed long */
-#define PLUS        (1 << 2)	/* show plus */
-#define SPACE       (1 << 3)	/* space if plus */
-#define LEFT        (1 << 4)	/* left justified */
-#define SPECIAL     (1 << 5)	/* 0x */
-#define LARGE       (1 << 6)	/* use 'ABCDEF' instead of 'abcdef' */
+#define ZEROPAD     (1 << 0)    /* pad with zero */
+#define SIGN        (1 << 1)    /* unsigned/signed long */
+#define PLUS        (1 << 2)    /* show plus */
+#define SPACE       (1 << 3)    /* space if plus */
+#define LEFT        (1 << 4)    /* left justified */
+#define SPECIAL     (1 << 5)    /* 0x */
+#define LARGE       (1 << 6)    /* use 'ABCDEF' instead of 'abcdef' */
 
 #ifdef RT_PRINTF_PRECISION
-static char *print_number(char *buf, char *end, long num, int base, int s, int precision, int type)
+static char *print_number(char *buf,
+                          char *end,
+                          long  num,
+                          int   base,
+                          int   s,
+                          int   precision,
+                          int   type)
 #else
-static char *print_number(char *buf, char *end, long num, int base, int s, int type)
+static char *print_number(char *buf,
+                          char *end,
+                          long  num,
+                          int   base,
+                          int   s,
+                          int   type)
 #endif
 {
-	char c, sign;
+    char c, sign;
 #ifdef RT_PRINTF_LONGLONG
-	char tmp[32];
+    char tmp[32];
 #else
-	char tmp[16];
+    char tmp[16];
 #endif
-	const char *digits;
-	static const char small_digits[] = "0123456789abcdef";
-	static const char large_digits[] = "0123456789ABCDEF";
-	register int i;
-	register int size;
+    const char *digits;
+    static const char small_digits[] = "0123456789abcdef";
+    static const char large_digits[] = "0123456789ABCDEF";
+    register int i;
+    register int size;
 
-	size = s;
+    size = s;
 
-	digits = (type & LARGE) ? large_digits : small_digits;
-	if (type & LEFT)
-		type &= ~ZEROPAD;
+    digits = (type & LARGE) ? large_digits : small_digits;
+    if (type & LEFT)
+        type &= ~ZEROPAD;
 
-	c = (type & ZEROPAD) ? '0' : ' ';
+    c = (type & ZEROPAD) ? '0' : ' ';
 
-	/* get sign */
-	sign = 0;
-	if (type & SIGN)
-	{
-		if (num < 0)
-		{
-			sign = '-';
-			num = -num;
-		}
-		else if (type & PLUS) sign = '+';
-		else if (type & SPACE) sign = ' ';
-	}
+    /* get sign */
+    sign = 0;
+    if (type & SIGN)
+    {
+        if (num < 0)
+        {
+            sign = '-';
+            num = -num;
+        }
+        else if (type & PLUS)
+            sign = '+';
+        else if (type & SPACE)
+            sign = ' ';
+    }
 
 #ifdef RT_PRINTF_SPECIAL
-	if (type & SPECIAL)
-	{
-		if (base == 16) size -= 2;
-		else if (base == 8) size--;
-	}
+    if (type & SPECIAL)
+    {
+        if (base == 16)
+            size -= 2;
+        else if (base == 8)
+            size--;
+    }
 #endif
 
-	i = 0;
-	if (num == 0)
-		tmp[i++]='0';
-	else
-	{
-		while (num != 0)
-			tmp[i++] = digits[divide(&num, base)];
-	}
+    i = 0;
+    if (num == 0)
+        tmp[i++]='0';
+    else
+    {
+        while (num != 0)
+            tmp[i++] = digits[divide(&num, base)];
+    }
 
 #ifdef RT_PRINTF_PRECISION
-	if (i > precision)
-		precision = i;
-	size -= precision;
+    if (i > precision)
+        precision = i;
+    size -= precision;
 #else
-	size -= i;
+    size -= i;
 #endif
 
-	if (!(type&(ZEROPAD | LEFT)))
-	{
-		if ((sign)&&(size>0))
-			size--;
+    if (!(type&(ZEROPAD | LEFT)))
+    {
+        if ((sign)&&(size>0))
+            size--;
 
-		while (size-->0)
-		{
-			if (buf <= end)
-				*buf = ' ';
-			++ buf;
-		}
-	}
+        while (size-->0)
+        {
+            if (buf <= end)
+                *buf = ' ';
+            ++ buf;
+        }
+    }
 
-	if (sign)
-	{
-		if (buf <= end)
-		{
-			*buf = sign;
-			-- size;
-		}
-		++ buf;
-	}
+    if (sign)
+    {
+        if (buf <= end)
+        {
+            *buf = sign;
+            -- size;
+        }
+        ++ buf;
+    }
 
 #ifdef RT_PRINTF_SPECIAL
-	if (type & SPECIAL)
-	{
-		if (base==8)
-		{
-			if (buf <= end)
-				*buf = '0';
-			++ buf;
-		}
-		else if (base == 16)
-		{
-			if (buf <= end)
-				*buf = '0';
-			++ buf;
-			if (buf <= end)
-			{
-				*buf = type & LARGE? 'X' : 'x';
-			}
-			++ buf;
-		}
-	}
+    if (type & SPECIAL)
+    {
+        if (base==8)
+        {
+            if (buf <= end)
+                *buf = '0';
+            ++ buf;
+        }
+        else if (base == 16)
+        {
+            if (buf <= end)
+                *buf = '0';
+            ++ buf;
+            if (buf <= end)
+            {
+                *buf = type & LARGE? 'X' : 'x';
+            }
+            ++ buf;
+        }
+    }
 #endif
 
-	/* no align to the left */
-	if (!(type & LEFT))
-	{
-		while (size-- > 0)
-		{
-			if (buf <= end)
-				*buf = c;
-			++ buf;
-		}
-	}
+    /* no align to the left */
+    if (!(type & LEFT))
+    {
+        while (size-- > 0)
+        {
+            if (buf <= end)
+                *buf = c;
+            ++ buf;
+        }
+    }
 
 #ifdef RT_PRINTF_PRECISION
-	while (i < precision--)
-	{
-		if (buf <= end)
-			*buf = '0';
-		++ buf;
-	}
+    while (i < precision--)
+    {
+        if (buf <= end)
+            *buf = '0';
+        ++ buf;
+    }
 #endif
 
-	/* put number in the temporary buffer */
-	while (i-- > 0)
-	{
-		if (buf <= end)
-			*buf = tmp[i];
-		++ buf;
-	}
+    /* put number in the temporary buffer */
+    while (i-- > 0)
+    {
+        if (buf <= end)
+            *buf = tmp[i];
+        ++ buf;
+    }
 
-	while (size-- > 0)
-	{
-		if (buf <= end)
-			*buf = ' ';
-		++ buf;
-	}
+    while (size-- > 0)
+    {
+        if (buf <= end)
+            *buf = ' ';
+        ++ buf;
+    }
 
-	return buf;
+    return buf;
 }
 
-static rt_int32_t vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args)
+static rt_int32_t vsnprintf(char       *buf,
+                            rt_size_t   size,
+                            const char *fmt,
+                            va_list     args)
 {
 #ifdef RT_PRINTF_LONGLONG
-	unsigned long long num;
+    unsigned long long num;
 #else
-	rt_uint32_t num;
+    rt_uint32_t num;
 #endif
-	int i, len;
-	char *str, *end, c;
-	const char *s;
+    int i, len;
+    char *str, *end, c;
+    const char *s;
 
-	rt_uint8_t base;			/* the base of number */
-	rt_uint8_t flags;			/* flags to print number */
-	rt_uint8_t qualifier;		/* 'h', 'l', or 'L' for integer fields */
-	rt_int32_t field_width;		/* width of output field */
+    rt_uint8_t base;            /* the base of number */
+    rt_uint8_t flags;           /* flags to print number */
+    rt_uint8_t qualifier;       /* 'h', 'l', or 'L' for integer fields */
+    rt_int32_t field_width;     /* width of output field */
 
 #ifdef RT_PRINTF_PRECISION
-	int precision;		/* min. # of digits for integers and max for a string */
+    int precision;      /* min. # of digits for integers and max for a string */
 #endif
 
-	str = buf;
-	end = buf + size - 1;
+    str = buf;
+    end = buf + size - 1;
 
-	/* Make sure end is always >= buf */
-	if (end < buf)
-	{
-		end = ((char *)-1);
-		size = end - buf;
-	}
+    /* Make sure end is always >= buf */
+    if (end < buf)
+    {
+        end  = ((char *)-1);
+        size = end - buf;
+    }
 
-	for (; *fmt ; ++fmt)
-	{
-		if (*fmt != '%')
-		{
-			if (str <= end)
-				*str = *fmt;
-			++ str;
-			continue;
-		}
+    for (; *fmt ; ++fmt)
+    {
+        if (*fmt != '%')
+        {
+            if (str <= end)
+                *str = *fmt;
+            ++ str;
+            continue;
+        }
 
-		/* process flags */
-		flags = 0;
+        /* process flags */
+        flags = 0;
 
-		while (1)
-		{
-			/* skips the first '%' also */
-			++ fmt;
-			if (*fmt == '-') flags |= LEFT;
-			else if (*fmt == '+') flags |= PLUS;
-			else if (*fmt == ' ') flags |= SPACE;
-			else if (*fmt == '#') flags |= SPECIAL;
-			else if (*fmt == '0') flags |= ZEROPAD;
-			else break;
-		}
+        while (1)
+        {
+            /* skips the first '%' also */
+            ++ fmt;
+            if (*fmt == '-') flags |= LEFT;
+            else if (*fmt == '+') flags |= PLUS;
+            else if (*fmt == ' ') flags |= SPACE;
+            else if (*fmt == '#') flags |= SPECIAL;
+            else if (*fmt == '0') flags |= ZEROPAD;
+            else break;
+        }
 
-		/* get field width */
-		field_width = -1;
-		if (isdigit(*fmt)) field_width = skip_atoi(&fmt);
-		else if (*fmt == '*')
-		{
-			++ fmt;
-			/* it's the next argument */
-			field_width = va_arg(args, int);
-			if (field_width < 0)
-			{
-				field_width = -field_width;
-				flags |= LEFT;
-			}
-		}
+        /* get field width */
+        field_width = -1;
+        if (isdigit(*fmt)) field_width = skip_atoi(&fmt);
+        else if (*fmt == '*')
+        {
+            ++ fmt;
+            /* it's the next argument */
+            field_width = va_arg(args, int);
+            if (field_width < 0)
+            {
+                field_width = -field_width;
+                flags |= LEFT;
+            }
+        }
 
 #ifdef RT_PRINTF_PRECISION
-		/* get the precision */
-		precision = -1;
-		if (*fmt == '.')
-		{
-			++ fmt;
-			if (isdigit(*fmt)) precision = skip_atoi(&fmt);
-			else if (*fmt == '*')
-			{
-				++ fmt;
-				/* it's the next argument */
-				precision = va_arg(args, int);
-			}
-			if (precision < 0) precision = 0;
-		}
+        /* get the precision */
+        precision = -1;
+        if (*fmt == '.')
+        {
+            ++ fmt;
+            if (isdigit(*fmt)) precision = skip_atoi(&fmt);
+            else if (*fmt == '*')
+            {
+                ++ fmt;
+                /* it's the next argument */
+                precision = va_arg(args, int);
+            }
+            if (precision < 0) precision = 0;
+        }
 #endif
-		/* get the conversion qualifier */
-		qualifier = 0;
+        /* get the conversion qualifier */
+        qualifier = 0;
 #ifdef RT_PRINTF_LONGLONG
-		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')
+        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L')
 #else
-		if (*fmt == 'h' || *fmt == 'l')
+        if (*fmt == 'h' || *fmt == 'l')
 #endif
-		{
-			qualifier = *fmt;
-			++ fmt;
+        {
+            qualifier = *fmt;
+            ++ fmt;
 #ifdef RT_PRINTF_LONGLONG
-			if (qualifier == 'l' && *fmt == 'l')
-			{
-				qualifier = 'L';
-				++ fmt;
-			}
+            if (qualifier == 'l' && *fmt == 'l')
+            {
+                qualifier = 'L';
+                ++ fmt;
+            }
 #endif
-		}
+        }
 
-		/* the default base */
-		base = 10;
+        /* the default base */
+        base = 10;
 
-		switch (*fmt)
-		{
-		case 'c':
-			if (!(flags & LEFT))
-			{
-				while (--field_width > 0)
-				{
-					if (str <= end) *str = ' ';
-					++ str;
-				}
-			}
+        switch (*fmt)
+        {
+        case 'c':
+            if (!(flags & LEFT))
+            {
+                while (--field_width > 0)
+                {
+                    if (str <= end) *str = ' ';
+                    ++ str;
+                }
+            }
 
-			/* get character */
-			c = (rt_uint8_t)va_arg(args, int);
-			if (str <= end) *str = c;
-			++ str;
+            /* get character */
+            c = (rt_uint8_t)va_arg(args, int);
+            if (str <= end) *str = c;
+            ++ str;
 
-			/* put width */
-			while (--field_width > 0)
-			{
-				if (str <= end) *str = ' ';
-				++ str;
-			}
-			continue;
+            /* put width */
+            while (--field_width > 0)
+            {
+                if (str <= end) *str = ' ';
+                ++ str;
+            }
+            continue;
 
-		case 's':
-			s = va_arg(args, char *);
-			if (!s) s = "(NULL)";
+        case 's':
+            s = va_arg(args, char *);
+            if (!s) s = "(NULL)";
 
-			len = rt_strlen(s);
+            len = rt_strlen(s);
 #ifdef RT_PRINTF_PRECISION
-			if (precision > 0 && len > precision) len = precision;
+            if (precision > 0 && len > precision) len = precision;
 #endif
 
-			if (!(flags & LEFT))
-			{
-				while (len < field_width--)
-				{
-					if (str <= end) *str = ' ';
-					++ str;
-				}
-			}
+            if (!(flags & LEFT))
+            {
+                while (len < field_width--)
+                {
+                    if (str <= end) *str = ' ';
+                    ++ str;
+                }
+            }
 
-			for (i = 0; i < len; ++i)
-			{
-				if (str <= end) *str = *s;
-				++ str;
-				++ s;
-			}
+            for (i = 0; i < len; ++i)
+            {
+                if (str <= end) *str = *s;
+                ++ str;
+                ++ s;
+            }
 
-			while (len < field_width--)
-			{
-				if (str <= end) *str = ' ';
-				++ str;
-			}
-			continue;
+            while (len < field_width--)
+            {
+                if (str <= end) *str = ' ';
+                ++ str;
+            }
+            continue;
 
-		case 'p':
-			if (field_width == -1)
-			{
-				field_width = sizeof(void *) << 1;
-				flags |= ZEROPAD;
-			}
+        case 'p':
+            if (field_width == -1)
+            {
+                field_width = sizeof(void *) << 1;
+                flags |= ZEROPAD;
+            }
 #ifdef RT_PRINTF_PRECISION
-			str = print_number(str, end,
-							   (long)va_arg(args, void *),
-							   16, field_width, precision, flags);
+            str = print_number(str, end,
+                               (long)va_arg(args, void *),
+                               16, field_width, precision, flags);
 #else
-			str = print_number(str, end,
-							   (long)va_arg(args, void *),
-							   16, field_width, flags);
+            str = print_number(str, end,
+                               (long)va_arg(args, void *),
+                               16, field_width, flags);
 #endif
-			continue;
+            continue;
 
-		case '%':
-			if (str <= end) *str = '%';
-			++ str;
-			continue;
+        case '%':
+            if (str <= end) *str = '%';
+            ++ str;
+            continue;
 
-			/* integer number formats - set up the flags and "break" */
-		case 'o':
-			base = 8;
-			break;
+            /* integer number formats - set up the flags and "break" */
+        case 'o':
+            base = 8;
+            break;
 
-		case 'X':
-			flags |= LARGE;
-		case 'x':
-			base = 16;
-			break;
+        case 'X':
+            flags |= LARGE;
+        case 'x':
+            base = 16;
+            break;
 
-		case 'd':
-		case 'i':
-			flags |= SIGN;
-		case 'u':
-			break;
+        case 'd':
+        case 'i':
+            flags |= SIGN;
+        case 'u':
+            break;
 
-		default:
-			if (str <= end) *str = '%';
-			++ str;
+        default:
+            if (str <= end) *str = '%';
+            ++ str;
 
-			if (*fmt)
-			{
-				if (str <= end) *str = *fmt;
-				++ str;
-			}
-			else
-			{
-				-- fmt;
-			}
-			continue;
-		}
+            if (*fmt)
+            {
+                if (str <= end) *str = *fmt;
+                ++ str;
+            }
+            else
+            {
+                -- fmt;
+            }
+            continue;
+        }
 
 #ifdef RT_PRINTF_LONGLONG
-		if (qualifier == 'L') num = va_arg(args, long long);
-		else if (qualifier == 'l')
+        if (qualifier == 'L') num = va_arg(args, long long);
+        else if (qualifier == 'l')
 #else
-		if (qualifier == 'l')
+        if (qualifier == 'l')
 #endif
-		{
-			num = va_arg(args, rt_uint32_t);
-			if (flags & SIGN) num = (rt_int32_t)num;
-		}
-		else if (qualifier == 'h')
-		{
-			num = (rt_uint16_t)va_arg(args, rt_int32_t);
-			if (flags & SIGN) num = (rt_int16_t)num;
-		}
-		else
-		{
-			num = va_arg(args, rt_uint32_t);
-			if (flags & SIGN) num = (rt_int32_t)num;
-		}
+        {
+            num = va_arg(args, rt_uint32_t);
+            if (flags & SIGN) num = (rt_int32_t)num;
+        }
+        else if (qualifier == 'h')
+        {
+            num = (rt_uint16_t)va_arg(args, rt_int32_t);
+            if (flags & SIGN) num = (rt_int16_t)num;
+        }
+        else
+        {
+            num = va_arg(args, rt_uint32_t);
+            if (flags & SIGN) num = (rt_int32_t)num;
+        }
 #ifdef RT_PRINTF_PRECISION
-		str = print_number(str, end, num, base, field_width, precision, flags);
+        str = print_number(str, end, num, base, field_width, precision, flags);
 #else
-		str = print_number(str, end, num, base, field_width, flags);
+        str = print_number(str, end, num, base, field_width, flags);
 #endif
-	}
+    }
 
-	if (str <= end) *str = '\0';
-	else *end = '\0';
+    if (str <= end) *str = '\0';
+    else *end = '\0';
 
-	/* the trailing null byte doesn't count towards the total
-	* ++str;
-	*/
-	return str - buf;
+    /* the trailing null byte doesn't count towards the total
+    * ++str;
+    */
+    return str - buf;
 }
 
 /**
@@ -955,14 +975,14 @@ static rt_int32_t vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list
  */
 rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *fmt, ...)
 {
-	rt_int32_t n;
-	va_list args;
+    rt_int32_t n;
+    va_list args;
 
-	va_start(args, fmt);
-	n = vsnprintf(buf, size, fmt, args);
-	va_end(args);
+    va_start(args, fmt);
+    n = vsnprintf(buf, size, fmt, args);
+    va_end(args);
 
-	return n;
+    return n;
 }
 RTM_EXPORT(rt_snprintf);
 
@@ -975,7 +995,7 @@ RTM_EXPORT(rt_snprintf);
  */
 rt_int32_t rt_vsprintf(char *buf, const char *format, va_list arg_ptr)
 {
-	return vsnprintf(buf, (rt_size_t) -1, format, arg_ptr);
+    return vsnprintf(buf, (rt_size_t) -1, format, arg_ptr);
 }
 RTM_EXPORT(rt_vsprintf);
 
@@ -987,14 +1007,14 @@ RTM_EXPORT(rt_vsprintf);
  */
 rt_int32_t rt_sprintf(char *buf, const char *format, ...)
 {
-	rt_int32_t n;
-	va_list arg_ptr;
+    rt_int32_t n;
+    va_list arg_ptr;
 
-	va_start(arg_ptr, format);
-	n = rt_vsprintf(buf ,format, arg_ptr);
-	va_end(arg_ptr);
+    va_start(arg_ptr, format);
+    n = rt_vsprintf(buf ,format, arg_ptr);
+    va_end(arg_ptr);
 
-	return n;
+    return n;
 }
 RTM_EXPORT(rt_sprintf);
 
@@ -1008,7 +1028,7 @@ RTM_EXPORT(rt_sprintf);
  */
 rt_device_t rt_console_get_device(void)
 {
-	return _console_device;
+    return _console_device;
 }
 RTM_EXPORT(rt_console_get_device);
 
@@ -1023,27 +1043,27 @@ RTM_EXPORT(rt_console_get_device);
  */
 rt_device_t rt_console_set_device(const char *name)
 {
-	rt_device_t new, old;
+    rt_device_t new, old;
 
-	/* save old device */
-	old = _console_device;
+    /* save old device */
+    old = _console_device;
 
-	/* find new console device */
-	new = rt_device_find(name);
-	if (new != RT_NULL)
-	{
-		if (_console_device != RT_NULL)
-		{
-			/* close old console device */
-			rt_device_close(_console_device);
-		}
+    /* find new console device */
+    new = rt_device_find(name);
+    if (new != RT_NULL)
+    {
+        if (_console_device != RT_NULL)
+        {
+            /* close old console device */
+            rt_device_close(_console_device);
+        }
 
-		/* set new console device */
-		_console_device = new;
-		rt_device_open(_console_device, RT_DEVICE_OFLAG_RDWR);
-	}
+        /* set new console device */
+        _console_device = new;
+        rt_device_open(_console_device, RT_DEVICE_OFLAG_RDWR);
+    }
 
-	return old;
+    return old;
 }
 RTM_EXPORT(rt_console_set_device);
 #endif
@@ -1062,7 +1082,7 @@ void rt_hw_console_output(const char *str)
 void rt_hw_console_output(const char *str)
 #endif
 {
-	/* empty console output */
+    /* empty console output */
 }
 RTM_EXPORT(rt_hw_console_output);
 
@@ -1073,32 +1093,32 @@ RTM_EXPORT(rt_hw_console_output);
  */
 void rt_kprintf(const char *fmt, ...)
 {
-	va_list args;
-	rt_size_t length;
-	static char rt_log_buf[RT_CONSOLEBUF_SIZE];
+    va_list args;
+    rt_size_t length;
+    static char rt_log_buf[RT_CONSOLEBUF_SIZE];
 
-	va_start(args, fmt);
-	/* the return value of vsnprintf is the number of bytes that would be
-	 * written to buffer had if the size of the buffer been sufficiently
-	 * large excluding the terminating null byte. If the output string
-	 * would be larger than the rt_log_buf, we have to adjust the output
-	 * length. */
-	length = vsnprintf(rt_log_buf, sizeof(rt_log_buf) - 1, fmt, args);
-	if (length > RT_CONSOLEBUF_SIZE - 1)
-		length = RT_CONSOLEBUF_SIZE - 1;
+    va_start(args, fmt);
+    /* the return value of vsnprintf is the number of bytes that would be
+     * written to buffer had if the size of the buffer been sufficiently
+     * large excluding the terminating null byte. If the output string
+     * would be larger than the rt_log_buf, we have to adjust the output
+     * length. */
+    length = vsnprintf(rt_log_buf, sizeof(rt_log_buf) - 1, fmt, args);
+    if (length > RT_CONSOLEBUF_SIZE - 1)
+        length = RT_CONSOLEBUF_SIZE - 1;
 #ifdef RT_USING_DEVICE
-	if (_console_device == RT_NULL)
-	{
-		rt_hw_console_output(rt_log_buf);
-	}
-	else
-	{
-		rt_device_write(_console_device, 0, rt_log_buf, length);
-	}
+    if (_console_device == RT_NULL)
+    {
+        rt_hw_console_output(rt_log_buf);
+    }
+    else
+    {
+        rt_device_write(_console_device, 0, rt_log_buf, length);
+    }
 #else
-	rt_hw_console_output(rt_log_buf);
+    rt_hw_console_output(rt_log_buf);
 #endif
-	va_end(args);
+    va_end(args);
 }
 RTM_EXPORT(rt_kprintf);
 #else
@@ -1121,50 +1141,51 @@ RTM_EXPORT(rt_kprintf);
  */
 void* rt_malloc_align(rt_size_t size, rt_size_t align)
 {
-	void *align_ptr;
-	void *ptr;
-	rt_size_t align_size;
+    void *align_ptr;
+    void *ptr;
+    rt_size_t align_size;
 
-	/* align the alignment size to 4 byte */
-	align = ((align + 0x03) & ~0x03);
+    /* align the alignment size to 4 byte */
+    align = ((align + 0x03) & ~0x03);
 
-	/* get total aligned size */
-	align_size = ((size + 0x03) & ~0x03) + align;
-	/* allocate memory block from heap */
-	ptr = rt_malloc(align_size);
-	if (ptr != RT_NULL)
-	{
-		if (((rt_uint32_t)ptr & (align - 1)) == 0) /* the allocated memory block is aligned */
-		{
-			align_ptr = (void*) ((rt_uint32_t)ptr + align);
-		}
-		else
-		{
-			align_ptr = (void*) (((rt_uint32_t)ptr + (align - 1)) & ~(align - 1));
-		}
+    /* get total aligned size */
+    align_size = ((size + 0x03) & ~0x03) + align;
+    /* allocate memory block from heap */
+    ptr = rt_malloc(align_size);
+    if (ptr != RT_NULL)
+    {
+         /* the allocated memory block is aligned */
+        if (((rt_uint32_t)ptr & (align - 1)) == 0)
+        {
+            align_ptr = (void *)((rt_uint32_t)ptr + align);
+        }
+        else
+        {
+            align_ptr = (void *)(((rt_uint32_t)ptr + (align - 1)) & ~(align - 1));
+        }
 
-		/* set the pointer before alignment pointer to the real pointer */
-		*((rt_uint32_t*)((rt_uint32_t)align_ptr - sizeof(void*))) = (rt_uint32_t)ptr;
+        /* set the pointer before alignment pointer to the real pointer */
+        *((rt_uint32_t *)((rt_uint32_t)align_ptr - sizeof(void *))) = (rt_uint32_t)ptr;
 
-		ptr = align_ptr;
-	}
+        ptr = align_ptr;
+    }
 
-	return ptr;
+    return ptr;
 }
 RTM_EXPORT(rt_malloc_align);
 
 /**
- * This function release the memory block, which is allocated by rt_malloc_align
- * function and address is aligned.
+ * This function release the memory block, which is allocated by
+ * rt_malloc_align function and address is aligned.
  *
  * @param ptr the memory block pointer
  */
 void rt_free_align(void *ptr)
 {
-	void *real_ptr;
+    void *real_ptr;
 
-	real_ptr = (void*)*(rt_uint32_t*)((rt_uint32_t)ptr - sizeof(void*));
-	rt_free(real_ptr);
+    real_ptr = (void *)*(rt_uint32_t *)((rt_uint32_t)ptr - sizeof(void *));
+    rt_free(real_ptr);
 }
 RTM_EXPORT(rt_free_align);
 #endif