[kernel & MemMang] use space to replace tab and remove meaningless space in the end of each line (#314)

mysterywolf · alfred2g · web-flow · commit d8770748ffb5 · 2021-04-19T09:58:55.000-07:00
Signed-off-by: Meco Man &lt;920369182@qq.com&gt;

Co-authored-by: alfred gedeon &lt;28123637+alfred2g@users.noreply.github.com&gt;
diff --git a/include/croutine.h b/include/croutine.h
@@ -65,7 +65,7 @@ typedef struct corCoRoutineControlBlock
  *                               crCOROUTINE_CODE pxCoRoutineCode,
  *                               UBaseType_t uxPriority,
  *                               UBaseType_t uxIndex
- *                             ); 
+ *                             );
  * </pre>
  *
  * Create a new co-routine and add it to the list of co-routines that are
diff --git a/include/timers.h b/include/timers.h
@@ -1329,10 +1329,10 @@ BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
     /**
      * task.h
      * <pre>void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer, StackType_t ** ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ) </pre>
-     * 
-     * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Timer Task TCB.  This function is required when 
+     *
+     * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Timer Task TCB.  This function is required when
      * configSUPPORT_STATIC_ALLOCATION is set.  For more information see this URI: https://www.FreeRTOS.org/a00110.html#configSUPPORT_STATIC_ALLOCATION
-     * 
+     *
      * @param ppxTimerTaskTCBBuffer   A handle to a statically allocated TCB buffer
      * @param ppxTimerTaskStackBuffer A handle to a statically allocated Stack buffer for thie idle task
      * @param pulTimerTaskStackSize   A pointer to the number of elements that will fit in the allocated stack buffer
diff --git a/portable/MemMang/heap_1.c b/portable/MemMang/heap_1.c
@@ -80,8 +80,8 @@ void * pvPortMalloc( size_t xWantedSize )
                 if ( (xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) )) > xWantedSize )
                 {
                     xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
-                } 
-                else 
+                }
+                else
                 {
                     xWantedSize = 0;
                 }
diff --git a/portable/MemMang/heap_2.c b/portable/MemMang/heap_2.c
@@ -133,13 +133,13 @@ void * pvPortMalloc( size_t xWantedSize )
 
         /* The wanted size must be increased so it can contain a BlockLink_t
          * structure in addition to the requested amount of bytes. */
-        if( ( xWantedSize > 0 ) && 
+        if( ( xWantedSize > 0 ) &&
             ( ( xWantedSize + heapSTRUCT_SIZE ) >  xWantedSize ) ) /* Overflow check */
         {
             xWantedSize += heapSTRUCT_SIZE;
 
             /* Byte alignment required. Check for overflow. */
-            if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) 
+            if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )
                     > xWantedSize )
             {
                 xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
@@ -148,11 +148,11 @@ void * pvPortMalloc( size_t xWantedSize )
             else
             {
                 xWantedSize = 0;
-            }       
+            }
         }
-        else 
+        else
         {
-            xWantedSize = 0; 
+            xWantedSize = 0;
         }
 
 
diff --git a/portable/MemMang/heap_4.c b/portable/MemMang/heap_4.c
@@ -138,7 +138,7 @@ void * pvPortMalloc( size_t xWantedSize )
         {
             /* The wanted size must be increased so it can contain a BlockLink_t
              * structure in addition to the requested amount of bytes. */
-            if( ( xWantedSize > 0 ) && 
+            if( ( xWantedSize > 0 ) &&
                 ( ( xWantedSize + xHeapStructSize ) >  xWantedSize ) ) /* Overflow check */
             {
                 xWantedSize += xHeapStructSize;
@@ -147,7 +147,7 @@ void * pvPortMalloc( size_t xWantedSize )
                 if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
                 {
                     /* Byte alignment required. Check for overflow. */
-                    if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) 
+                    if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )
                             > xWantedSize )
                     {
                         xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
@@ -156,21 +156,21 @@ void * pvPortMalloc( size_t xWantedSize )
                     else
                     {
                         xWantedSize = 0;
-                    }  
+                    }
                 }
                 else
                 {
                     mtCOVERAGE_TEST_MARKER();
                 }
