reformat the coding style

convert Tabs to spaces

1 files changed, 102 insertions, 95 deletions

diff --git a/src/memheap.c b/src/memheap.c
index 4aae16432f..8c386d8e71 100644
--- a/src/memheap.c
+++ b/src/memheap.c
@@ -286,36 +286,37 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
 }
 RTM_EXPORT(rt_memheap_alloc);
 
-void *rt_memheap_realloc(struct rt_memheap* heap, void* ptr, rt_size_t newsize)
+void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize)
 {
     rt_err_t result;
-	rt_size_t oldsize;
-	struct rt_memheap_item *header_ptr;
-	struct rt_memheap_item *new_ptr;
+    rt_size_t oldsize;
+    struct rt_memheap_item *header_ptr;
+    struct rt_memheap_item *new_ptr;
+
+    if (newsize == 0)
+    {
+        rt_memheap_free(ptr);
 
-	if (newsize == 0)
-	{
-		rt_memheap_free(ptr);
-		return RT_NULL;
-	}
-	/* align allocated size */
-	newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
-	if (newsize < RT_MEMHEAP_MINIALLOC)
-		newsize = RT_MEMHEAP_MINIALLOC;
+        return RT_NULL;
+    }
+    /* align allocated size */
+    newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
+    if (newsize < RT_MEMHEAP_MINIALLOC)
+        newsize = RT_MEMHEAP_MINIALLOC;
 
-	if (ptr == RT_NULL)
-	{
-		return rt_memheap_alloc(heap, newsize);
-	}
+    if (ptr == RT_NULL)
+    {
+        return rt_memheap_alloc(heap, newsize);
+    }
 
-	/* get memory block header and get the size of memory block */
-	header_ptr = (struct rt_memheap_item*)((rt_uint8_t *)ptr -
-		RT_MEMHEAP_SIZE);
-	oldsize = MEMITEM_SIZE(header_ptr);
+    /* get memory block header and get the size of memory block */
+    header_ptr = (struct rt_memheap_item *)
+                 ((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE);
+    oldsize = MEMITEM_SIZE(header_ptr);
      /* re-allocate memory */
     if (newsize > oldsize)
     {
-		void* new_ptr;
+        void* new_ptr;
         /* re-allocate a memory block */
         new_ptr = (void*)rt_memheap_alloc(heap, newsize);
         if (new_ptr != RT_NULL)
@@ -327,74 +328,75 @@ void *rt_memheap_realloc(struct rt_memheap* heap, void* ptr, rt_size_t newsize)
         return new_ptr;
     }
 
-	/* lock memheap */
-	result = rt_sem_take(&(heap->lock), RT_WAITING_FOREVER);
-	if (result != RT_EOK)
-	{
-		rt_set_errno(result);
-		return RT_NULL;
-	}
+    /* lock memheap */
+    result = rt_sem_take(&(heap->lock), RT_WAITING_FOREVER);
+    if (result != RT_EOK)
+    {
+        rt_set_errno(result);
 
-	/* split the block. */
-	new_ptr = (struct rt_memheap_item *)
-			  (((rt_uint8_t *)header_ptr) + newsize + RT_MEMHEAP_SIZE);
+        return RT_NULL;
+    }
 
-	RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
-				 ("split: block[0x%08x] nextm[0x%08x] prevm[0x%08x] to new[0x%08x]",
-				  header_ptr,
-				  header_ptr->next,
-				  header_ptr->prev,
-				  new_ptr));
+    /* split the block. */
+    new_ptr = (struct rt_memheap_item *)
+              (((rt_uint8_t *)header_ptr) + newsize + RT_MEMHEAP_SIZE);
 
-	/* mark the new block as a memory block and freed. */
-	new_ptr->magic = RT_MEMHEAP_MAGIC;
-	/* put the pool pointer into the new block. */
-	new_ptr->pool_ptr = heap;
+    RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
+                 ("split: block[0x%08x] nextm[0x%08x] prevm[0x%08x] to new[0x%08x]",
+                  header_ptr,
+                  header_ptr->next,
+                  header_ptr->prev,
+                  new_ptr));
 
-	/* break down the block list */
-	new_ptr->prev		   = header_ptr;
-	new_ptr->next		   = header_ptr->next;
-	header_ptr->next->prev = new_ptr;
-	header_ptr->next	   = new_ptr;
+    /* mark the new block as a memory block and freed. */
+    new_ptr->magic = RT_MEMHEAP_MAGIC;
+    /* put the pool pointer into the new block. */
+    new_ptr->pool_ptr = heap;
 
-	/* determine if the block can be merged with the next neighbor. */
-	if (!RT_MEMHEAP_IS_USED(new_ptr->next))
-	{
-		struct rt_memheap_item *free_ptr;
+    /* break down the block list */
+    new_ptr->prev          = header_ptr;
+    new_ptr->next          = header_ptr->next;
+    header_ptr->next->prev = new_ptr;
+    header_ptr->next       = new_ptr;
 
-		/* merge block with next neighbor. */
-		free_ptr = new_ptr->next;
-		heap->available_size = heap->available_size - MEMITEM_SIZE(free_ptr);
+    /* determine if the block can be merged with the next neighbor. */
+    if (!RT_MEMHEAP_IS_USED(new_ptr->next))
+    {
+        struct rt_memheap_item *free_ptr;
 
-		RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
-					 ("merge: right node 0x%08x, next_free 0x%08x, prev_free 0x%08x",
-					  header_ptr, header_ptr->next_free, header_ptr->prev_free));
+        /* merge block with next neighbor. */
+        free_ptr = new_ptr->next;
+        heap->available_size = heap->available_size - MEMITEM_SIZE(free_ptr);
 
-		free_ptr->next->prev = new_ptr;
-		new_ptr->next	= free_ptr->next;
+        RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
+                     ("merge: right node 0x%08x, next_free 0x%08x, prev_free 0x%08x",
+                      header_ptr, header_ptr->next_free, header_ptr->prev_free));
+
+        free_ptr->next->prev = new_ptr;
+        new_ptr->next   = free_ptr->next;
 
-		/* remove free ptr from free list */
-		free_ptr->next_free->prev_free = free_ptr->prev_free;
-		free_ptr->prev_free->next_free = free_ptr->next_free;
-	}
+        /* remove free ptr from free list */
+        free_ptr->next_free->prev_free = free_ptr->prev_free;
+        free_ptr->prev_free->next_free = free_ptr->next_free;
+    }
 
-	/* insert the split block to free list */
-	new_ptr->next_free = heap->free_list->next_free;
-	new_ptr->prev_free = heap->free_list;
-	heap->free_list->next_free->prev_free = new_ptr;
-	heap->free_list->next_free			  = new_ptr;
-	RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("new free ptr: next_free 0x%08x, prev_free 0x%08x",
-									new_ptr->next_free,
-									new_ptr->prev_free));
+    /* insert the split block to free list */
+    new_ptr->next_free = heap->free_list->next_free;
+    new_ptr->prev_free = heap->free_list;
+    heap->free_list->next_free->prev_free = new_ptr;
+    heap->free_list->next_free            = new_ptr;
+    RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("new free ptr: next_free 0x%08x, prev_free 0x%08x",
+                                    new_ptr->next_free,
+                                    new_ptr->prev_free));
 
-	/* increment the available byte count.	*/
-	heap->available_size = heap->available_size + MEMITEM_SIZE(new_ptr);
+    /* increment the available byte count.  */
+    heap->available_size = heap->available_size + MEMITEM_SIZE(new_ptr);
 
     /* release lock */
     rt_sem_release(&(heap->lock));
 
-	/* return the old memory block */
-	return ptr;
+    /* return the old memory block */
+    return ptr;
 }
 RTM_EXPORT(rt_memheap_realloc);
 
@@ -408,8 +410,8 @@ void rt_memheap_free(void *ptr)
     /* set initial status as OK */
     insert_header = 1;
     new_ptr       = RT_NULL;
-    header_ptr    = (struct rt_memheap_item *)((rt_uint8_t *)ptr -
-                                               RT_MEMHEAP_SIZE);
+    header_ptr    = (struct rt_memheap_item *)
+                    ((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE);
 
     RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("free memory: memory[0x%08x], block[0x%08x]",
                                     ptr, header_ptr));
@@ -425,6 +427,7 @@ void rt_memheap_free(void *ptr)
     if (result != RT_EOK)
     {
         rt_set_errno(result);
+
         return ;
     }
 
@@ -548,31 +551,35 @@ RTM_EXPORT(rt_free);
 
 void *rt_realloc(void *rmem, rt_size_t newsize)
 {
-	void *new_ptr;
+    void *new_ptr;
     struct rt_memheap_item *header_ptr;
 
-	if (rmem == RT_NULL) return rt_malloc(newsize);
+    if (rmem == RT_NULL)
+        return rt_malloc(newsize);
 
     /* get old memory item */
-    header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)rmem - RT_MEMHEAP_SIZE);
+    header_ptr = (struct rt_memheap_item *)
+                 ((rt_uint8_t *)rmem - RT_MEMHEAP_SIZE);
 
-	new_ptr = rt_memheap_realloc(header_ptr->pool_ptr, rmem, newsize);
-	if (new_ptr == RT_NULL && newsize != 0)
-	{
-		/* allocate memory block from other memheap */
-		new_ptr = rt_malloc(newsize);
-		if (new_ptr != RT_NULL && rmem != RT_NULL)
-		{
-			rt_size_t oldsize;
+    new_ptr = rt_memheap_realloc(header_ptr->pool_ptr, rmem, newsize);
+    if (new_ptr == RT_NULL && newsize != 0)
+    {
+        /* allocate memory block from other memheap */
+        new_ptr = rt_malloc(newsize);
+        if (new_ptr != RT_NULL && rmem != RT_NULL)
+        {
+            rt_size_t oldsize;
 
-			/* get the size of old memory block */
-			oldsize = MEMITEM_SIZE(header_ptr);
-			if (newsize > oldsize) rt_memcpy(new_ptr, rmem, oldsize);
-			else rt_memcpy(new_ptr, rmem, newsize);
-		}
-	}
+            /* get the size of old memory block */
+            oldsize = MEMITEM_SIZE(header_ptr);
+            if (newsize > oldsize)
+                rt_memcpy(new_ptr, rmem, oldsize);
+            else
+                rt_memcpy(new_ptr, rmem, newsize);
+        }
+    }
 
-	return new_ptr;
+    return new_ptr;
 }
 RTM_EXPORT(rt_realloc);