Demo: Run uncrustify on quemu mps2 demo (#643)

8 files changed, 1002 insertions, 958 deletions

diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/FreeRTOSConfig.h b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/FreeRTOSConfig.h
index c4e7254a3..420e72462 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/FreeRTOSConfig.h
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/FreeRTOSConfig.h
@@ -24,97 +24,100 @@
  *
  */
 
-#ifndef FREERTOS_CONFIG_H

-#define FREERTOS_CONFIG_H

+#ifndef FREERTOS_CONFIG_H
+#define FREERTOS_CONFIG_H
 
 /*-----------------------------------------------------------
- * Application specific definitions.
- *
- * These definitions should be adjusted for your particular hardware and
- * application requirements.
- *
- * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
- * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
- *
- * See https://www.freertos.org/a00110.html
- *----------------------------------------------------------*/
+* Application specific definitions.
+*
+* These definitions should be adjusted for your particular hardware and
+* application requirements.
+*
+* THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
+* FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
+*
+* See https://www.freertos.org/a00110.html
+*----------------------------------------------------------*/
 
-#define configASSERT_DEFINED                     1
+#define configASSERT_DEFINED                             1
 extern void vAssertCalled( void );
-#define configASSERT( x ) if( ( x ) == 0 ) vAssertCalled( )
-#define configQUEUE_REGISTRY_SIZE                20
-
-#define configUSE_PREEMPTION                     1
-#define configUSE_TIME_SLICING                   0
-#define configUSE_PORT_OPTIMISED_TASK_SELECTION  0
-
-#define configUSE_IDLE_HOOK                      1
-#define configUSE_TICK_HOOK                      1
-#define configUSE_DAEMON_TASK_STARTUP_HOOK       0
-#define configCPU_CLOCK_HZ                       ( ( unsigned long ) 20000000 )
-#define configTICK_RATE_HZ                       ( ( TickType_t ) 1000 )
-#define configMINIMAL_STACK_SIZE                 ( ( unsigned short ) 2000 )
-#define configTOTAL_HEAP_SIZE                    ( ( size_t ) ( 900 ) )
-#define configMAX_TASK_NAME_LEN                  ( 10 )
-#define configUSE_TRACE_FACILITY                 1
-#define configUSE_16_BIT_TICKS                   0
-#define configIDLE_SHOULD_YIELD                  1
-#define configUSE_CO_ROUTINES                    0
-
-#define configMAX_PRIORITIES                     ( 10 )
-#define configMAX_CO_ROUTINE_PRIORITIES          ( 2 )
-#define configTIMER_QUEUE_LENGTH                 20
-#define configTIMER_TASK_PRIORITY                ( configMAX_PRIORITIES - 1 )
-#define configUSE_COUNTING_SEMAPHORES            1
-#define configSUPPORT_DYNAMIC_ALLOCATION         1
-#define configSUPPORT_STATIC_ALLOCATION          1
-#define  configNUM_TX_DESCRIPTORS                15
-#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN 2
-
-/* Set the following definitions to 1 to include the API function, or zero

-to exclude the API function. */

-
-#define configUSE_MALLOC_FAILED_HOOK            1
-#define configUSE_MUTEXES                       1
-#define configUSE_RECURSIVE_MUTEXES             1
-#define configUSE_TIMERS                        1
-#define configTIMER_TASK_STACK_DEPTH            ( configMINIMAL_STACK_SIZE * 2 )
-
-#define INCLUDE_vTaskPrioritySet                1
-#define INCLUDE_uxTaskPriorityGet               1
-#define INCLUDE_vTaskDelete                     1
-#define INCLUDE_vTaskCleanUpResources           0
-#define INCLUDE_vTaskSuspend                    1
-#define INCLUDE_vTaskDelayUntil                 1
-#define INCLUDE_vTaskDelay                      1
-#define INCLUDE_uxTaskGetStackHighWaterMark     1
-#define INCLUDE_uxTaskGetStackHighWaterMark2    1
-#define INCLUDE_xTaskGetSchedulerState          1
-#define INCLUDE_xTimerGetTimerDaemonTaskHandle  1
-#define INCLUDE_xTaskGetIdleTaskHandle          1
-#define INCLUDE_xTaskGetHandle                  1
-#define INCLUDE_eTaskGetState                   1
-#define INCLUDE_xSemaphoreGetMutexHolder        1
-#define INCLUDE_xTimerPendFunctionCall          1
-#define INCLUDE_xTaskAbortDelay                 1
+#define configASSERT( x )    if( ( x ) == 0 ) vAssertCalled()
+#define configQUEUE_REGISTRY_SIZE                        20
+
+#define configUSE_PREEMPTION                             1
+#define configUSE_TIME_SLICING                           0
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION          0
+
+#define configUSE_IDLE_HOOK                              1
+#define configUSE_TICK_HOOK                              1
+#define configUSE_DAEMON_TASK_STARTUP_HOOK               0
+#define configCPU_CLOCK_HZ                               ( ( unsigned long ) 20000000 )
+#define configTICK_RATE_HZ                               ( ( TickType_t ) 1000 )
+#define configMINIMAL_STACK_SIZE                         ( ( unsigned short ) 2000 )
+#define configTOTAL_HEAP_SIZE                            ( ( size_t ) ( 900 ) )
+#define configMAX_TASK_NAME_LEN                          ( 10 )
+#define configUSE_TRACE_FACILITY                         1
+#define configUSE_16_BIT_TICKS                           0
+#define configIDLE_SHOULD_YIELD                          1
+#define configUSE_CO_ROUTINES                            0
+
+#define configMAX_PRIORITIES                             ( 10 )
+#define configMAX_CO_ROUTINE_PRIORITIES                  ( 2 )
+#define configTIMER_QUEUE_LENGTH                         20
+#define configTIMER_TASK_PRIORITY                        ( configMAX_PRIORITIES - 1 )
+#define configUSE_COUNTING_SEMAPHORES                    1
+#define configSUPPORT_DYNAMIC_ALLOCATION                 1
+#define configSUPPORT_STATIC_ALLOCATION                  1
+#define  configNUM_TX_DESCRIPTORS                        15
+#define configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN    2
+
+/* Set the following definitions to 1 to include the API function, or zero
+ * to exclude the API function. */
+
+#define configUSE_MALLOC_FAILED_HOOK              1
+#define configUSE_MUTEXES                         1
+#define configUSE_RECURSIVE_MUTEXES               1
+#define configUSE_TIMERS                          1
+#define configTIMER_TASK_STACK_DEPTH              ( configMINIMAL_STACK_SIZE * 2 )
+
+#define INCLUDE_vTaskPrioritySet                  1
+#define INCLUDE_uxTaskPriorityGet                 1
+#define INCLUDE_vTaskDelete                       1
+#define INCLUDE_vTaskCleanUpResources             0
+#define INCLUDE_vTaskSuspend                      1
+#define INCLUDE_vTaskDelayUntil                   1
+#define INCLUDE_vTaskDelay                        1
+#define INCLUDE_uxTaskGetStackHighWaterMark       1
+#define INCLUDE_uxTaskGetStackHighWaterMark2      1
+#define INCLUDE_xTaskGetSchedulerState            1
+#define INCLUDE_xTimerGetTimerDaemonTaskHandle    1
+#define INCLUDE_xTaskGetIdleTaskHandle            1
+#define INCLUDE_xTaskGetHandle                    1
+#define INCLUDE_eTaskGetState                     1
+#define INCLUDE_xSemaphoreGetMutexHolder          1
+#define INCLUDE_xTimerPendFunctionCall            1
+#define INCLUDE_xTaskAbortDelay                   1
 
 unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */
 
-#define projCOVERAGE_TEST 0
+#define projCOVERAGE_TEST                       0
 
 #define configKERNEL_INTERRUPT_PRIORITY         255
+
 /* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!
-See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */
+ * See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */
 #define configMAX_SYSCALL_INTERRUPT_PRIORITY    191 /* equivalent to 0xa0, or priority 5. */
-#define configMAC_INTERRUPT_PRIORITY 5
+#define configMAC_INTERRUPT_PRIORITY            5
+
 /* Prototype for the function used to print out.  In this case it prints to the
-|     10 console before the network is connected then a UDP port after the network has
-|      9 connected. */
-extern void vLoggingPrintf( const char *pcFormatString, ... );
+ |     10 console before the network is connected then a UDP port after the network has
+ |      9 connected. */
+extern void vLoggingPrintf( const char * pcFormatString,
+                            ... );
 
 #ifdef HEAP3
-#define xPortGetMinimumEverFreeHeapSize (x)
-#define xPortGetFreeHeapSize (x)
+    #define xPortGetMinimumEverFreeHeapSize    ( x )
+    #define xPortGetFreeHeapSize               ( x )
 #endif
 
-#endif /* FREERTOS_CONFIG_H */

+#endif /* FREERTOS_CONFIG_H */
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.c
index dc7a8d3ef..633c8bcb0 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.c
@@ -25,8 +25,8 @@
  */
 
 /*-----------------------------------------------------------
- * Example console I/O wrappers.
- *----------------------------------------------------------*/
+* Example console I/O wrappers.
+*----------------------------------------------------------*/
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -37,22 +37,23 @@
 SemaphoreHandle_t xStdioMutex;
 StaticSemaphore_t xStdioMutexBuffer;
 
-void console_init(void)
+void console_init( void )
 {
-    xStdioMutex = xSemaphoreCreateMutexStatic(&xStdioMutexBuffer);
+    xStdioMutex = xSemaphoreCreateMutexStatic( &xStdioMutexBuffer );
 }
 
-void console_print(const char *fmt, ...)
+void console_print( const char * fmt,
+                    ... )
 {
     va_list vargs;
 
-    va_start(vargs, fmt);
-    
-    xSemaphoreTake(xStdioMutex, portMAX_DELAY);
+    va_start( vargs, fmt );
 
-    vprintf(fmt, vargs);
+    xSemaphoreTake( xStdioMutex, portMAX_DELAY );
 
-    xSemaphoreGive(xStdioMutex);
+    vprintf( fmt, vargs );
 
-    va_end(vargs);
+    xSemaphoreGive( xStdioMutex );
+
+    va_end( vargs );
 }
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.h b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.h
index 35223873b..19e9c50b5 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.h
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/console.h
@@ -26,20 +26,24 @@
 
 #ifndef CONSOLE_H
 #define CONSOLE_H
-
+/* *INDENT-OFF* */
 #ifdef __cplusplus
-extern "C" {
+    extern "C" {
 #endif
+/* *INDENT-ON* */
 
 /*-----------------------------------------------------------
- * Example console I/O wrappers.
- *----------------------------------------------------------*/
+* Example console I/O wrappers.
+*----------------------------------------------------------*/
 
-void console_init(void);
-void console_print(const char *fmt, ...);
+void console_init( void );
+void console_print( const char * fmt,
+                    ... );
 
+/* *INDENT-OFF* */
 #ifdef __cplusplus
-}
+    }
 #endif
+/* *INDENT-ON* */
 
 #endif /* CONSOLE_H */
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c
index b7fda0c74..4d6e2cff2 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c
@@ -37,48 +37,50 @@ extern void xPortSysTickHandler( void );
 extern void uart_init();
 extern int main();
 
-void __attribute__((weak)) EthernetISR (void);
+void __attribute__( ( weak ) ) EthernetISR( void );
 
 extern uint32_t _estack, _sidata, _sdata, _edata, _sbss, _ebss;
 
 /* Prevent optimization so gcc does not replace code with memcpy */
-__attribute__((optimize("O0")))
-__attribute__((naked))
-void Reset_Handler(void)
+__attribute__( ( optimize( "O0" ) ) )
+__attribute__( ( naked ) )
+void Reset_Handler( void )
 {
-    // set stack pointer
-    __asm volatile ("ldr r0, =_estack");
-    __asm volatile ("mov sp, r0");
-    // copy .data section from flash to RAM
-    for (uint32_t *src = &_sidata, *dest = &_sdata; dest < &_edata;)
+    /* set stack pointer */
+    __asm volatile ( "ldr r0, =_estack" );
+    __asm volatile ( "mov sp, r0" );
+
+    /* copy .data section from flash to RAM */
+    for( uint32_t * src = &_sidata, * dest = &_sdata; dest < &_edata; )
     {
         *dest++ = *src++;
     }
 
-    // zero out .bss section
-    for (uint32_t *dest = &_sbss; dest < &_ebss;)
+    /* zero out .bss section */
+    for( uint32_t * dest = &_sbss; dest < &_ebss; )
     {
         *dest++ = 0;
     }
-    // jump to board initialisation
-    void _start(void);
+
+    /* jump to board initialisation */
+    void _start( void );
     _start();
 }
 
-void prvGetRegistersFromStack( uint32_t *pulFaultStackAddress )
+void prvGetRegistersFromStack( uint32_t * pulFaultStackAddress )
 {
 /* These are volatile to try and prevent the compiler/linker optimising them
-away as the variables never actually get used.  If the debugger won't show the
-values of the variables, make them global my moving their declaration outside
-of this function. */
+ * away as the variables never actually get used.  If the debugger won't show the
+ * values of the variables, make them global my moving their declaration outside
+ * of this function. */
     volatile uint32_t r0;
     volatile uint32_t r1;
     volatile uint32_t r2;
     volatile uint32_t r3;
     volatile uint32_t r12;
-    volatile uint32_t lr; /* Link register. */
-    volatile uint32_t pc; /* Program counter. */
-    volatile uint32_t psr;/* Program status register. */
+    volatile uint32_t lr;  /* Link register. */
+    volatile uint32_t pc;  /* Program counter. */
+    volatile uint32_t psr; /* Program status register. */
 
     r0 = pulFaultStackAddress[ 0 ];
     r1 = pulFaultStackAddress[ 1 ];
@@ -91,11 +93,13 @@ of this function. */
     psr = pulFaultStackAddress[ 7 ];
 
     /* When the following line is hit, the variables contain the register values. */
-    for( ;; );
+    for( ; ; )
+    {
+    }
 }
 
 static void Default_Handler( void ) __attribute__( ( naked ) );
-void Default_Handler(void)
+void Default_Handler( void )
 {
     __asm volatile
     (
@@ -111,9 +115,8 @@ void Default_Handler(void)
     );
 }
 static void HardFault_Handler( void ) __attribute__( ( naked ) );
-void Default_Handler2(void)
+void Default_Handler2( void )
 {
-
     __asm volatile
     (
         " tst lr, #4                                                \n"
@@ -127,80 +130,86 @@ void Default_Handler2(void)
     );
 }
 
-void Default_Handler3(void)
+void Default_Handler3( void )
 {
-    for (;;) { }
+    for( ; ; )
+    {
+    }
 }
 
-void Default_Handler4(void)
+void Default_Handler4( void )
 {
-    for (;;) { }
+    for( ; ; )
+    {
+    }
 }
 
-void Default_Handler5(void)
+void Default_Handler5( void )
 {
-    for (;;) { }
+    for( ; ; )
+    {
+    }
 }
 
-void Default_Handler6(void)
+void Default_Handler6( void )
 {
-    for (;;) { }
+    for( ; ; )
+    {
+    }
 }
 
-const uint32_t* isr_vector[] __attribute__((section(".isr_vector"))) =
+const uint32_t * isr_vector[] __attribute__( ( section( ".isr_vector" ) ) ) =
 {
-    (uint32_t*)&_estack,
-    (uint32_t*)&Reset_Handler,    // Reset                -15
-    (uint32_t*)&Default_Handler,  // NMI_Handler          -14
-    (uint32_t*)&Default_Handler2, // HardFault_Handler    -13
-    (uint32_t*)&Default_Handler3, // MemManage_Handler    -12
-    (uint32_t*)&Default_Handler4, // BusFault_Handler     -11
-    (uint32_t*)&Default_Handler5, // UsageFault_Handler   -10
-    0, // reserved
-    0, // reserved
-    0, // reserved
-    0, // reserved   -6
-    (uint32_t*)&vPortSVCHandler,  // SVC_Handler              -5
-    (uint32_t*)&Default_Handler6, // DebugMon_Handler         -4
-    0, // reserved
-    (uint32_t*)&xPortPendSVHandler,      // PendSV handler    -2
-    (uint32_t*)&xPortSysTickHandler,     // SysTick_Handler   -1
-    0,                    // uart0 receive 0
-    0,                    // uart0 transmit
-    0,                    // uart1 receive
-    0,                    // uart1 transmit
-    0,                    // uart 2 receive
-    0,                    // uart 2 transmit
-    0,                    // GPIO 0 combined interrupt
-    0,                    // GPIO 2 combined interrupt
-    0,                    // Timer 0
-    0,                    // Timer 1
-    0,                    // Dial Timer
-    0,                    // SPI0 SPI1
-    0,                    // uart overflow 1, 2,3
-    0,                    // Ethernet   13
-
+    ( uint32_t * ) &_estack,
+    ( uint32_t * ) &Reset_Handler,       /* Reset                -15 */
+    ( uint32_t * ) &Default_Handler,     /* NMI_Handler          -14 */
+    ( uint32_t * ) &Default_Handler2,    /* HardFault_Handler    -13 */
+    ( uint32_t * ) &Default_Handler3,    /* MemManage_Handler    -12 */
+    ( uint32_t * ) &Default_Handler4,    /* BusFault_Handler     -11 */
+    ( uint32_t * ) &Default_Handler5,    /* UsageFault_Handler   -10 */
+    0,                                   /* reserved */
+    0,                                   /* reserved */
+    0,                                   /* reserved */
+    0,                                   /* reserved   -6 */
+    ( uint32_t * ) &vPortSVCHandler,     /* SVC_Handler              -5 */
+    ( uint32_t * ) &Default_Handler6,    /* DebugMon_Handler         -4 */
+    0,                                   /* reserved */
+    ( uint32_t * ) &xPortPendSVHandler,  /* PendSV handler    -2 */
+    ( uint32_t * ) &xPortSysTickHandler, /* SysTick_Handler   -1 */
+    0,                                   /* uart0 receive 0 */
+    0,                                   /* uart0 transmit */
+    0,                                   /* uart1 receive */
+    0,                                   /* uart1 transmit */
+    0,                                   /* uart 2 receive */
+    0,                                   /* uart 2 transmit */
+    0,                                   /* GPIO 0 combined interrupt */
+    0,                                   /* GPIO 2 combined interrupt */
+    0,                                   /* Timer 0 */
+    0,                                   /* Timer 1 */
+    0,                                   /* Dial Timer */
+    0,                                   /* SPI0 SPI1 */
+    0,                                   /* uart overflow 1, 2,3 */
+    0,                                   /* Ethernet   13 */
 };
 
-void _start(void)
+void _start( void )
 {
     uart_init();
-    main(0, 0);
-    exit(0);
+    main( 0, 0 );
+    exit( 0 );
 }
 
-__attribute__((naked)) void exit(int status)
+__attribute__( ( naked ) ) void exit( int status )
 {
-    // Force qemu to exit using ARM Semihosting
+    /* Force qemu to exit using ARM Semihosting */
     __asm volatile (
         "mov r1, r0\n"
         "cmp r1, #0\n"
         "bne .notclean\n"
-        "ldr r1, =0x20026\n" // ADP_Stopped_ApplicationExit, a clean exit
+        "ldr r1, =0x20026\n" /* ADP_Stopped_ApplicationExit, a clean exit */
         ".notclean:\n"
-        "movs r0, #0x18\n" // SYS_EXIT
+        "movs r0, #0x18\n"   /* SYS_EXIT */
         "bkpt 0xab\n"
         "end: b end\n"
         );
 }
-
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main.c
index e2686bed6..18ef9c293 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main.c
@@ -27,46 +27,47 @@
 #include <FreeRTOS.h>
 #include <task.h>
 
-#include<FreeRTOSConfig.h>
+#include <FreeRTOSConfig.h>
 
 #include <string.h>
 #include <stdarg.h>
 #include <stdio.h>
 
-void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName );
+void vApplicationStackOverflowHook( TaskHandle_t pxTask,
+                                    char * pcTaskName );
 void vApplicationMallocFailedHook( void );
 void vApplicationIdleHook( void );
 void vApplicationTickHook( void );
 void vFullDemoIdleFunction( void );
 void vFullDemoTickHookFunction( void );
-void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
-                                     StackType_t **ppxTimerTaskStackBuffer,
-                                     uint32_t *pulTimerTaskStackSize );
-void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
-                                    StackType_t **ppxIdleTaskStackBuffer,
-                                    uint32_t *pulIdleTaskStackSize );
+void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
+                                     StackType_t ** ppxTimerTaskStackBuffer,
+                                     uint32_t * pulTimerTaskStackSize );
+void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                    StackType_t ** ppxIdleTaskStackBuffer,
+                                    uint32_t * pulIdleTaskStackSize );
 void main_blinky( void );
 void main_full( void );
 
-extern void initialise_monitor_handles(void);
+extern void initialise_monitor_handles( void );
 
 StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
 
-int main ()
+int main()
 {
-#if (mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1)
-    {
-    main_blinky();
-    }
-#elif (mainCREATE_FULL_DEMO_ONLY == 1)
-    {
-    main_full();
-    }
-#else
-    {
-    #error "Invalid Selection...\nPlease Select a Demo application from the main command"
-    }
-#endif
+    #if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 )
+        {
+            main_blinky();
+        }
+    #elif ( mainCREATE_FULL_DEMO_ONLY == 1 )
+        {
+            main_full();
+        }
+    #else
+        {
+            #error "Invalid Selection...\nPlease Select a Demo application from the main command"
+        }
+    #endif /* if ( mainCREATE_SIMPLE_BLINKY_DEMO_ONLY == 1 ) */
     return 0;
 }
 
@@ -75,66 +76,74 @@ int main ()
 void vApplicationMallocFailedHook( void )
 {
     /* Called if a call to pvPortMalloc() fails because there is insufficient
-    free memory available in the FreeRTOS heap.  pvPortMalloc() is called
-    internally by FreeRTOS API functions that create tasks, queues, software
-    timers, and semaphores.  The size of the FreeRTOS heap is set by the
-    configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
+     * free memory available in the FreeRTOS heap.  pvPortMalloc() is called
+     * internally by FreeRTOS API functions that create tasks, queues, software
+     * timers, and semaphores.  The size of the FreeRTOS heap is set by the
+     * configTOTAL_HEAP_SIZE configuration constant in FreeRTOSConfig.h. */
     taskDISABLE_INTERRUPTS();
-    for( ;; ){};
+
+    for( ; ; )
+    {
+    }
 }
 /*-----------------------------------------------------------*/
 
-void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
+void vApplicationStackOverflowHook( TaskHandle_t pxTask,
+                                    char * pcTaskName )
 {
     ( void ) pcTaskName;
     ( void ) pxTask;
 
     /* Run time stack overflow checking is performed if
-    configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
-    function is called if a stack overflow is detected. */
+     * configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
+     * function is called if a stack overflow is detected. */
     taskDISABLE_INTERRUPTS();
-    for( ;; ){};
+
+    for( ; ; )
+    {
+    }
 }
 /*-----------------------------------------------------------*/
 
 void vApplicationIdleHook( void )
 {
-volatile size_t xFreeHeapSpace;
+    volatile size_t xFreeHeapSpace;
 
     /* This is just a trivial example of an idle hook.  It is called on each
-    cycle of the idle task.  It must *NOT* attempt to block.  In this case the
-    idle task just queries the amount of FreeRTOS heap that remains.  See the
-    memory management section on the https://www.FreeRTOS.org web site for memory
-    management options.  If there is a lot of heap memory free then the
-    configTOTAL_HEAP_SIZE value in FreeRTOSConfig.h can be reduced to free up
-    RAM. */
-#if (mainCREATE_FULL_DEMO_ONLY == 1)
-   {
-    /* Call the idle task processing used by the full demo.  The simple
-     blinky demo does not use the idle task hook. */
-    vFullDemoIdleFunction();
-    }
-#endif
+     * cycle of the idle task.  It must *NOT* attempt to block.  In this case the
+     * idle task just queries the amount of FreeRTOS heap that remains.  See the
+     * memory management section on the https://www.FreeRTOS.org web site for memory
+     * management options.  If there is a lot of heap memory free then the
+     * configTOTAL_HEAP_SIZE value in FreeRTOSConfig.h can be reduced to free up
+     * RAM. */
+    #if ( mainCREATE_FULL_DEMO_ONLY == 1 )
+        {
+            /* Call the idle task processing used by the full demo.  The simple
+             * blinky demo does not use the idle task hook. */
+            vFullDemoIdleFunction();
+        }
+    #endif
 }
 /*-----------------------------------------------------------*/
 
 void vApplicationTickHook( void )
 {
-#if (mainCREATE_FULL_DEMO_ONLY == 1)
-{
-    vFullDemoTickHookFunction();
-}
-#endif /* mainSELECTED_APPLICATION */
+    #if ( mainCREATE_FULL_DEMO_ONLY == 1 )
+        {
+            vFullDemoTickHookFunction();
+        }
+    #endif /* mainSELECTED_APPLICATION */
 }
 /*-----------------------------------------------------------*/
 
 void vAssertCalled( void )
 {
     volatile unsigned long looping = 0;
+
     taskENTER_CRITICAL();
     {
         /* Use the debugger to set ul to a non-zero value in order to step out
-                of this function to determine why it was called. */
+         *      of this function to determine why it was called. */
         while( looping == 0LU )
         {
             portNOP();
@@ -143,60 +152,62 @@ void vAssertCalled( void )
     taskEXIT_CRITICAL();
 }
 /*-----------------------------------------------------------*/
-void vLoggingPrintf( const char *pcFormat, ... )
+void vLoggingPrintf( const char * pcFormat,
+                     ... )
 {
-        va_list arg;
+    va_list arg;
 
-        va_start( arg, pcFormat );
-        vprintf( pcFormat, arg );
-        va_end( arg );
+    va_start( arg, pcFormat );
+    vprintf( pcFormat, arg );
+    va_end( arg );
 }
+
 /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an
-implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
-used by the Idle task. */
-void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
-                                    StackType_t **ppxIdleTaskStackBuffer,
-                                    uint32_t *pulIdleTaskStackSize )
+ * implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
+ * used by the Idle task. */
+void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                    StackType_t ** ppxIdleTaskStackBuffer,
+                                    uint32_t * pulIdleTaskStackSize )
 {
 /* If the buffers to be provided to the Idle task are declared inside this
-function then they must be declared static - otherwise they will be allocated on
-the stack and so not exists after this function exits. */
+ * function then they must be declared static - otherwise they will be allocated on
+ * the stack and so not exists after this function exits. */
     static StaticTask_t xIdleTaskTCB;
     static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
 
     /* Pass out a pointer to the StaticTask_t structure in which the Idle task's
-    state will be stored. */
+     * state will be stored. */
     *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
 
     /* Pass out the array that will be used as the Idle task's stack. */
     *ppxIdleTaskStackBuffer = uxIdleTaskStack;
 
     /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
-    Note that, as the array is necessarily of type StackType_t,
-    configMINIMAL_STACK_SIZE is specified in words, not bytes. */
+     * Note that, as the array is necessarily of type StackType_t,
+     * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
     *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
 }
 /*-----------------------------------------------------------*/
 
 /*-----------------------------------------------------------*/
-void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
-                                     StackType_t **ppxTimerTaskStackBuffer,
-                                     uint32_t *pulTimerTaskStackSize )
+void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
+                                     StackType_t ** ppxTimerTaskStackBuffer,
+                                     uint32_t * pulTimerTaskStackSize )
 {
     /* If the buffers to be provided to the Timer task are declared inside this
-    function then they must be declared static - otherwise they will be allocated on
-    the stack and so not exists after this function exits. */
+     * function then they must be declared static - otherwise they will be allocated on
+     * the stack and so not exists after this function exits. */
     static StaticTask_t xTimerTaskTCB;
 
     /* Pass out a pointer to the StaticTask_t structure in which the Timer
-    task's state will be stored. */
+     * task's state will be stored. */
     *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
 
     /* Pass out the array that will be used as the Timer task's stack. */
     *ppxTimerTaskStackBuffer = uxTimerTaskStack;
 
-     /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
-     Note that, as the array is necessarily of type StackType_t,
-     configMINIMAL_STACK_SIZE is specified in words, not bytes. */
+    /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
+     * Note that, as the array is necessarily of type StackType_t,
+     * configMINIMAL_STACK_SIZE is specified in words, not bytes. */
     *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
 }
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_blinky.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_blinky.c
index 400b200fb..cb460f098 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_blinky.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_blinky.c
@@ -29,13 +29,13 @@
 #include <queue.h>
 #include <stdio.h>
 
-static void prvQueueReceiveTask( void *pvParameters );
-static void prvQueueSendTask( void *pvParameters );
+static void prvQueueReceiveTask( void * pvParameters );
+static void prvQueueSendTask( void * pvParameters );
 
-#define mainQUEUE_RECEIVE_TASK_PRIORITY     ( tskIDLE_PRIORITY + 2 )
-#define mainQUEUE_SEND_TASK_PRIORITY        ( tskIDLE_PRIORITY + 1 )
-#define mainQUEUE_LENGTH                    ( 1 )
-#define mainQUEUE_SEND_FREQUENCY_MS         ( 200 / portTICK_PERIOD_MS )
+#define mainQUEUE_RECEIVE_TASK_PRIORITY    ( tskIDLE_PRIORITY + 2 )
+#define mainQUEUE_SEND_TASK_PRIORITY       ( tskIDLE_PRIORITY + 1 )
+#define mainQUEUE_LENGTH                   ( 1 )
+#define mainQUEUE_SEND_FREQUENCY_MS        ( 200 / portTICK_PERIOD_MS )
 /* The queue used by both tasks. */
 static QueueHandle_t xQueue = NULL;
 
@@ -47,38 +47,40 @@ void main_blinky( void )
     if( xQueue != NULL )
     {
         /* Start the two tasks as described in the comments at the top of this
-        file. */
-        xTaskCreate( prvQueueReceiveTask,            /* The function that implements the task. */
-                    "Rx",                            /* The text name assigned to the task - for debug only as it is not used by the kernel. */
-                    configMINIMAL_STACK_SIZE,        /* The size of the stack to allocate to the task. */
-                    NULL,                            /* The parameter passed to the task - not used in this case. */
-                    mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */
-                    NULL );                          /* The task handle is not required, so NULL is passed. */
+         * file. */
+        xTaskCreate( prvQueueReceiveTask,             /* The function that implements the task. */
+                     "Rx",                            /* The text name assigned to the task - for debug only as it is not used by the kernel. */
+                     configMINIMAL_STACK_SIZE,        /* The size of the stack to allocate to the task. */
+                     NULL,                            /* The parameter passed to the task - not used in this case. */
+                     mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */
+                     NULL );                          /* The task handle is not required, so NULL is passed. */
 
         xTaskCreate( prvQueueSendTask,
-                    "TX",
-                    configMINIMAL_STACK_SIZE,
-                    NULL,
-                    mainQUEUE_SEND_TASK_PRIORITY,
-                    NULL );
+                     "TX",
+                     configMINIMAL_STACK_SIZE,
+                     NULL,
+                     mainQUEUE_SEND_TASK_PRIORITY,
+                     NULL );
 
         /* Start the tasks and timer running. */
         vTaskStartScheduler();
     }
 
     /* If all is well, the scheduler will now be running, and the following
-    line will never be reached.  If the following line does execute, then
-    there was insufficient FreeRTOS heap memory available for the Idle and/or
-    timer tasks to be created.  See the memory management section on the
-    FreeRTOS web site for more details on the FreeRTOS heap
-    http://www.freertos.org/a00111.html. */
-    for( ;; );
+     * line will never be reached.  If the following line does execute, then
+     * there was insufficient FreeRTOS heap memory available for the Idle and/or
+     * timer tasks to be created.  See the memory management section on the
+     * FreeRTOS web site for more details on the FreeRTOS heap
+     * http://www.freertos.org/a00111.html. */
+    for( ; ; )
+    {
+    }
 }
 
-static void prvQueueSendTask( void *pvParameters )
+static void prvQueueSendTask( void * pvParameters )
 {
-TickType_t xNextWakeTime;
-const uint32_t ulValueToSend = 100UL;
+    TickType_t xNextWakeTime;
+    const uint32_t ulValueToSend = 100UL;
 
     /* Remove compiler warning about unused parameter. */
     ( void ) pvParameters;
@@ -86,41 +88,41 @@ const uint32_t ulValueToSend = 100UL;
     /* Initialise xNextWakeTime - this only needs to be done once. */
     xNextWakeTime = xTaskGetTickCount();
 
-    for( ;; )
+    for( ; ; )
     {
         /* Place this task in the blocked state until it is time to run again. */
         vTaskDelayUntil( &xNextWakeTime, mainQUEUE_SEND_FREQUENCY_MS );
 
         /* Send to the queue - causing the queue receive task to unblock and
-        toggle the LED.  0 is used as the block time so the sending operation
-        will not block - it shouldn't need to block as the queue should always
-        be empty at this point in the code. */
+         * toggle the LED.  0 is used as the block time so the sending operation
+         * will not block - it shouldn't need to block as the queue should always
+         * be empty at this point in the code. */
         xQueueSend( xQueue, &ulValueToSend, 0U );
     }
 }
 
 volatile uint32_t ulRxEvents = 0;
-static void prvQueueReceiveTask( void *pvParameters )
+static void prvQueueReceiveTask( void * pvParameters )
 {
-uint32_t ulReceivedValue;
-const uint32_t ulExpectedValue = 100UL;
+    uint32_t ulReceivedValue;
+    const uint32_t ulExpectedValue = 100UL;
 
     /* Remove compiler warning about unused parameter. */
     ( void ) pvParameters;
 
-    for( ;; )
+    for( ; ; )
     {
         /* Wait until something arrives in the queue - this task will block
-        indefinitely provided INCLUDE_vTaskSuspend is set to 1 in
-        FreeRTOSConfig.h. */
+         * indefinitely provided INCLUDE_vTaskSuspend is set to 1 in
+         * FreeRTOSConfig.h. */
         xQueueReceive( xQueue, &ulReceivedValue, portMAX_DELAY );
 
         /*  To get here something must have been received from the queue, but
-        is it the expected value?  If it is, toggle the LED. */
+         * is it the expected value?  If it is, toggle the LED. */
         if( ulReceivedValue == ulExpectedValue )
         {
-            printf("%s\n","blinking");
-            vTaskDelay(1000);
+            printf( "%s\n", "blinking" );
+            vTaskDelay( 1000 );
             ulReceivedValue = 0U;
             ulRxEvents++;
         }
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_full.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_full.c
index 46fb47a92..f786e76bb 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_full.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_full.c
@@ -109,18 +109,18 @@
 #include "console.h"
 
 /* Priorities at which the tasks are created. */
-#define mainCHECK_TASK_PRIORITY			( configMAX_PRIORITIES - 2 )
-#define mainQUEUE_POLL_PRIORITY			( tskIDLE_PRIORITY + 1 )
-#define mainSEM_TEST_PRIORITY			( tskIDLE_PRIORITY + 1 )
-#define mainBLOCK_Q_PRIORITY			( tskIDLE_PRIORITY + 2 )
-#define mainCREATOR_TASK_PRIORITY		( tskIDLE_PRIORITY + 3 )
-#define mainFLASH_TASK_PRIORITY			( tskIDLE_PRIORITY + 1 )
-#define mainINTEGER_TASK_PRIORITY		( tskIDLE_PRIORITY )
-#define mainGEN_QUEUE_TASK_PRIORITY		( tskIDLE_PRIORITY )
-#define mainFLOP_TASK_PRIORITY			( tskIDLE_PRIORITY )
-#define mainQUEUE_OVERWRITE_PRIORITY	( tskIDLE_PRIORITY )
-
-#define mainTIMER_TEST_PERIOD			( 50 )
+#define mainCHECK_TASK_PRIORITY         ( configMAX_PRIORITIES - 2 )
+#define mainQUEUE_POLL_PRIORITY         ( tskIDLE_PRIORITY + 1 )
+#define mainSEM_TEST_PRIORITY           ( tskIDLE_PRIORITY + 1 )
+#define mainBLOCK_Q_PRIORITY            ( tskIDLE_PRIORITY + 2 )
+#define mainCREATOR_TASK_PRIORITY       ( tskIDLE_PRIORITY + 3 )
+#define mainFLASH_TASK_PRIORITY         ( tskIDLE_PRIORITY + 1 )
+#define mainINTEGER_TASK_PRIORITY       ( tskIDLE_PRIORITY )
+#define mainGEN_QUEUE_TASK_PRIORITY     ( tskIDLE_PRIORITY )
+#define mainFLOP_TASK_PRIORITY          ( tskIDLE_PRIORITY )
+#define mainQUEUE_OVERWRITE_PRIORITY    ( tskIDLE_PRIORITY )
+
+#define mainTIMER_TEST_PERIOD           ( 50 )
 
 /*
  * Exercises code that is not otherwise covered by the standard demo/test
@@ -129,11 +129,11 @@
 extern BaseType_t xRunCodeCoverageTestAdditions( void );
 
 /* Task function prototypes. */
-static void prvCheckTask( void *pvParameters );
+static void prvCheckTask( void * pvParameters );
 
 /* A task that is created from the idle task to test the functionality of
-eTaskStateGet(). */
-static void prvTestTask( void *pvParameters );
+ * eTaskStateGet(). */
+static void prvTestTask( void * pvParameters );
 
 /*
  * Called from the idle task hook function to demonstrate a few utility
@@ -151,7 +151,8 @@ static void prvDemonstratePendingFunctionCall( void );
 /*
  * The function that is pended by prvDemonstratePendingFunctionCall().
  */
-static void prvPendedFunction( void *pvParameter1, uint32_t ulParameter2 );
+static void prvPendedFunction( void * pvParameter1,
+                               uint32_t ulParameter2 );
 
 /*
  * prvDemonstrateTimerQueryFunctions() is called from the idle task hook
@@ -165,741 +166,747 @@ static void prvTestTimerCallback( TimerHandle_t xTimer );
 /*
  * A task to demonstrate the use of the xQueueSpacesAvailable() function.
  */
-static void prvDemoQueueSpaceFunctions( void *pvParameters );
+static void prvDemoQueueSpaceFunctions( void * pvParameters );
 
 /*
  * Tasks that ensure indefinite delays are truly indefinite.
  */
-static void prvPermanentlyBlockingSemaphoreTask( void *pvParameters );
-static void prvPermanentlyBlockingNotificationTask( void *pvParameters );
+static void prvPermanentlyBlockingSemaphoreTask( void * pvParameters );
+static void prvPermanentlyBlockingNotificationTask( void * pvParameters );
 
 /*
  * The test function and callback function used when exercising the timer AP
  * function that changes the timer's auto-reload mode.
  */
-static void prvDemonstrateChangingTimerReloadMode( void *pvParameters );
+static void prvDemonstrateChangingTimerReloadMode( void * pvParameters );
 static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer );
 
 /*-----------------------------------------------------------*/
 
 /* The variable into which error messages are latched. */
-static char *pcStatusMessage = "OK: No errors";
+static char * pcStatusMessage = "OK: No errors";
 
 /* This semaphore is created purely to test using the vSemaphoreDelete() and
-semaphore tracing API functions.  It has no other purpose. */
+ * semaphore tracing API functions.  It has no other purpose. */
 static SemaphoreHandle_t xMutexToDelete = NULL;
 
 /*-----------------------------------------------------------*/
 
 int main_full( void )
 {
-	/* Start the check task as described at the top of this file. */
-	xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
-
-	/* Create the standard demo tasks. */
-	vStartTaskNotifyTask();
-	// vStartTaskNotifyArrayTask();
-	vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
-	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
-	vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
-	vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
-	vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
-	vStartQueuePeekTasks();
-	vStartMathTasks( mainFLOP_TASK_PRIORITY );
-	vStartRecursiveMutexTasks();
-	vStartCountingSemaphoreTasks();
-	vStartDynamicPriorityTasks();
-	vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );
-	vStartEventGroupTasks();
-	vStartInterruptSemaphoreTasks();
-	vCreateBlockTimeTasks();
-	vCreateAbortDelayTasks();
-	xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-	xTaskCreate( prvPermanentlyBlockingSemaphoreTask, "BlockSem", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-	xTaskCreate( prvPermanentlyBlockingNotificationTask, "BlockNoti", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-
-	vStartMessageBufferTasks( configMINIMAL_STACK_SIZE );
-	vStartStreamBufferTasks();
-	vStartStreamBufferInterruptDemo();
-	vStartMessageBufferAMPTasks( configMINIMAL_STACK_SIZE );
-
-	#if( configUSE_QUEUE_SETS == 1 )
-	{
-		vStartQueueSetTasks();
-		vStartQueueSetPollingTask();
-	}
-	#endif
-
-	#if( configSUPPORT_STATIC_ALLOCATION == 1 )
-	{
-		vStartStaticallyAllocatedTasks();
-	}
-	#endif
-
-	#if( configUSE_PREEMPTION != 0  )
-	{
-		/* Don't expect these tasks to pass when preemption is not used. */
-		vStartTimerDemoTask( mainTIMER_TEST_PERIOD );
-	}
-	#endif
-
-	/* The suicide tasks must be created last as they need to know how many
-	tasks were running prior to their creation.  This then allows them to
-	ascertain whether or not the correct/expected number of tasks are running at
-	any given time. */
-	vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );
-
-	/* Create the semaphore that will be deleted in the idle task hook.  This
-	is done purely to test the use of vSemaphoreDelete(). */
-	xMutexToDelete = xSemaphoreCreateMutex();
-
-	/* Start the scheduler itself. */
-	vTaskStartScheduler();
-
-	/* Should never get here unless there was not enough heap space to create
-	the idle and other system tasks. */
-	return 0;
+    /* Start the check task as described at the top of this file. */
+    xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
+
+    /* Create the standard demo tasks. */
+    vStartTaskNotifyTask();
+    /* vStartTaskNotifyArrayTask(); */
+    vStartBlockingQueueTasks( mainBLOCK_Q_PRIORITY );
+    vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
+    vStartPolledQueueTasks( mainQUEUE_POLL_PRIORITY );
+    vStartIntegerMathTasks( mainINTEGER_TASK_PRIORITY );
+    vStartGenericQueueTasks( mainGEN_QUEUE_TASK_PRIORITY );
+    vStartQueuePeekTasks();
+    vStartMathTasks( mainFLOP_TASK_PRIORITY );
+    vStartRecursiveMutexTasks();
+    vStartCountingSemaphoreTasks();
+    vStartDynamicPriorityTasks();
+    vStartQueueOverwriteTask( mainQUEUE_OVERWRITE_PRIORITY );
+    vStartEventGroupTasks();
+    vStartInterruptSemaphoreTasks();
+    vCreateBlockTimeTasks();
+    vCreateAbortDelayTasks();
+    xTaskCreate( prvDemoQueueSpaceFunctions, "QSpace", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
+    xTaskCreate( prvPermanentlyBlockingSemaphoreTask, "BlockSem", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
+    xTaskCreate( prvPermanentlyBlockingNotificationTask, "BlockNoti", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
+
+    vStartMessageBufferTasks( configMINIMAL_STACK_SIZE );
+    vStartStreamBufferTasks();
+    vStartStreamBufferInterruptDemo();
+    vStartMessageBufferAMPTasks( configMINIMAL_STACK_SIZE );
+
+    #if ( configUSE_QUEUE_SETS == 1 )
+        {
+            vStartQueueSetTasks();
+            vStartQueueSetPollingTask();
+        }
+    #endif
+
+    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+        {
+            vStartStaticallyAllocatedTasks();
+        }
+    #endif
+
+    #if ( configUSE_PREEMPTION != 0 )
+        {
+            /* Don't expect these tasks to pass when preemption is not used. */
+            vStartTimerDemoTask( mainTIMER_TEST_PERIOD );
+        }
+    #endif
+
+    /* The suicide tasks must be created last as they need to know how many
+     * tasks were running prior to their creation.  This then allows them to
+     * ascertain whether or not the correct/expected number of tasks are running at
+     * any given time. */
+    vCreateSuicidalTasks( mainCREATOR_TASK_PRIORITY );
+
+    /* Create the semaphore that will be deleted in the idle task hook.  This
+     * is done purely to test the use of vSemaphoreDelete(). */
+    xMutexToDelete = xSemaphoreCreateMutex();
+
+    /* Start the scheduler itself. */
+    vTaskStartScheduler();
+
+    /* Should never get here unless there was not enough heap space to create
+     * the idle and other system tasks. */
+    return 0;
 }
 /*-----------------------------------------------------------*/
 
-static void prvCheckTask( void *pvParameters )
+static void prvCheckTask( void * pvParameters )
 {
-TickType_t xNextWakeTime;
-const TickType_t xCycleFrequency = pdMS_TO_TICKS( 10000UL );
-HeapStats_t xHeapStats;
-
-	/* Just to remove compiler warning. */
-	( void ) pvParameters;
-
-	/* Initialise xNextWakeTime - this only needs to be done once. */
-	xNextWakeTime = xTaskGetTickCount();
-
-	for( ;; )
-	{
-		/* Place this task in the blocked state until it is time to run again. */
-		vTaskDelayUntil( &xNextWakeTime, xCycleFrequency );
-
-		/* Check the standard demo tasks are running without error. */
-		#if( configUSE_PREEMPTION != 0 )
-		{
-			/* These tasks are only created when preemption is used. */
-			if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE )
-			{
-				pcStatusMessage = "Error: TimerDemo";
-			}
-		}
-		#endif
-
-		if( xAreStreamBufferTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error:  StreamBuffer";
-		}
-		else if( xAreMessageBufferTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error:  MessageBuffer";
-		}
-		else if( xAreTaskNotificationTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error:  Notification";
-		}
-		// else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE )
-		// {
-		// 	pcStatusMessage = "Error:  NotificationArray";
-		// }
-		else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: IntSem";
-		}
-		else if( xAreEventGroupTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: EventGroup";
-		}
-		else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: IntMath";
-		}
-		else if( xAreGenericQueueTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: GenQueue";
-		}
-		else if( xAreQueuePeekTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: QueuePeek";
-		}
-		else if( xAreBlockingQueuesStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: BlockQueue";
-		}
-		else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: SemTest";
-		}
-		else if( xArePollingQueuesStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: PollQueue";
-		}
-		else if( xAreMathsTaskStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Flop";
-		}
-		else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: RecMutex";
-		}
-		else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: CountSem";
-		}
-		else if( xIsCreateTaskStillRunning() != pdTRUE )
-		{
-			pcStatusMessage = "Error: Death";
-		}
-		else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Dynamic";
-		}
-		else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Queue overwrite";
-		}
-		else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Block time";
-		}
-		else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Abort delay";
-		}
-		else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Stream buffer interrupt";
-		}
-		else if( xAreMessageBufferAMPTasksStillRunning() != pdPASS )
-		{
-			pcStatusMessage = "Error: Message buffer AMP";
-		}
-
-		#if( configUSE_QUEUE_SETS == 1 )
-			else if( xAreQueueSetTasksStillRunning() != pdPASS )
-			{
-				pcStatusMessage = "Error: Queue set";
-			}
-			else if( xAreQueueSetPollTasksStillRunning() != pdPASS )
-			{
-				pcStatusMessage = "Error: Queue set polling";
-			}
-		#endif
-
-		#if( configSUPPORT_STATIC_ALLOCATION == 1 )
-			else if( xAreStaticAllocationTasksStillRunning() != pdPASS )
-			{
-				pcStatusMessage = "Error: Static allocation";
-			}
-		#endif /* configSUPPORT_STATIC_ALLOCATION */
-
-		printf( "%s - tick count %u \r\n",
-					pcStatusMessage,
-					xTaskGetTickCount() );
-
-		// Reset the error condition
-		pcStatusMessage = "OK: No errors";
-	}
+    TickType_t xNextWakeTime;
+    const TickType_t xCycleFrequency = pdMS_TO_TICKS( 10000UL );
+    HeapStats_t xHeapStats;
+
+    /* Just to remove compiler warning. */
+    ( void ) pvParameters;
+
+    /* Initialise xNextWakeTime - this only needs to be done once. */
+    xNextWakeTime = xTaskGetTickCount();
+
+    for( ; ; )
+    {
+        /* Place this task in the blocked state until it is time to run again. */
+        vTaskDelayUntil( &xNextWakeTime, xCycleFrequency );
+
+        /* Check the standard demo tasks are running without error. */
+        #if ( configUSE_PREEMPTION != 0 )
+            {
+                /* These tasks are only created when preemption is used. */
+                if( xAreTimerDemoTasksStillRunning( xCycleFrequency ) != pdTRUE )
+                {
+                    pcStatusMessage = "Error: TimerDemo";
+                }
+            }
+        #endif
+
+        if( xAreStreamBufferTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error:  StreamBuffer";
+        }
+        else if( xAreMessageBufferTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error:  MessageBuffer";
+        }
+        else if( xAreTaskNotificationTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error:  Notification";
+        }
+        /* else if( xAreTaskNotificationArrayTasksStillRunning() != pdTRUE ) */
+        /* { */
+        /*  pcStatusMessage = "Error:  NotificationArray"; */
+        /* } */
+        else if( xAreInterruptSemaphoreTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: IntSem";
+        }
+        else if( xAreEventGroupTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: EventGroup";
+        }
+        else if( xAreIntegerMathsTaskStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: IntMath";
+        }
+        else if( xAreGenericQueueTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: GenQueue";
+        }
+        else if( xAreQueuePeekTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: QueuePeek";
+        }
+        else if( xAreBlockingQueuesStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: BlockQueue";
+        }
+        else if( xAreSemaphoreTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: SemTest";
+        }
+        else if( xArePollingQueuesStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: PollQueue";
+        }
+        else if( xAreMathsTaskStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Flop";
+        }
+        else if( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: RecMutex";
+        }
+        else if( xAreCountingSemaphoreTasksStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: CountSem";
+        }
+        else if( xIsCreateTaskStillRunning() != pdTRUE )
+        {
+            pcStatusMessage = "Error: Death";
+        }
+        else if( xAreDynamicPriorityTasksStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Dynamic";
+        }
+        else if( xIsQueueOverwriteTaskStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Queue overwrite";
+        }
+        else if( xAreBlockTimeTestTasksStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Block time";
+        }
+        else if( xAreAbortDelayTestTasksStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Abort delay";
+        }
+        else if( xIsInterruptStreamBufferDemoStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Stream buffer interrupt";
+        }
+        else if( xAreMessageBufferAMPTasksStillRunning() != pdPASS )
+        {
+            pcStatusMessage = "Error: Message buffer AMP";
+        }
+
+        #if ( configUSE_QUEUE_SETS == 1 )
+            else if( xAreQueueSetTasksStillRunning() != pdPASS )
+            {
+                pcStatusMessage = "Error: Queue set";
+            }
+            else if( xAreQueueSetPollTasksStillRunning() != pdPASS )
+            {
+                pcStatusMessage = "Error: Queue set polling";
+            }
+        #endif
+
+        #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+            else if( xAreStaticAllocationTasksStillRunning() != pdPASS )
+            {
+                pcStatusMessage = "Error: Static allocation";
+            }
+        #endif /* configSUPPORT_STATIC_ALLOCATION */
+
+        printf( "%s - tick count %u \r\n",
+                pcStatusMessage,
+                xTaskGetTickCount() );
+
+        /* Reset the error condition */
+        pcStatusMessage = "OK: No errors";
+    }
 }
 /*-----------------------------------------------------------*/
 
-static void prvTestTask( void *pvParameters )
+static void prvTestTask( void * pvParameters )
 {
-const unsigned long ulMSToSleep = 5;
-
-	/* Just to remove compiler warnings. */
-	( void ) pvParameters;
-
-	/* This task is just used to test the eTaskStateGet() function.  It
-	does not have anything to do. */
-	for( ;; )
-	{
-		/* Sleep to reduce CPU load, but don't sleep indefinitely in case there are
-		tasks waiting to be terminated by the idle task. */
-                vTaskDelay( pdMS_TO_TICKS( ulMSToSleep ) );
-	}
+    const unsigned long ulMSToSleep = 5;
+
+    /* Just to remove compiler warnings. */
+    ( void ) pvParameters;
+
+    /* This task is just used to test the eTaskStateGet() function.  It
+     * does not have anything to do. */
+    for( ; ; )
+    {
+        /* Sleep to reduce CPU load, but don't sleep indefinitely in case there are
+         * tasks waiting to be terminated by the idle task. */
+        vTaskDelay( pdMS_TO_TICKS( ulMSToSleep ) );
+    }
 }
 /*-----------------------------------------------------------*/
 
 /* Called from vApplicationIdleHook(), which is defined in main.c. */
 void vFullDemoIdleFunction( void )
 {
-const unsigned long ulMSToSleep = 15;
-void *pvAllocated;
-
-	/* Sleep to reduce CPU load, but don't sleep indefinitely in case there are
-	tasks waiting to be terminated by the idle task. */
-        vTaskDelay( pdMS_TO_TICKS( ulMSToSleep ) );
-
-	/* Demonstrate a few utility functions that are not demonstrated by any of
-	the standard demo tasks. */
-	prvDemonstrateTaskStateAndHandleGetFunctions();
-
-	/* Demonstrate the use of xTimerPendFunctionCall(), which is not
-	demonstrated by any of the standard demo tasks. */
-	prvDemonstratePendingFunctionCall();
-
-	/* Demonstrate the use of functions that query information about a software
-	timer. */
-	prvDemonstrateTimerQueryFunctions();
-
-	/* If xMutexToDelete has not already been deleted, then delete it now.
-	This is done purely to demonstrate the use of, and test, the
-	vSemaphoreDelete() macro.  Care must be taken not to delete a semaphore
-	that has tasks blocked on it. */
-	if( xMutexToDelete != NULL )
-	{
-		/* For test purposes, add the mutex to the registry, then remove it
-		again, before it is deleted - checking its name is as expected before
-		and after the assertion into the registry and its removal from the
-		registry. */
-		configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );
-		vQueueAddToRegistry( xMutexToDelete, "Test_Mutex" );
-		configASSERT( strcmp( pcQueueGetName( xMutexToDelete ), "Test_Mutex" ) == 0 );
-		vQueueUnregisterQueue( xMutexToDelete );
-		configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );
-
-		vSemaphoreDelete( xMutexToDelete );
-		xMutexToDelete = NULL;
-	}
-
-	/* Exercise heap_5 a bit.  The malloc failed hook will trap failed
-	allocations so there is no need to test here. */
-	pvAllocated = pvPortMalloc( ( rand() % 500 ) + 1 );
-	vPortFree( pvAllocated );
-
-	/* Exit after a fixed time so code coverage results are written to the
-	disk. */
-	#if( projCOVERAGE_TEST == 1 )
-	{
-		const TickType_t xMaxRunTime = pdMS_TO_TICKS( 30000UL );
-
-		/* Exercise code not otherwise executed by standard demo/test tasks. */
-		if( xRunCodeCoverageTestAdditions() != pdPASS )
-		{
-			pcStatusMessage = "Code coverage additions failed.\r\n";
-		}
-
-		if( ( xTaskGetTickCount() - configINITIAL_TICK_COUNT ) >= xMaxRunTime )
-		{
-			vTaskEndScheduler();
-		}
-	}
-	#endif
+    const unsigned long ulMSToSleep = 15;
+    void * pvAllocated;
+
+    /* Sleep to reduce CPU load, but don't sleep indefinitely in case there are
+     * tasks waiting to be terminated by the idle task. */
+    vTaskDelay( pdMS_TO_TICKS( ulMSToSleep ) );
+
+    /* Demonstrate a few utility functions that are not demonstrated by any of
+     * the standard demo tasks. */
+    prvDemonstrateTaskStateAndHandleGetFunctions();
+
+    /* Demonstrate the use of xTimerPendFunctionCall(), which is not
+     * demonstrated by any of the standard demo tasks. */
+    prvDemonstratePendingFunctionCall();
+
+    /* Demonstrate the use of functions that query information about a software
+     * timer. */
+    prvDemonstrateTimerQueryFunctions();
+
+    /* If xMutexToDelete has not already been deleted, then delete it now.
+     * This is done purely to demonstrate the use of, and test, the
+     * vSemaphoreDelete() macro.  Care must be taken not to delete a semaphore
+     * that has tasks blocked on it. */
+    if( xMutexToDelete != NULL )
+    {
+        /* For test purposes, add the mutex to the registry, then remove it
+         * again, before it is deleted - checking its name is as expected before
+         * and after the assertion into the registry and its removal from the
+         * registry. */
+        configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );
+        vQueueAddToRegistry( xMutexToDelete, "Test_Mutex" );
+        configASSERT( strcmp( pcQueueGetName( xMutexToDelete ), "Test_Mutex" ) == 0 );
+        vQueueUnregisterQueue( xMutexToDelete );
+        configASSERT( pcQueueGetName( xMutexToDelete ) == NULL );
+
+        vSemaphoreDelete( xMutexToDelete );
+        xMutexToDelete = NULL;
+    }
+
+    /* Exercise heap_5 a bit.  The malloc failed hook will trap failed
+     * allocations so there is no need to test here. */
+    pvAllocated = pvPortMalloc( ( rand() % 500 ) + 1 );
+    vPortFree( pvAllocated );
+
+    /* Exit after a fixed time so code coverage results are written to the
+     * disk. */
+    #if ( projCOVERAGE_TEST == 1 )
+        {
+            const TickType_t xMaxRunTime = pdMS_TO_TICKS( 30000UL );
+
+            /* Exercise code not otherwise executed by standard demo/test tasks. */
+            if( xRunCodeCoverageTestAdditions() != pdPASS )
+            {
+                pcStatusMessage = "Code coverage additions failed.\r\n";
+            }
+
+            if( ( xTaskGetTickCount() - configINITIAL_TICK_COUNT ) >= xMaxRunTime )
+            {
+                vTaskEndScheduler();
+            }
+        }
+    #endif /* if ( projCOVERAGE_TEST == 1 ) */
 }
 /*-----------------------------------------------------------*/
 
 /* Called by vApplicationTickHook(), which is defined in main.c. */
 void vFullDemoTickHookFunction( void )
 {
-TaskHandle_t xTimerTask;
-
-	/* Call the periodic timer test, which tests the timer API functions that
-	can be called from an ISR. */
-	#if( configUSE_PREEMPTION != 0 )
-	{
-		/* Only created when preemption is used. */
-		vTimerPeriodicISRTests();
-	}
-	#endif
-
-	/* Call the periodic queue overwrite from ISR demo. */
-	vQueueOverwritePeriodicISRDemo();
-
-	#if( configUSE_QUEUE_SETS == 1 ) /* Remove the tests if queue sets are not defined. */
-	{
-		/* Write to a queue that is in use as part of the queue set demo to
-		demonstrate using queue sets from an ISR. */
-		vQueueSetAccessQueueSetFromISR();
-		vQueueSetPollingInterruptAccess();
-	}
-	#endif
-
-	/* Exercise event groups from interrupts. */
-	vPeriodicEventGroupsProcessing();
-
-	/* Exercise giving mutexes from an interrupt. */
-	vInterruptSemaphorePeriodicTest();
-
-	/* Exercise using task notifications from an interrupt. */
-	xNotifyTaskFromISR();
-	// xNotifyArrayTaskFromISR();
-
-	/* Writes to stream buffer byte by byte to test the stream buffer trigger
-	level functionality. */
-	vPeriodicStreamBufferProcessing();
-
-	/* Writes a string to a string buffer four bytes at a time to demonstrate
-	a stream being sent from an interrupt to a task. */
-	vBasicStreamBufferSendFromISR();
-
-	/* For code coverage purposes. */
-	xTimerTask = xTimerGetTimerDaemonTaskHandle();
-	configASSERT( uxTaskPriorityGetFromISR( xTimerTask ) == configTIMER_TASK_PRIORITY );
+    TaskHandle_t xTimerTask;
+
+    /* Call the periodic timer test, which tests the timer API functions that
+     * can be called from an ISR. */
+    #if ( configUSE_PREEMPTION != 0 )
+        {
+            /* Only created when preemption is used. */
+            vTimerPeriodicISRTests();
+        }
+    #endif
+
+    /* Call the periodic queue overwrite from ISR demo. */
+    vQueueOverwritePeriodicISRDemo();
+
+    #if ( configUSE_QUEUE_SETS == 1 ) /* Remove the tests if queue sets are not defined. */
+        {
+            /* Write to a queue that is in use as part of the queue set demo to
+             * demonstrate using queue sets from an ISR. */
+            vQueueSetAccessQueueSetFromISR();
+            vQueueSetPollingInterruptAccess();
+        }
+    #endif
+
+    /* Exercise event groups from interrupts. */
+    vPeriodicEventGroupsProcessing();
+
+    /* Exercise giving mutexes from an interrupt. */
+    vInterruptSemaphorePeriodicTest();
+
+    /* Exercise using task notifications from an interrupt. */
+    xNotifyTaskFromISR();
+    /* xNotifyArrayTaskFromISR(); */
+
+    /* Writes to stream buffer byte by byte to test the stream buffer trigger
+     * level functionality. */
+    vPeriodicStreamBufferProcessing();
+
+    /* Writes a string to a string buffer four bytes at a time to demonstrate
+     * a stream being sent from an interrupt to a task. */
+    vBasicStreamBufferSendFromISR();
+
+    /* For code coverage purposes. */
+    xTimerTask = xTimerGetTimerDaemonTaskHandle();
+    configASSERT( uxTaskPriorityGetFromISR( xTimerTask ) == configTIMER_TASK_PRIORITY );
 }
 /*-----------------------------------------------------------*/
 
-static void prvPendedFunction( void *pvParameter1, uint32_t ulParameter2 )
+static void prvPendedFunction( void * pvParameter1,
+                               uint32_t ulParameter2 )
 {
-static intptr_t ulLastParameter1 = 1000UL, ulLastParameter2 = 0UL;
-intptr_t ulParameter1;
+    static intptr_t ulLastParameter1 = 1000UL, ulLastParameter2 = 0UL;
+    intptr_t ulParameter1;
 
-	ulParameter1 = ( intptr_t ) pvParameter1;
+    ulParameter1 = ( intptr_t ) pvParameter1;
 
-	/* Ensure the parameters are as expected. */
-	configASSERT( ulParameter1 == ( ulLastParameter1 + 1 ) );
-	configASSERT( ulParameter2 == ( ulLastParameter2 + 1 ) );
+    /* Ensure the parameters are as expected. */
+    configASSERT( ulParameter1 == ( ulLastParameter1 + 1 ) );
+    configASSERT( ulParameter2 == ( ulLastParameter2 + 1 ) );
 
-	/* Remember the parameters for the next time the function is called. */
-	ulLastParameter1 = ulParameter1;
-	ulLastParameter2 = ulParameter2;
+    /* Remember the parameters for the next time the function is called. */
+    ulLastParameter1 = ulParameter1;
+    ulLastParameter2 = ulParameter2;
 
-	/* Remove compiler warnings in case configASSERT() is not defined. */
-	( void ) ulLastParameter1;
-	( void ) ulLastParameter2;
+    /* Remove compiler warnings in case configASSERT() is not defined. */
+    ( void ) ulLastParameter1;
+    ( void ) ulLastParameter2;
 }
 /*-----------------------------------------------------------*/
 
 static void prvTestTimerCallback( TimerHandle_t xTimer )
 {
-	/* This is the callback function for the timer accessed by
-	prvDemonstrateTimerQueryFunctions().  The callback does not do anything. */
-	( void ) xTimer;
+    /* This is the callback function for the timer accessed by
+     * prvDemonstrateTimerQueryFunctions().  The callback does not do anything. */
+    ( void ) xTimer;
 }
 /*-----------------------------------------------------------*/
 
 static void prvDemonstrateTimerQueryFunctions( void )
 {
-static TimerHandle_t xTimer = NULL;
-const char *pcTimerName = "TestTimer";
-volatile TickType_t xExpiryTime;
-const TickType_t xDontBlock = 0;
-
-	if( xTimer == NULL )
-	{
-		xTimer = xTimerCreate( pcTimerName, portMAX_DELAY, pdTRUE, NULL, prvTestTimerCallback );
-
-		if( xTimer != NULL )
-		{
-			/* Called from the idle task so a block time must not be
-			specified. */
-			xTimerStart( xTimer, xDontBlock );
-		}
-	}
-
-	if( xTimer != NULL )
-	{
-		/* Demonstrate querying a timer's name. */
-		configASSERT( strcmp( pcTimerGetName( xTimer ), pcTimerName ) == 0 );
-
-		/* Demonstrate querying a timer's period. */
-		configASSERT( xTimerGetPeriod( xTimer ) == portMAX_DELAY );
-
-		/* Demonstrate querying a timer's next expiry time, although nothing is
-		done with the returned value.  Note if the expiry time is less than the
-		maximum tick count then the expiry time has overflowed from the current
-		time.  In this case the expiry time was set to portMAX_DELAY, so it is
-		expected to be less than the current time until the current time has
-		itself overflowed. */
-		xExpiryTime = xTimerGetExpiryTime( xTimer );
-		( void ) xExpiryTime;
-	}
+    static TimerHandle_t xTimer = NULL;
+    const char * pcTimerName = "TestTimer";
+    volatile TickType_t xExpiryTime;
+    const TickType_t xDontBlock = 0;
+
+    if( xTimer == NULL )
+    {
+        xTimer = xTimerCreate( pcTimerName, portMAX_DELAY, pdTRUE, NULL, prvTestTimerCallback );
+
+        if( xTimer != NULL )
+        {
+            /* Called from the idle task so a block time must not be
+             * specified. */
+            xTimerStart( xTimer, xDontBlock );
+        }
+    }
+
+    if( xTimer != NULL )
+    {
+        /* Demonstrate querying a timer's name. */
+        configASSERT( strcmp( pcTimerGetName( xTimer ), pcTimerName ) == 0 );
+
+        /* Demonstrate querying a timer's period. */
+        configASSERT( xTimerGetPeriod( xTimer ) == portMAX_DELAY );
+
+        /* Demonstrate querying a timer's next expiry time, although nothing is
+         * done with the returned value.  Note if the expiry time is less than the
+         * maximum tick count then the expiry time has overflowed from the current
+         * time.  In this case the expiry time was set to portMAX_DELAY, so it is
+         * expected to be less than the current time until the current time has
+         * itself overflowed. */
+        xExpiryTime = xTimerGetExpiryTime( xTimer );
+        ( void ) xExpiryTime;
+    }
 }
 /*-----------------------------------------------------------*/
 
 static void prvDemonstratePendingFunctionCall( void )
 {
-static intptr_t ulParameter1 = 1000UL, ulParameter2 = 0UL;
-const TickType_t xDontBlock = 0; /* This is called from the idle task so must *not* attempt to block. */
+    static intptr_t ulParameter1 = 1000UL, ulParameter2 = 0UL;
+    const TickType_t xDontBlock = 0; /* This is called from the idle task so must *not* attempt to block. */
+
+    /* prvPendedFunction() just expects the parameters to be incremented by one
+     * each time it is called. */
 
-	/* prvPendedFunction() just expects the parameters to be incremented by one
-	each time it is called. */
-	ulParameter1++;
-	ulParameter2++;
+    ulParameter1++;
+    ulParameter2++;
 
-	/* Pend the function call, sending the parameters. */
-	xTimerPendFunctionCall( prvPendedFunction, ( void * ) ulParameter1, ulParameter2, xDontBlock );
+    /* Pend the function call, sending the parameters. */
+    xTimerPendFunctionCall( prvPendedFunction, ( void * ) ulParameter1, ulParameter2, xDontBlock );
 }
 /*-----------------------------------------------------------*/
 
 static void prvDemonstrateTaskStateAndHandleGetFunctions( void )
 {
-TaskHandle_t xIdleTaskHandle, xTimerTaskHandle;
-char *pcTaskName;
-static portBASE_TYPE xPerformedOneShotTests = pdFALSE;
-TaskHandle_t xTestTask;
-TaskStatus_t xTaskInfo;
-extern StackType_t uxTimerTaskStack[];
-
-	/* Demonstrate the use of the xTimerGetTimerDaemonTaskHandle() and
-	xTaskGetIdleTaskHandle() functions.  Also try using the function that sets
-	the task number. */
-	xIdleTaskHandle = xTaskGetIdleTaskHandle();
-	xTimerTaskHandle = xTimerGetTimerDaemonTaskHandle();
-
-	/* This is the idle hook, so the current task handle should equal the
-	returned idle task handle. */
-	if( xTaskGetCurrentTaskHandle() != xIdleTaskHandle )
-	{
-		pcStatusMessage = "Error:  Returned idle task handle was incorrect";
-	}
-
-	/* Check the same handle is obtained using the idle task's name.  First try
-	with the wrong name, then the right name. */
-	if( xTaskGetHandle( "Idle" ) == xIdleTaskHandle )
-	{
-		pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
-	}
-
-	if( xTaskGetHandle( "IDLE" ) != xIdleTaskHandle )
-	{
-		pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
-	}
-
-	/* Check the timer task handle was returned correctly. */
-	pcTaskName = pcTaskGetName( xTimerTaskHandle );
-	if( strcmp( pcTaskName, "Tmr Svc" ) != 0 )
-	{
-		pcStatusMessage = "Error:  Returned timer task handle was incorrect";
-	}
-
-	if( xTaskGetHandle( "Tmr Svc" ) != xTimerTaskHandle )
-	{
-		pcStatusMessage = "Error:  Returned handle for name Tmr Svc was incorrect";
-	}
-
-	/* This task is running, make sure it's state is returned as running. */
-	if( eTaskStateGet( xIdleTaskHandle ) != eRunning )
-	{
-		pcStatusMessage = "Error:  Returned idle task state was incorrect";
-	}
-
-	/* If this task is running, then the timer task must be blocked. */
-	if( eTaskStateGet( xTimerTaskHandle ) != eBlocked )
-	{
-		pcStatusMessage = "Error:  Returned timer task state was incorrect";
-	}
-
-	/* Also with the vTaskGetInfo() function. */
-	vTaskGetInfo( xTimerTaskHandle, /* The task being queried. */
-					  &xTaskInfo,		/* The structure into which information on the task will be written. */
-					  pdTRUE,			/* Include the task's high watermark in the structure. */
-					  eInvalid );		/* Include the task state in the structure. */
-
-	/* Check the information returned by vTaskGetInfo() is as expected. */
-	if( ( xTaskInfo.eCurrentState != eBlocked )						 ||
-		( strcmp( xTaskInfo.pcTaskName, "Tmr Svc" ) != 0 )			 ||
-		( xTaskInfo.uxCurrentPriority != configTIMER_TASK_PRIORITY ) ||
-		( xTaskInfo.pxStackBase != uxTimerTaskStack )				 ||
-		( xTaskInfo.xHandle != xTimerTaskHandle ) )
-	{
-		pcStatusMessage = "Error:  vTaskGetInfo() returned incorrect information about the timer task";
-	}
-
-	/* Other tests that should only be performed once follow.  The test task
-	is not created on each iteration because to do so would cause the death
-	task to report an error (too many tasks running). */
-	if( xPerformedOneShotTests == pdFALSE )
-	{
-		/* Don't run this part of the test again. */
-		xPerformedOneShotTests = pdTRUE;
-
-		/* Create a test task to use to test other eTaskStateGet() return values. */
-		if( xTaskCreate( prvTestTask, "Test", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, &xTestTask ) == pdPASS )
-		{
-			/* If this task is running, the test task must be in the ready state. */
-			if( eTaskStateGet( xTestTask ) != eReady )
-			{
-				pcStatusMessage = "Error: Returned test task state was incorrect 1";
-			}
-
-			/* Now suspend the test task and check its state is reported correctly. */
-			vTaskSuspend( xTestTask );
-			if( eTaskStateGet( xTestTask ) != eSuspended )
-			{
-				pcStatusMessage = "Error: Returned test task state was incorrect 2";
-			}
-
-			/* Now delete the task and check its state is reported correctly. */
-			vTaskDelete( xTestTask );
-			if( eTaskStateGet( xTestTask ) != eDeleted )
-			{
-				pcStatusMessage = "Error: Returned test task state was incorrect 3";
-			}
-		}
-	}
+    TaskHandle_t xIdleTaskHandle, xTimerTaskHandle;
+    char * pcTaskName;
+    static portBASE_TYPE xPerformedOneShotTests = pdFALSE;
+    TaskHandle_t xTestTask;
+    TaskStatus_t xTaskInfo;
+    extern StackType_t uxTimerTaskStack[];
+
+    /* Demonstrate the use of the xTimerGetTimerDaemonTaskHandle() and
+     * xTaskGetIdleTaskHandle() functions.  Also try using the function that sets
+     * the task number. */
+    xIdleTaskHandle = xTaskGetIdleTaskHandle();
+    xTimerTaskHandle = xTimerGetTimerDaemonTaskHandle();
+
+    /* This is the idle hook, so the current task handle should equal the
+     * returned idle task handle. */
+    if( xTaskGetCurrentTaskHandle() != xIdleTaskHandle )
+    {
+        pcStatusMessage = "Error:  Returned idle task handle was incorrect";
+    }
+
+    /* Check the same handle is obtained using the idle task's name.  First try
+     * with the wrong name, then the right name. */
+    if( xTaskGetHandle( "Idle" ) == xIdleTaskHandle )
+    {
+        pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
+    }
+
+    if( xTaskGetHandle( "IDLE" ) != xIdleTaskHandle )
+    {
+        pcStatusMessage = "Error:  Returned handle for name Idle was incorrect";
+    }
+
+    /* Check the timer task handle was returned correctly. */
+    pcTaskName = pcTaskGetName( xTimerTaskHandle );
+
+    if( strcmp( pcTaskName, "Tmr Svc" ) != 0 )
+    {
+        pcStatusMessage = "Error:  Returned timer task handle was incorrect";
+    }
+
+    if( xTaskGetHandle( "Tmr Svc" ) != xTimerTaskHandle )
+    {
+        pcStatusMessage = "Error:  Returned handle for name Tmr Svc was incorrect";
+    }
+
+    /* This task is running, make sure it's state is returned as running. */
+    if( eTaskStateGet( xIdleTaskHandle ) != eRunning )
+    {
+        pcStatusMessage = "Error:  Returned idle task state was incorrect";
+    }
+
+    /* If this task is running, then the timer task must be blocked. */
+    if( eTaskStateGet( xTimerTaskHandle ) != eBlocked )
+    {
+        pcStatusMessage = "Error:  Returned timer task state was incorrect";
+    }
+
+    /* Also with the vTaskGetInfo() function. */
+    vTaskGetInfo( xTimerTaskHandle, /* The task being queried. */
+                  &xTaskInfo,       /* The structure into which information on the task will be written. */
+                  pdTRUE,           /* Include the task's high watermark in the structure. */
+                  eInvalid );       /* Include the task state in the structure. */
+
+    /* Check the information returned by vTaskGetInfo() is as expected. */
+    if( ( xTaskInfo.eCurrentState != eBlocked ) ||
+        ( strcmp( xTaskInfo.pcTaskName, "Tmr Svc" ) != 0 ) ||
+        ( xTaskInfo.uxCurrentPriority != configTIMER_TASK_PRIORITY ) ||
+        ( xTaskInfo.pxStackBase != uxTimerTaskStack ) ||
+        ( xTaskInfo.xHandle != xTimerTaskHandle ) )
+    {
+        pcStatusMessage = "Error:  vTaskGetInfo() returned incorrect information about the timer task";
+    }
+
+    /* Other tests that should only be performed once follow.  The test task
+     * is not created on each iteration because to do so would cause the death
+     * task to report an error (too many tasks running). */
+    if( xPerformedOneShotTests == pdFALSE )
+    {
+        /* Don't run this part of the test again. */
+        xPerformedOneShotTests = pdTRUE;
+
+        /* Create a test task to use to test other eTaskStateGet() return values. */
+        if( xTaskCreate( prvTestTask, "Test", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, &xTestTask ) == pdPASS )
+        {
+            /* If this task is running, the test task must be in the ready state. */
+            if( eTaskStateGet( xTestTask ) != eReady )
+            {
+                pcStatusMessage = "Error: Returned test task state was incorrect 1";
+            }
+
+            /* Now suspend the test task and check its state is reported correctly. */
+            vTaskSuspend( xTestTask );
+
+            if( eTaskStateGet( xTestTask ) != eSuspended )
+            {
+                pcStatusMessage = "Error: Returned test task state was incorrect 2";
+            }
+
+            /* Now delete the task and check its state is reported correctly. */
+            vTaskDelete( xTestTask );
+
+            if( eTaskStateGet( xTestTask ) != eDeleted )
+            {
+                pcStatusMessage = "Error: Returned test task state was incorrect 3";
+            }
+        }
+    }
 }
 /*-----------------------------------------------------------*/
 
-static void prvDemoQueueSpaceFunctions( void *pvParameters )
+static void prvDemoQueueSpaceFunctions( void * pvParameters )
 {
-QueueHandle_t xQueue = NULL;
-const unsigned portBASE_TYPE uxQueueLength = 10;
-unsigned portBASE_TYPE uxReturn, x;
-
-	/* Remove compiler warnings. */
-	( void ) pvParameters;
-
-	/* Create the queue that will be used.  Nothing is actually going to be
-	sent or received so the queue item size is set to 0. */
-	xQueue = xQueueCreate( uxQueueLength, 0 );
-	configASSERT( xQueue );
-
-	for( ;; )
-	{
-		for( x = 0; x < uxQueueLength; x++ )
-		{
-			/* Ask how many messages are available... */
-			uxReturn = uxQueueMessagesWaiting( xQueue );
-
-			/* Check the number of messages being reported as being available
-			is as expected, and force an assert if not. */
-			if( uxReturn != x )
-			{
-				/* xQueue cannot be NULL so this is deliberately causing an
-				assert to be triggered as there is an error. */
-				configASSERT( xQueue == NULL );
-			}
-
-			/* Ask how many spaces remain in the queue... */
-			uxReturn = uxQueueSpacesAvailable( xQueue );
-
-			/* Check the number of spaces being reported as being available
-			is as expected, and force an assert if not. */
-			if( uxReturn != ( uxQueueLength - x ) )
-			{
-				/* xQueue cannot be NULL so this is deliberately causing an
-				assert to be triggered as there is an error. */
-				configASSERT( xQueue == NULL );
-			}
-
-			/* Fill one more space in the queue. */
-			xQueueSendToBack( xQueue, NULL, 0 );
-		}
-
-		/* Perform the same check while the queue is full. */
-		uxReturn = uxQueueMessagesWaiting( xQueue );
-		if( uxReturn != uxQueueLength )
-		{
-			configASSERT( xQueue == NULL );
-		}
-
-		uxReturn = uxQueueSpacesAvailable( xQueue );
-
-		if( uxReturn != 0 )
-		{
-			configASSERT( xQueue == NULL );
-		}
-
-		/* The queue is full, start again. */
-		xQueueReset( xQueue );
-
-		#if( configUSE_PREEMPTION == 0 )
-			taskYIELD();
-		#endif
-	}
+    QueueHandle_t xQueue = NULL;
+    const unsigned portBASE_TYPE uxQueueLength = 10;
+    unsigned portBASE_TYPE uxReturn, x;
+
+    /* Remove compiler warnings. */
+    ( void ) pvParameters;
+
+    /* Create the queue that will be used.  Nothing is actually going to be
+     * sent or received so the queue item size is set to 0. */
+    xQueue = xQueueCreate( uxQueueLength, 0 );
+    configASSERT( xQueue );
+
+    for( ; ; )
+    {
+        for( x = 0; x < uxQueueLength; x++ )
+        {
+            /* Ask how many messages are available... */
+            uxReturn = uxQueueMessagesWaiting( xQueue );
+
+            /* Check the number of messages being reported as being available
+             * is as expected, and force an assert if not. */
+            if( uxReturn != x )
+            {
+                /* xQueue cannot be NULL so this is deliberately causing an
+                 * assert to be triggered as there is an error. */
+                configASSERT( xQueue == NULL );
+            }
+
+            /* Ask how many spaces remain in the queue... */
+            uxReturn = uxQueueSpacesAvailable( xQueue );
+
+            /* Check the number of spaces being reported as being available
+             * is as expected, and force an assert if not. */
+            if( uxReturn != ( uxQueueLength - x ) )
+            {
+                /* xQueue cannot be NULL so this is deliberately causing an
+                 * assert to be triggered as there is an error. */
+                configASSERT( xQueue == NULL );
+            }
+
+            /* Fill one more space in the queue. */
+            xQueueSendToBack( xQueue, NULL, 0 );
+        }
+
+        /* Perform the same check while the queue is full. */
+        uxReturn = uxQueueMessagesWaiting( xQueue );
+
+        if( uxReturn != uxQueueLength )
+        {
+            configASSERT( xQueue == NULL );
+        }
+
+        uxReturn = uxQueueSpacesAvailable( xQueue );
+
+        if( uxReturn != 0 )
+        {
+            configASSERT( xQueue == NULL );
+        }
+
+        /* The queue is full, start again. */
+        xQueueReset( xQueue );
+
+        #if ( configUSE_PREEMPTION == 0 )
+            taskYIELD();
+        #endif
+    }
 }
 /*-----------------------------------------------------------*/
 
-static void prvPermanentlyBlockingSemaphoreTask( void *pvParameters )
+static void prvPermanentlyBlockingSemaphoreTask( void * pvParameters )
 {
-SemaphoreHandle_t xSemaphore;
+    SemaphoreHandle_t xSemaphore;
 
-	/* Prevent compiler warning about unused parameter in the case that
-	configASSERT() is not defined. */
-	( void ) pvParameters;
+    /* Prevent compiler warning about unused parameter in the case that
+     * configASSERT() is not defined. */
+    ( void ) pvParameters;
 
-	/* This task should block on a semaphore, and never return. */
-	xSemaphore = xSemaphoreCreateBinary();
-	configASSERT( xSemaphore );
+    /* This task should block on a semaphore, and never return. */
+    xSemaphore = xSemaphoreCreateBinary();
+    configASSERT( xSemaphore );
 
-	xSemaphoreTake( xSemaphore, portMAX_DELAY );
+    xSemaphoreTake( xSemaphore, portMAX_DELAY );
 
-	/* The above xSemaphoreTake() call should never return, force an assert if
-	it does. */
-	configASSERT( pvParameters != NULL );
-	vTaskDelete( NULL );
+    /* The above xSemaphoreTake() call should never return, force an assert if
+     * it does. */
+    configASSERT( pvParameters != NULL );
+    vTaskDelete( NULL );
 }
 /*-----------------------------------------------------------*/
 
-static void prvPermanentlyBlockingNotificationTask( void *pvParameters )
+static void prvPermanentlyBlockingNotificationTask( void * pvParameters )
 {
-	/* Prevent compiler warning about unused parameter in the case that
-	configASSERT() is not defined. */
-	( void ) pvParameters;
+    /* Prevent compiler warning about unused parameter in the case that
+     * configASSERT() is not defined. */
+    ( void ) pvParameters;
 
-	/* This task should block on a task notification, and never return. */
-	ulTaskNotifyTake( pdTRUE, portMAX_DELAY );
+    /* This task should block on a task notification, and never return. */
+    ulTaskNotifyTake( pdTRUE, portMAX_DELAY );
 
-	/* The above ulTaskNotifyTake() call should never return, force an assert
-	if it does. */
-	configASSERT( pvParameters != NULL );
-	vTaskDelete( NULL );
+    /* The above ulTaskNotifyTake() call should never return, force an assert
+     * if it does. */
+    configASSERT( pvParameters != NULL );
+    vTaskDelete( NULL );
 }
 /*-----------------------------------------------------------*/
 
 static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer )
 {
-intptr_t ulTimerID;
+    intptr_t ulTimerID;
 
-	/* Increment the timer's ID to show the callback has executed. */
-	ulTimerID = ( intptr_t ) pvTimerGetTimerID( xTimer );
-	ulTimerID++;
-	vTimerSetTimerID( xTimer, ( void * ) ulTimerID );
+    /* Increment the timer's ID to show the callback has executed. */
+    ulTimerID = ( intptr_t ) pvTimerGetTimerID( xTimer );
+    ulTimerID++;
+    vTimerSetTimerID( xTimer, ( void * ) ulTimerID );
 }
 /*-----------------------------------------------------------*/
 
-static void prvDemonstrateChangingTimerReloadMode( void *pvParameters )
+static void prvDemonstrateChangingTimerReloadMode( void * pvParameters )
 {
-TimerHandle_t xTimer;
-const char * const pcTimerName = "TestTimer";
-const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
-
-	/* Avoid compiler warnings about unused parameter. */
-	( void ) pvParameters;
-
-	xTimer = xTimerCreate( 	pcTimerName,
-							x100ms,
-							pdFALSE, /* Created as a one-shot timer. */
-							0,
-							prvReloadModeTestTimerCallback );
-	configASSERT( xTimer );
-	configASSERT( xTimerIsTimerActive( xTimer ) == pdFALSE );
-	configASSERT( xTimerGetTimerDaemonTaskHandle() != NULL );
-	configASSERT( strcmp( pcTimerName, pcTimerGetName( xTimer ) ) == 0 );
-	configASSERT( xTimerGetPeriod( xTimer ) == x100ms );
-
-	/* Timer was created as a one-shot timer.  Its callback just increments the
-	timer's ID - so set the ID to 0, let the timer run for a number of timeout
-	periods, then check the timer has only executed once. */
-	vTimerSetTimerID( xTimer, ( void * ) 0 );
-	xTimerStart( xTimer, portMAX_DELAY );
-	vTaskDelay( 3UL * x100ms );
-	configASSERT( ( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );
-
-	/* Now change the timer to be an auto-reload timer and check it executes
-	the expected number of times. */
-	vTimerSetReloadMode( xTimer, pdTRUE );
-	vTimerSetTimerID( xTimer, ( void * ) 0 );
-	xTimerStart( xTimer, 0 );
-	vTaskDelay( ( 3UL * x100ms ) + ( x100ms / 2UL ) ); /* Three full periods. */
-	configASSERT( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) == 3UL );
-	configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );
-
-	/* Now change the timer back to be a one-shot timer and check it only
-	executes once. */
-	vTimerSetReloadMode( xTimer, pdFALSE );
-	vTimerSetTimerID( xTimer, ( void * ) 0 );
-	xTimerStart( xTimer, 0 );
-	vTaskDelay( 3UL * x100ms );
-	configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );
-	configASSERT( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) == 1UL );
-
-	/* Clean up at the end. */
-	xTimerDelete( xTimer, portMAX_DELAY );
-	vTaskDelete( NULL );
+    TimerHandle_t xTimer;
+    const char * const pcTimerName = "TestTimer";
+    const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
+
+    /* Avoid compiler warnings about unused parameter. */
+    ( void ) pvParameters;
+
+    xTimer = xTimerCreate( pcTimerName,
+                           x100ms,
+                           pdFALSE,  /* Created as a one-shot timer. */
+                           0,
+                           prvReloadModeTestTimerCallback );
+    configASSERT( xTimer );
+    configASSERT( xTimerIsTimerActive( xTimer ) == pdFALSE );
+    configASSERT( xTimerGetTimerDaemonTaskHandle() != NULL );
+    configASSERT( strcmp( pcTimerName, pcTimerGetName( xTimer ) ) == 0 );
+    configASSERT( xTimerGetPeriod( xTimer ) == x100ms );
+
+    /* Timer was created as a one-shot timer.  Its callback just increments the
+     * timer's ID - so set the ID to 0, let the timer run for a number of timeout
+     * periods, then check the timer has only executed once. */
+    vTimerSetTimerID( xTimer, ( void * ) 0 );
+    xTimerStart( xTimer, portMAX_DELAY );
+    vTaskDelay( 3UL * x100ms );
+    configASSERT( ( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );
+
+    /* Now change the timer to be an auto-reload timer and check it executes
+     * the expected number of times. */
+    vTimerSetReloadMode( xTimer, pdTRUE );
+    vTimerSetTimerID( xTimer, ( void * ) 0 );
+    xTimerStart( xTimer, 0 );
+    vTaskDelay( ( 3UL * x100ms ) + ( x100ms / 2UL ) ); /* Three full periods. */
+    configASSERT( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) == 3UL );
+    configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );
+
+    /* Now change the timer back to be a one-shot timer and check it only
+     * executes once. */
+    vTimerSetReloadMode( xTimer, pdFALSE );
+    vTimerSetTimerID( xTimer, ( void * ) 0 );
+    xTimerStart( xTimer, 0 );
+    vTaskDelay( 3UL * x100ms );
+    configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );
+    configASSERT( ( uintptr_t ) ( pvTimerGetTimerID( xTimer ) ) == 1UL );
+
+    /* Clean up at the end. */
+    xTimerDelete( xTimer, portMAX_DELAY );
+    vTaskDelete( NULL );
 }
diff --git a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/syscall.c b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/syscall.c
index 1e98621a4..d3e4db23a 100644
--- a/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/syscall.c
+++ b/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/syscall.c
@@ -24,12 +24,13 @@
  *
  */
 #ifdef __cplusplus
-extern "C" {
+    extern "C" {
 #endif
 
 #include <sys/types.h>
 
-typedef struct UART_t {
+typedef struct UART_t
+{
     volatile uint32_t DATA;
     volatile uint32_t STATE;
     volatile uint32_t CTRL;
@@ -37,19 +38,19 @@ typedef struct UART_t {
     volatile uint32_t BAUDDIV;
 } UART_t;
 
-#define UART0_ADDR ((UART_t *)(0x40004000))
-#define UART_DR(baseaddr) (*(unsigned int *)(baseaddr))
+#define UART0_ADDR           ( ( UART_t * ) ( 0x40004000 ) )
+#define UART_DR( baseaddr )    ( *( unsigned int * ) ( baseaddr ) )
 
-#define UART_STATE_TXFULL (1 << 0)
-#define UART_CTRL_TX_EN (1 << 0)
-#define UART_CTRL_RX_EN (1 << 1)
+#define UART_STATE_TXFULL    ( 1 << 0 )
+#define UART_CTRL_TX_EN      ( 1 << 0 )
+#define UART_CTRL_RX_EN      ( 1 << 1 )
 
 
 extern unsigned long _heap_bottom;
 extern unsigned long _heap_top;
 extern unsigned long g_ulBase;
 
-static void *heap_end = 0;
+static void * heap_end = 0;
 
 /**
  * @brief initializes the UART emulated hardware
@@ -65,7 +66,7 @@ void uart_init()
  * @todo  implement if necessary
  *
  */
-int _fstat(int file)
+int _fstat( int file )
 {
     return 0;
 }
@@ -75,9 +76,11 @@ int _fstat(int file)
  * @todo  implement if necessary
  *
  */
-int _read(int file, char *buf, int len)
+int _read( int file,
+           char * buf,
+           int len )
 {
-     return -1;
+    return -1;
 }
 
 /**
@@ -88,13 +91,17 @@ int _read(int file, char *buf, int len)
  * @param [in] len   length of the buffer
  * @returns the number of bytes written
  */
-int _write(int file, char *buf, int len)
+int _write( int file,
+            char * buf,
+            int len )
 {
     int todo;
 
-    for (todo = 0; todo < len; todo++){
-        UART_DR(UART0_ADDR) = *buf++;
+    for( todo = 0; todo < len; todo++ )
+    {
+        UART_DR( UART0_ADDR ) = *buf++;
     }
+
     return len;
 }
 
@@ -104,20 +111,20 @@ int _write(int file, char *buf, int len)
  * @returns the previous top of the heap
  * @note uses a global variable <b>heap_end</b> to keep track of the previous top
  */
-void* _sbrk(int incr)
+void * _sbrk( int incr )
 {
-    char *prev_heap_end;
+    char * prev_heap_end;
 
-    if (heap_end == 0)
+    if( heap_end == 0 )
     {
-        heap_end = (void*) &_heap_bottom;
+        heap_end = ( void * ) &_heap_bottom;
     }
 
     prev_heap_end = heap_end;
 
-    if ((heap_end + incr) > (void*)&_heap_top)
+    if( ( heap_end + incr ) > ( void * ) &_heap_top )
     {
-        return (void*)-1;
+        return ( void * ) -1;
     }
 
     heap_end += incr;
@@ -126,5 +133,5 @@ void* _sbrk(int incr)
 }
 
 #ifdef __cplusplus
-}
+    }
 #endif