-            } 
-            else 
+            }
+            else
             {
                 xWantedSize = 0;
             }
 
             if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
             {
-                /* Traverse the list from the start	(lowest address) block until
+                /* Traverse the list from the start (lowest address) block until
                  * one of adequate size is found. */
                 pxPreviousBlock = &xStart;
                 pxBlock = xStart.pxNextFreeBlock;
diff --git a/portable/MemMang/heap_5.c b/portable/MemMang/heap_5.c
@@ -45,8 +45,8 @@
  *
  * typedef struct HeapRegion
  * {
- *	uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.
- *	size_t xSizeInBytes;	  << Size of the block of memory.
+ *  uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.
+ *  size_t xSizeInBytes;      << Size of the block of memory.
  * } HeapRegion_t;
  *
  * The array is terminated using a NULL zero sized region definition, and the
@@ -149,7 +149,7 @@ void * pvPortMalloc( size_t xWantedSize )
         {
             /* The wanted size is increased so it can contain a BlockLink_t
              * structure in addition to the requested amount of bytes. */
-            if( ( xWantedSize > 0 ) && 
+            if( ( xWantedSize > 0 ) &&
                 ( ( xWantedSize + xHeapStructSize ) >  xWantedSize ) ) /* Overflow check */
             {
                 xWantedSize += xHeapStructSize;
@@ -162,8 +162,8 @@ void * pvPortMalloc( size_t xWantedSize )
                          xWantedSize )
                     {
                         xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
-                    } 
-                    else 
+                    }
+                    else
                     {
                         xWantedSize = 0;
                     }
@@ -180,7 +180,7 @@ void * pvPortMalloc( size_t xWantedSize )
 
             if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
             {
-                /* Traverse the list from the start	(lowest address) block until
+                /* Traverse the list from the start (lowest address) block until
                  * one of adequate size is found. */
                 pxPreviousBlock = &xStart;
                 pxBlock = xStart.pxNextFreeBlock;
diff --git a/timers.c b/timers.c
@@ -523,7 +523,7 @@
         {
             /* Advance the expiry time. */
             xExpiredTime += pxTimer->xTimerPeriodInTicks;
-            
+
             /* Call the timer callback. */
             traceTIMER_EXPIRED( pxTimer );
             pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ typedef struct corCoRoutineControlBlock`
`65`	`65`	`* crCOROUTINE_CODE pxCoRoutineCode,`
`66`	`66`	`* UBaseType_t uxPriority,`
`67`	`67`	`* UBaseType_t uxIndex`
`68`		`- * );`
	`68`	`+ * );`
`69`	`69`	`* </pre>`
`70`	`70`	`*`
`71`	`71`	`* Create a new co-routine and add it to the list of co-routines that are`
Original file line number	Diff line number	Diff line change
`@@ -80,8 +80,8 @@ void * pvPortMalloc( size_t xWantedSize )`
`80`	`80`	`if ( (xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) )) > xWantedSize )`
`81`	`81`	`{`
`82`	`82`	`xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );`
`83`		`- }`
`84`		`- else`
	`83`	`+ }`
	`84`	`+ else`
`85`	`85`	`{`
`86`	`86`	`xWantedSize = 0;`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,13 +133,13 @@ void * pvPortMalloc( size_t xWantedSize )`
`133`	`133`
`134`	`134`	`/* The wanted size must be increased so it can contain a BlockLink_t`
`135`	`135`	`* structure in addition to the requested amount of bytes. */`
`136`		`- if( ( xWantedSize > 0 ) &&`
	`136`	`+ if( ( xWantedSize > 0 ) &&`
`137`	`137`	`( ( xWantedSize + heapSTRUCT_SIZE ) > xWantedSize ) ) /* Overflow check */`
`138`	`138`	`{`
`139`	`139`	`xWantedSize += heapSTRUCT_SIZE;`
`140`	`140`
`141`	`141`	`/* Byte alignment required. Check for overflow. */`
`142`		`- if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )`
	`142`	`+ if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )`
`143`	`143`	`> xWantedSize )`
`144`	`144`	`{`
`145`	`145`	`xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );`
`@@ -148,11 +148,11 @@ void * pvPortMalloc( size_t xWantedSize )`
`148`	`148`	`else`
`149`	`149`	`{`
`150`	`150`	`xWantedSize = 0;`
`151`		`- }`
	`151`	`+ }`
`152`	`152`	`}`
`153`		`- else`
	`153`	`+ else`
`154`	`154`	`{`
`155`		`- xWantedSize = 0;`
	`155`	`+ xWantedSize = 0;`
`156`	`156`	`}`
`157`	`157`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ void * pvPortMalloc( size_t xWantedSize )`
`138`	`138`	`{`
`139`	`139`	`/* The wanted size must be increased so it can contain a BlockLink_t`
`140`	`140`	`* structure in addition to the requested amount of bytes. */`
`141`		`- if( ( xWantedSize > 0 ) &&`
	`141`	`+ if( ( xWantedSize > 0 ) &&`
`142`	`142`	`( ( xWantedSize + xHeapStructSize ) > xWantedSize ) ) /* Overflow check */`
`143`	`143`	`{`
`144`	`144`	`xWantedSize += xHeapStructSize;`
`@@ -147,7 +147,7 @@ void * pvPortMalloc( size_t xWantedSize )`
`147`	`147`	`if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )`
`148`	`148`	`{`
`149`	`149`	`/* Byte alignment required. Check for overflow. */`
`150`		`- if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )`
	`150`	`+ if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )`
`151`	`151`	`> xWantedSize )`
`152`	`152`	`{`
`153`	`153`	`xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );`
`@@ -156,21 +156,21 @@ void * pvPortMalloc( size_t xWantedSize )`
`156`	`156`	`else`
`157`	`157`	`{`
`158`	`158`	`xWantedSize = 0;`
`159`		`- }`
	`159`	`+ }`
`160`	`160`	`}`
`161`	`161`	`else`
`162`	`162`	`{`
`163`	`163`	`mtCOVERAGE_TEST_MARKER();`
`164`	`164`	`}`
`165`		`- }`
`166`		`- else`
	`165`	`+ }`
	`166`	`+ else`
`167`	`167`	`{`
`168`	`168`	`xWantedSize = 0;`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )`
`172`	`172`	`{`
`173`		`- /* Traverse the list from the start (lowest address) block until`
	`173`	`+ /* Traverse the list from the start (lowest address) block until`
`174`	`174`	`* one of adequate size is found. */`
`175`	`175`	`pxPreviousBlock = &xStart;`
`176`	`176`	`pxBlock = xStart.pxNextFreeBlock;`
Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,8 @@`
`45`	`45`	`*`
`46`	`46`	`* typedef struct HeapRegion`
`47`	`47`	`* {`
`48`		`- * uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.`
`49`		`- * size_t xSizeInBytes; << Size of the block of memory.`
	`48`	`+ * uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.`
	`49`	`+ * size_t xSizeInBytes; << Size of the block of memory.`
`50`	`50`	`* } HeapRegion_t;`
`51`	`51`	`*`
`52`	`52`	`* The array is terminated using a NULL zero sized region definition, and the`
`@@ -149,7 +149,7 @@ void * pvPortMalloc( size_t xWantedSize )`
`149`	`149`	`{`
`150`	`150`	`/* The wanted size is increased so it can contain a BlockLink_t`
`151`	`151`	`* structure in addition to the requested amount of bytes. */`
`152`		`- if( ( xWantedSize > 0 ) &&`
	`152`	`+ if( ( xWantedSize > 0 ) &&`
`153`	`153`	`( ( xWantedSize + xHeapStructSize ) > xWantedSize ) ) /* Overflow check */`
`154`	`154`	`{`
`155`	`155`	`xWantedSize += xHeapStructSize;`
`@@ -162,8 +162,8 @@ void * pvPortMalloc( size_t xWantedSize )`
`162`	`162`	`xWantedSize )`
`163`	`163`	`{`
`164`	`164`	`xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );`
`165`		`- }`
`166`		`- else`
	`165`	`+ }`
	`166`	`+ else`
`167`	`167`	`{`
`168`	`168`	`xWantedSize = 0;`
`169`	`169`	`}`
`@@ -180,7 +180,7 @@ void * pvPortMalloc( size_t xWantedSize )`
`180`	`180`
`181`	`181`	`if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )`
`182`	`182`	`{`
`183`		`- /* Traverse the list from the start (lowest address) block until`
	`183`	`+ /* Traverse the list from the start (lowest address) block until`
`184`	`184`	`* one of adequate size is found. */`
`185`	`185`	`pxPreviousBlock = &xStart;`
`186`	`186`	`pxBlock = xStart.pxNextFreeBlock;`
Original file line number	Diff line number	Diff line change
`@@ -523,7 +523,7 @@`
`523`	`523`	`{`
`524`	`524`	`/* Advance the expiry time. */`
`525`	`525`	`xExpiredTime += pxTimer->xTimerPeriodInTicks;`
`526`		`-`
	`526`	`+`
`527`	`527`	`/* Call the timer callback. */`
`528`	`528`	`traceTIMER_EXPIRED( pxTimer );`
`529`	`529`	`pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );`