diff --git a/src/mem.c b/src/mem.c
index 1149c7f2fe..38bd50e902 100644
--- a/src/mem.c
+++ b/src/mem.c
@@ -74,7 +74,7 @@ static void (*rt_free_hook)(void *ptr);
  */
 void rt_malloc_sethook(void (*hook)(void *ptr, rt_size_t size))
 {
-	rt_malloc_hook = hook;
+    rt_malloc_hook = hook;
 }
 
 /**
@@ -85,7 +85,7 @@ void rt_malloc_sethook(void (*hook)(void *ptr, rt_size_t size))
  */
 void rt_free_sethook(void (*hook)(void *ptr))
 {
-	rt_free_hook = hook;
+    rt_free_hook = hook;
 }
 
 /*@}*/
@@ -95,11 +95,11 @@ void rt_free_sethook(void (*hook)(void *ptr))
 #define HEAP_MAGIC 0x1ea0
 struct heap_mem
 {
-	/* magic and used flag */
-	rt_uint16_t magic;
-	rt_uint16_t used;
+    /* magic and used flag */
+    rt_uint16_t magic;
+    rt_uint16_t used;
 
-	rt_size_t next, prev;
+    rt_size_t next, prev;
 };
 
 /** pointer to the heap: for alignment, heap_ptr is now a pointer instead of an array */
@@ -123,38 +123,42 @@ static rt_size_t used_mem, max_mem;
 
 static void plug_holes(struct heap_mem *mem)
 {
-	struct heap_mem *nmem;
-	struct heap_mem *pmem;
+    struct heap_mem *nmem;
+    struct heap_mem *pmem;
 
-	RT_ASSERT((rt_uint8_t *)mem >= heap_ptr);
-	RT_ASSERT((rt_uint8_t *)mem < (rt_uint8_t *)heap_end);
-	RT_ASSERT(mem->used == 0);
+    RT_ASSERT((rt_uint8_t *)mem >= heap_ptr);
+    RT_ASSERT((rt_uint8_t *)mem < (rt_uint8_t *)heap_end);
+    RT_ASSERT(mem->used == 0);
 
-	/* plug hole forward */
-	nmem = (struct heap_mem *)&heap_ptr[mem->next];
-	if (mem != nmem && nmem->used == 0 && (rt_uint8_t *)nmem != (rt_uint8_t *)heap_end)
-	{
-		/* if mem->next is unused and not end of heap_ptr, combine mem and mem->next */
-		if (lfree == nmem)
-		{
-			lfree = mem;
-		}
-		mem->next = nmem->next;
-		((struct heap_mem *)&heap_ptr[nmem->next])->prev = (rt_uint8_t *)mem - heap_ptr;
-	}
+    /* plug hole forward */
+    nmem = (struct heap_mem *)&heap_ptr[mem->next];
+    if (mem != nmem &&
+        nmem->used == 0 &&
+        (rt_uint8_t *)nmem != (rt_uint8_t *)heap_end)
+    {
+        /* if mem->next is unused and not end of heap_ptr,
+         * combine mem and mem->next
+         */
+        if (lfree == nmem)
+        {
+            lfree = mem;
+        }
+        mem->next = nmem->next;
+        ((struct heap_mem *)&heap_ptr[nmem->next])->prev = (rt_uint8_t *)mem - heap_ptr;
+    }
 
-	/* plug hole backward */
-	pmem = (struct heap_mem *)&heap_ptr[mem->prev];
-	if (pmem != mem && pmem->used == 0)
-	{
-		/* if mem->prev is unused, combine mem and mem->prev */
-		if (lfree == mem)
-		{
-			lfree = pmem;
-		}
-		pmem->next = mem->next;
-		((struct heap_mem *)&heap_ptr[mem->next])->prev = (rt_uint8_t *)pmem - heap_ptr;
-	}
+    /* plug hole backward */
+    pmem = (struct heap_mem *)&heap_ptr[mem->prev];
+    if (pmem != mem && pmem->used == 0)
+    {
+        /* if mem->prev is unused, combine mem and mem->prev */
+        if (lfree == mem)
+        {
+            lfree = pmem;
+        }
+        pmem->next = mem->next;
+        ((struct heap_mem *)&heap_ptr[mem->next])->prev = (rt_uint8_t *)pmem - heap_ptr;
+    }
 }
 
 /**
@@ -167,50 +171,51 @@ static void plug_holes(struct heap_mem *mem)
  */
 void rt_system_heap_init(void *begin_addr, void *end_addr)
 {
-	struct heap_mem *mem;
-	rt_uint32_t begin_align = RT_ALIGN((rt_uint32_t)begin_addr, RT_ALIGN_SIZE);
-	rt_uint32_t end_align = RT_ALIGN_DOWN((rt_uint32_t)end_addr, RT_ALIGN_SIZE);
+    struct heap_mem *mem;
+    rt_uint32_t begin_align = RT_ALIGN((rt_uint32_t)begin_addr, RT_ALIGN_SIZE);
+    rt_uint32_t end_align = RT_ALIGN_DOWN((rt_uint32_t)end_addr, RT_ALIGN_SIZE);
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	/* alignment addr */
-	if ((end_align > (2 * SIZEOF_STRUCT_MEM)) &&
-		((end_align - 2 * SIZEOF_STRUCT_MEM) >= begin_align))
-	{
-		/* calculate the aligned memory size */
-		mem_size_aligned = end_align - begin_align - 2 * SIZEOF_STRUCT_MEM;
-	}
-	else
-	{
-		rt_kprintf("mem init, error begin address 0x%x, and end address 0x%x\n", (rt_uint32_t)begin_addr, (rt_uint32_t)end_addr);
-		
-		return;
-	}
+    /* alignment addr */
+    if ((end_align > (2 * SIZEOF_STRUCT_MEM)) &&
+        ((end_align - 2 * SIZEOF_STRUCT_MEM) >= begin_align))
+    {
+        /* calculate the aligned memory size */
+        mem_size_aligned = end_align - begin_align - 2 * SIZEOF_STRUCT_MEM;
+    }
+    else
+    {
+        rt_kprintf("mem init, error begin address 0x%x, and end address 0x%x\n",
+                   (rt_uint32_t)begin_addr, (rt_uint32_t)end_addr);
 
-	/* point to begin address of heap */
-	heap_ptr = (rt_uint8_t *)begin_align;
+        return;
+    }
 
-	RT_DEBUG_LOG(RT_DEBUG_MEM, ("mem init, heap begin address 0x%x, size %d\n",
+    /* point to begin address of heap */
+    heap_ptr = (rt_uint8_t *)begin_align;
+
+    RT_DEBUG_LOG(RT_DEBUG_MEM, ("mem init, heap begin address 0x%x, size %d\n",
                                 (rt_uint32_t)heap_ptr, mem_size_aligned));
 
-	/* initialize the start of the heap */
-	mem = (struct heap_mem *)heap_ptr;
-	mem->magic= HEAP_MAGIC;
-	mem->next = mem_size_aligned + SIZEOF_STRUCT_MEM;
-	mem->prev = 0;
-	mem->used = 0;
+    /* initialize the start of the heap */
+    mem        = (struct heap_mem *)heap_ptr;
+    mem->magic = HEAP_MAGIC;
+    mem->next  = mem_size_aligned + SIZEOF_STRUCT_MEM;
+    mem->prev  = 0;
+    mem->used  = 0;
 
-	/* initialize the end of the heap */
-	heap_end = (struct heap_mem *)&heap_ptr[mem->next];
-	heap_end->magic= HEAP_MAGIC;
-	heap_end->used = 1;
-	heap_end->next = mem_size_aligned + SIZEOF_STRUCT_MEM;
-	heap_end->prev = mem_size_aligned + SIZEOF_STRUCT_MEM;
+    /* initialize the end of the heap */
+    heap_end        = (struct heap_mem *)&heap_ptr[mem->next];
+    heap_end->magic = HEAP_MAGIC;
+    heap_end->used  = 1;
+    heap_end->next  = mem_size_aligned + SIZEOF_STRUCT_MEM;
+    heap_end->prev  = mem_size_aligned + SIZEOF_STRUCT_MEM;
 
-	rt_sem_init(&heap_sem, "heap", 1, RT_IPC_FLAG_FIFO);
+    rt_sem_init(&heap_sem, "heap", 1, RT_IPC_FLAG_FIFO);
 
-	/* initialize the lowest-free pointer to the start of the heap */
-	lfree = (struct heap_mem *)heap_ptr;
+    /* initialize the lowest-free pointer to the start of the heap */
+    lfree = (struct heap_mem *)heap_ptr;
 }
 
 /**
@@ -228,129 +233,132 @@ void rt_system_heap_init(void *begin_addr, void *end_addr)
  */
 void *rt_malloc(rt_size_t size)
 {
-	rt_size_t ptr, ptr2;
-	struct heap_mem *mem, *mem2;
+    rt_size_t ptr, ptr2;
+    struct heap_mem *mem, *mem2;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	if (size == 0)
-		return RT_NULL;
+    if (size == 0)
+        return RT_NULL;
 
-	if (size != RT_ALIGN(size, RT_ALIGN_SIZE))
-		RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n",
+    if (size != RT_ALIGN(size, RT_ALIGN_SIZE))
+        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n",
                                     size, RT_ALIGN(size, RT_ALIGN_SIZE)));
-	else
-		RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size));
+    else
+        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size));
 
-	/* alignment size */
-	size = RT_ALIGN(size, RT_ALIGN_SIZE);
+    /* alignment size */
+    size = RT_ALIGN(size, RT_ALIGN_SIZE);
 
-	if (size > mem_size_aligned)
-	{
-		RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n"));
+    if (size > mem_size_aligned)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n"));
 
-		return RT_NULL;
-	}
+        return RT_NULL;
+    }
 
-	/* every data block must be at least MIN_SIZE_ALIGNED long */
-	if (size < MIN_SIZE_ALIGNED)
-		size = MIN_SIZE_ALIGNED;
+    /* every data block must be at least MIN_SIZE_ALIGNED long */
+    if (size < MIN_SIZE_ALIGNED)
+        size = MIN_SIZE_ALIGNED;
 
-	/* take memory semaphore */
-	rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
+    /* take memory semaphore */
+    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
 
-	for (ptr = (rt_uint8_t *)lfree - heap_ptr; ptr < mem_size_aligned - size;
-		ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
-	{
-		mem = (struct heap_mem *)&heap_ptr[ptr];
+    for (ptr = (rt_uint8_t *)lfree - heap_ptr;
+         ptr < mem_size_aligned - size;
+         ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
+    {
+        mem = (struct heap_mem *)&heap_ptr[ptr];
 
-		if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)
-		{
-			/* mem is not used and at least perfect fit is possible:
-			 * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */
+        if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)
+        {
+            /* mem is not used and at least perfect fit is possible:
+             * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */
 
-			if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))
-			{
-				/* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing
-				 * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
-				 * -> split large block, create empty remainder,
-				 * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
-				 * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
-				 * struct heap_mem would fit in but no data between mem2 and mem2->next
-				 * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
-				 *       region that couldn't hold data, but when mem->next gets freed,
-				 *       the 2 regions would be combined, resulting in more free memory
-				 */
-				ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
+            if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
+                (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))
+            {
+                /* (in addition to the above, we test if another struct heap_mem (SIZEOF_STRUCT_MEM) containing
+                 * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem')
+                 * -> split large block, create empty remainder,
+                 * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if
+                 * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
+                 * struct heap_mem would fit in but no data between mem2 and mem2->next
+                 * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty
+                 *       region that couldn't hold data, but when mem->next gets freed,
+                 *       the 2 regions would be combined, resulting in more free memory
+                 */
+                ptr2 = ptr + SIZEOF_STRUCT_MEM + size;
 
-				/* create mem2 struct */
-				mem2 = (struct heap_mem *)&heap_ptr[ptr2];
-				mem2->used = 0;
-				mem2->next = mem->next;
-				mem2->prev = ptr;
+                /* create mem2 struct */
+                mem2       = (struct heap_mem *)&heap_ptr[ptr2];
+                mem2->used = 0;
+                mem2->next = mem->next;
+                mem2->prev = ptr;
 
-				/* and insert it between mem and mem->next */
-				mem->next = ptr2;
-				mem->used = 1;
+                /* and insert it between mem and mem->next */
+                mem->next = ptr2;
+                mem->used = 1;
 
-				if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
-				{
-					((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
-				}
+                if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
+                {
+                    ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
+                }
 #ifdef RT_MEM_STATS
-				used_mem += (size + SIZEOF_STRUCT_MEM);
-				if (max_mem < used_mem)
-					max_mem = used_mem;
+                used_mem += (size + SIZEOF_STRUCT_MEM);
+                if (max_mem < used_mem)
+                    max_mem = used_mem;
 #endif
-			}
-			else
-			{
-				/* (a mem2 struct does no fit into the user data space of mem and mem->next will always
-				 * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
-				 * take care of this).
-				 * -> near fit or excact fit: do not split, no mem2 creation
-				 * also can't move mem->next directly behind mem, since mem->next
-				 * will always be used at this point!
-				 */
-				mem->used = 1;
+            }
+            else
+            {
+                /* (a mem2 struct does no fit into the user data space of mem and mem->next will always
+                 * be used at this point: if not we have 2 unused structs in a row, plug_holes should have
+                 * take care of this).
+                 * -> near fit or excact fit: do not split, no mem2 creation
+                 * also can't move mem->next directly behind mem, since mem->next
+                 * will always be used at this point!
+                 */
+                mem->used = 1;
 #ifdef RT_MEM_STATS
-				used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr);
-				if (max_mem < used_mem)
-					max_mem = used_mem;
+                used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr);
+                if (max_mem < used_mem)
+                    max_mem = used_mem;
 #endif
-			}
-			/* set memory block magic */
-			mem->magic = HEAP_MAGIC;
+            }
+            /* set memory block magic */
+            mem->magic = HEAP_MAGIC;
 
-			if (mem == lfree)
-			{
-				/* Find next free block after mem and update lowest free pointer */
-				while (lfree->used && lfree != heap_end)
-					lfree = (struct heap_mem *)&heap_ptr[lfree->next];
+            if (mem == lfree)
+            {
+                /* Find next free block after mem and update lowest free pointer */
+                while (lfree->used && lfree != heap_end)
+                    lfree = (struct heap_mem *)&heap_ptr[lfree->next];
 
-				RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
-			}
+                RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
+            }
 
-			rt_sem_release(&heap_sem);
-			RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end);
- 			RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
-			RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0);
+            rt_sem_release(&heap_sem);
+            RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end);
+            RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
+            RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0);
 
-			RT_DEBUG_LOG(RT_DEBUG_MEM,
+            RT_DEBUG_LOG(RT_DEBUG_MEM,
                          ("allocate memory at 0x%x, size: %d\n", 
                           (rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
                           (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));
 
-			RT_OBJECT_HOOK_CALL(rt_malloc_hook, (((void*)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size));
-			
-			/* return the memory data except mem struct */
-			return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
-		}
-	}
+            RT_OBJECT_HOOK_CALL(rt_malloc_hook,
+                                (((void *)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size));
 
-	rt_sem_release(&heap_sem);
-	
-	return RT_NULL;
+            /* return the memory data except mem struct */
+            return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
+        }
+    }
+
+    rt_sem_release(&heap_sem);
+
+    return RT_NULL;
 }
 RTM_EXPORT(rt_malloc);
 
@@ -364,85 +372,85 @@ RTM_EXPORT(rt_malloc);
  */
 void *rt_realloc(void *rmem, rt_size_t newsize)
 {
-	rt_size_t size;
-	rt_size_t ptr, ptr2;
-	struct heap_mem *mem, *mem2;
-	void *nmem;
+    rt_size_t size;
+    rt_size_t ptr, ptr2;
+    struct heap_mem *mem, *mem2;
+    void *nmem;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	/* alignment size */
-	newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
-	if (newsize > mem_size_aligned)
-	{
-		RT_DEBUG_LOG(RT_DEBUG_MEM, ("realloc: out of memory\n"));
+    /* alignment size */
+    newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
+    if (newsize > mem_size_aligned)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_MEM, ("realloc: out of memory\n"));
 
-		return RT_NULL;
-	}
+        return RT_NULL;
+    }
 
-	/* allocate a new memory block */
-	if (rmem == RT_NULL)
-		return rt_malloc(newsize);
+    /* allocate a new memory block */
+    if (rmem == RT_NULL)
+        return rt_malloc(newsize);
 
-	rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
+    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
 
-	if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr ||
-		(rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
-	{
-		/* illegal memory */
-		rt_sem_release(&heap_sem);
+    if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr ||
+        (rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
+    {
+        /* illegal memory */
+        rt_sem_release(&heap_sem);
 
-		return rmem;
-	}
+        return rmem;
+    }
 
-	mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
+    mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
 
-	ptr = (rt_uint8_t *)mem - heap_ptr;
-	size = mem->next - ptr - SIZEOF_STRUCT_MEM;
-	if (size == newsize)
-	{
-		/* the size is the same as */
-		rt_sem_release(&heap_sem);
+    ptr = (rt_uint8_t *)mem - heap_ptr;
+    size = mem->next - ptr - SIZEOF_STRUCT_MEM;
+    if (size == newsize)
+    {
+        /* the size is the same as */
+        rt_sem_release(&heap_sem);
 
-		return rmem;
-	}
+        return rmem;
+    }
 
-	if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE < size)
-	{
-		/* split memory block */
+    if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE < size)
+    {
+        /* split memory block */
 #ifdef RT_MEM_STATS
-  		used_mem -= (size - newsize);
+        used_mem -= (size - newsize);
 #endif
 
-		ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize;
-		mem2 = (struct heap_mem *)&heap_ptr[ptr2];
-		mem2->magic= HEAP_MAGIC;
-		mem2->used = 0;
-		mem2->next = mem->next;
-		mem2->prev = ptr;
-		mem->next = ptr2;
-		if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
-		{
-			((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
-		}
+        ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize;
+        mem2 = (struct heap_mem *)&heap_ptr[ptr2];
+        mem2->magic= HEAP_MAGIC;
+        mem2->used = 0;
+        mem2->next = mem->next;
+        mem2->prev = ptr;
+        mem->next = ptr2;
+        if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
+        {
+            ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
+        }
 
-		plug_holes(mem2);
+        plug_holes(mem2);
 
-		rt_sem_release(&heap_sem);
+        rt_sem_release(&heap_sem);
 
-		return rmem;
-	}
-	rt_sem_release(&heap_sem);
+        return rmem;
+    }
+    rt_sem_release(&heap_sem);
 
-	/* expand memory */
-	nmem = rt_malloc(newsize);
-	if (nmem != RT_NULL) /* check memory */
-	{
-		rt_memcpy(nmem, rmem, size < newsize ? size : newsize);	
-		rt_free(rmem);
-	}
+    /* expand memory */
+    nmem = rt_malloc(newsize);
+    if (nmem != RT_NULL) /* check memory */
+    {
+        rt_memcpy(nmem, rmem, size < newsize ? size : newsize); 
+        rt_free(rmem);
+    }
 
-	return nmem;
+    return nmem;
 }
 RTM_EXPORT(rt_realloc);
 
@@ -460,98 +468,105 @@ RTM_EXPORT(rt_realloc);
  */
 void *rt_calloc(rt_size_t count, rt_size_t size)
 {
-	void *p;
+    void *p;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	/* allocate 'count' objects of size 'size' */
-	p = rt_malloc(count * size);
+    /* allocate 'count' objects of size 'size' */
+    p = rt_malloc(count * size);
 
-	/* zero the memory */
-	if (p)
-		rt_memset(p, 0, count * size);
+    /* zero the memory */
+    if (p)
+        rt_memset(p, 0, count * size);
 
-	return p;
+    return p;
 }
 RTM_EXPORT(rt_calloc);
 
 /**
- * This function will release the previously allocated memory block by rt_malloc.
- * The released memory block is taken back to system heap.
+ * This function will release the previously allocated memory block by
+ * rt_malloc. The released memory block is taken back to system heap.
  *
  * @param rmem the address of memory which will be released
  */
 void rt_free(void *rmem)
 {
-	struct heap_mem *mem;
+    struct heap_mem *mem;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	if (rmem == RT_NULL)
-		return;
-	RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE-1)) == 0);
-	RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
-			  (rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);
+    if (rmem == RT_NULL)
+        return;
+    RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE-1)) == 0);
+    RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
+              (rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);
 
-	RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem));
+    RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem));
 
-	if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr || (rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
-	{
-		RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n"));
+    if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr ||
+        (rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n"));
 
-		return;
-	}
+        return;
+    }
 
-	/* Get the corresponding struct heap_mem ... */
-	mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
+    /* Get the corresponding struct heap_mem ... */
+    mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
 
-	RT_DEBUG_LOG(RT_DEBUG_MEM,
+    RT_DEBUG_LOG(RT_DEBUG_MEM,
                  ("release memory 0x%x, size: %d\n", 
                   (rt_uint32_t)rmem, 
                   (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));
 
 
-	/* protect the heap from concurrent access */
-	rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
+    /* protect the heap from concurrent access */
+    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
 
-	/* ... which has to be in a used state ... */
-	RT_ASSERT(mem->used);
-	RT_ASSERT(mem->magic == HEAP_MAGIC);
-	/* ... and is now unused. */
-	mem->used = 0;
-	mem->magic = 0;
+    /* ... which has to be in a used state ... */
+    RT_ASSERT(mem->used);
+    RT_ASSERT(mem->magic == HEAP_MAGIC);
+    /* ... and is now unused. */
+    mem->used  = 0;
+    mem->magic = 0;
 
-	if (mem < lfree)
-	{
-		/* the newly freed struct is now the lowest */
-		lfree = mem;
-	}
+    if (mem < lfree)
+    {
+        /* the newly freed struct is now the lowest */
+        lfree = mem;
+    }
 
 #ifdef RT_MEM_STATS
-	used_mem -= (mem->next - ((rt_uint8_t*)mem - heap_ptr));
+    used_mem -= (mem->next - ((rt_uint8_t*)mem - heap_ptr));
 #endif
 
-	/* finally, see if prev or next are free also */
-	plug_holes(mem);
-	rt_sem_release(&heap_sem);
+    /* finally, see if prev or next are free also */
+    plug_holes(mem);
+    rt_sem_release(&heap_sem);
 }
 RTM_EXPORT(rt_free);
 
 #ifdef RT_MEM_STATS
-void rt_memory_info(rt_uint32_t *total, rt_uint32_t *used, rt_uint32_t *max_used)
+void rt_memory_info(rt_uint32_t *total,
+                    rt_uint32_t *used,
+                    rt_uint32_t *max_used)
 {
-	if (total != RT_NULL) *total = mem_size_aligned;
-	if (used  != RT_NULL) *used = used_mem;
-	if (max_used != RT_NULL) *max_used = max_mem;
+    if (total != RT_NULL)
+        *total = mem_size_aligned;
+    if (used  != RT_NULL)
+        *used = used_mem;
+    if (max_used != RT_NULL)
+        *max_used = max_mem;
 }
 
 #ifdef RT_USING_FINSH
 #include <finsh.h>
+
 void list_mem(void)
 {
-	rt_kprintf("total memory: %d\n", mem_size_aligned);
-	rt_kprintf("used memory : %d\n", used_mem);
-	rt_kprintf("maximum allocated memory: %d\n", max_mem);
+    rt_kprintf("total memory: %d\n", mem_size_aligned);
+    rt_kprintf("used memory : %d\n", used_mem);
+    rt_kprintf("maximum allocated memory: %d\n", max_mem);
 }
 FINSH_FUNCTION_EXPORT(list_mem, list memory usage information)
 #endif