Run unctustify, fix some Readme wording

13 files changed, 1741 insertions, 1679 deletions

diff --git a/FreeRTOS/Demo/Posix_GCC/FreeRTOSConfig.h b/FreeRTOS/Demo/Posix_GCC/FreeRTOSConfig.h
index 05d3e754c..680bbf852 100644
--- a/FreeRTOS/Demo/Posix_GCC/FreeRTOSConfig.h
+++ b/FreeRTOS/Demo/Posix_GCC/FreeRTOSConfig.h
@@ -27,154 +27,158 @@
 #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
- * http://www.freertos.org/a00110.html
- *----------------------------------------------------------*/
-
-#define configUSE_PREEMPTION					1
-#define configUSE_PORT_OPTIMISED_TASK_SELECTION	0
-#define configUSE_IDLE_HOOK						1
-#define configUSE_TICK_HOOK						1
-#define configUSE_DAEMON_TASK_STARTUP_HOOK		1
-#define configTICK_RATE_HZ						( 1000 ) /* In this non-real time simulated environment the tick frequency has to be at least a multiple of the Win32 tick frequency, and therefore very slow. */
-#define configMINIMAL_STACK_SIZE				( ( unsigned short ) 70 ) /* In this simulated case, the stack only has to hold one small structure as the real stack is part of the win32 thread. */
-#define configTOTAL_HEAP_SIZE					( ( size_t ) ( 65 * 1024 ) )
-#define configMAX_TASK_NAME_LEN					( 12 )
-#define configUSE_TRACE_FACILITY				1
-#define configUSE_16_BIT_TICKS					0
-#define configIDLE_SHOULD_YIELD					1
-#define configUSE_MUTEXES						1
-#define configCHECK_FOR_STACK_OVERFLOW			0
-#define configUSE_RECURSIVE_MUTEXES				1
-#define configQUEUE_REGISTRY_SIZE				20
-#define configUSE_APPLICATION_TASK_TAG			1
-#define configUSE_COUNTING_SEMAPHORES			1
-#define configUSE_ALTERNATIVE_API				0
-#define configUSE_QUEUE_SETS					1
-#define configUSE_TASK_NOTIFICATIONS			1
-#define configSUPPORT_STATIC_ALLOCATION			1
+* 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
+* http://www.freertos.org/a00110.html
+*----------------------------------------------------------*/
+
+#define configUSE_PREEMPTION                       1
+#define configUSE_PORT_OPTIMISED_TASK_SELECTION    0
+#define configUSE_IDLE_HOOK                        1
+#define configUSE_TICK_HOOK                        1
+#define configUSE_DAEMON_TASK_STARTUP_HOOK         1
+#define configTICK_RATE_HZ                         ( 1000 )                  /* In this non-real time simulated environment the tick frequency has to be at least a multiple of the Win32 tick frequency, and therefore very slow. */
+#define configMINIMAL_STACK_SIZE                   ( ( unsigned short ) 70 ) /* In this simulated case, the stack only has to hold one small structure as the real stack is part of the win32 thread. */
+#define configTOTAL_HEAP_SIZE                      ( ( size_t ) ( 65 * 1024 ) )
+#define configMAX_TASK_NAME_LEN                    ( 12 )
+#define configUSE_TRACE_FACILITY                   1
+#define configUSE_16_BIT_TICKS                     0
+#define configIDLE_SHOULD_YIELD                    1
+#define configUSE_MUTEXES                          1
+#define configCHECK_FOR_STACK_OVERFLOW             0
+#define configUSE_RECURSIVE_MUTEXES                1
+#define configQUEUE_REGISTRY_SIZE                  20
+#define configUSE_APPLICATION_TASK_TAG             1
+#define configUSE_COUNTING_SEMAPHORES              1
+#define configUSE_ALTERNATIVE_API                  0
+#define configUSE_QUEUE_SETS                       1
+#define configUSE_TASK_NOTIFICATIONS               1
+#define configSUPPORT_STATIC_ALLOCATION            1
 
 /* Software timer related configuration options.  The maximum possible task
-priority is configMAX_PRIORITIES - 1.  The priority of the timer task is
-deliberately set higher to ensure it is correctly capped back to
-configMAX_PRIORITIES - 1. */
-#define configUSE_TIMERS						1
-#define configTIMER_TASK_PRIORITY				( configMAX_PRIORITIES - 1 )
-#define configTIMER_QUEUE_LENGTH				20
-#define configTIMER_TASK_STACK_DEPTH			( configMINIMAL_STACK_SIZE * 2 )
+ * priority is configMAX_PRIORITIES - 1.  The priority of the timer task is
+ * deliberately set higher to ensure it is correctly capped back to
+ * configMAX_PRIORITIES - 1. */
+#define configUSE_TIMERS                           1
+#define configTIMER_TASK_PRIORITY                  ( configMAX_PRIORITIES - 1 )
+#define configTIMER_QUEUE_LENGTH                   20
+#define configTIMER_TASK_STACK_DEPTH               ( configMINIMAL_STACK_SIZE * 2 )
 
-#define configMAX_PRIORITIES					( 7 )
+#define configMAX_PRIORITIES                       ( 7 )
 
 /* Run time stats gathering configuration options. */
 unsigned long ulGetRunTimeCounterValue( void ); /* Prototype of function that returns run time counter. */
-void vConfigureTimerForRunTimeStats( void );	/* Prototype of function that initialises the run time counter. */
-#define configGENERATE_RUN_TIME_STATS			1
+void vConfigureTimerForRunTimeStats( void );    /* Prototype of function that initialises the run time counter. */
+#define configGENERATE_RUN_TIME_STATS             1
 
 /* Co-routine related configuration options. */
-#define configUSE_CO_ROUTINES 					0
-#define configMAX_CO_ROUTINE_PRIORITIES			( 2 )
+#define configUSE_CO_ROUTINES                     0
+#define configMAX_CO_ROUTINE_PRIORITIES           ( 2 )
 
 /* This demo can use of one or more example stats formatting functions.  These
-format the raw data provided by the uxTaskGetSystemState() function in to human
-readable ASCII form.  See the notes in the implementation of vTaskList() within
-FreeRTOS/Source/tasks.c for limitations. */
-#define configUSE_STATS_FORMATTING_FUNCTIONS	0
+ * format the raw data provided by the uxTaskGetSystemState() function in to human
+ * readable ASCII form.  See the notes in the implementation of vTaskList() within
+ * FreeRTOS/Source/tasks.c for limitations. */
+#define configUSE_STATS_FORMATTING_FUNCTIONS      0
 
 /* Enables the test whereby a stack larger than the total heap size is
-requested. */
-#define configSTACK_DEPTH_TYPE uint32_t
+ * requested. */
+#define configSTACK_DEPTH_TYPE                    uint32_t
 
 /* Set the following definitions to 1 to include the API function, or zero
-to exclude the API function.  In most cases the linker will remove unused
-functions anyway. */
-#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 configINCLUDE_MESSAGE_BUFFER_AMP_DEMO	0
+ * to exclude the API function.  In most cases the linker will remove unused
+ * functions anyway. */
+#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 configINCLUDE_MESSAGE_BUFFER_AMP_DEMO     0
 #if ( configINCLUDE_MESSAGE_BUFFER_AMP_DEMO == 1 )
-	extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer );
-	#define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreBInterrupt( pxStreamBuffer )
+    extern void vGenerateCoreBInterrupt( void * xUpdatedMessageBuffer );
+    #define sbSEND_COMPLETED( pxStreamBuffer )    vGenerateCoreBInterrupt( pxStreamBuffer )
 #endif /* configINCLUDE_MESSAGE_BUFFER_AMP_DEMO */
 
-extern void vAssertCalled( const char * const pcFileName,  unsigned long ulLine );
+extern void vAssertCalled( const char * const pcFileName,
+                           unsigned long ulLine );
 
 /* projCOVERAGE_TEST should be defined on the command line so this file can be
-used with multiple project configurations.  If it is
+ * used with multiple project configurations.  If it is
  */
 #ifndef projCOVERAGE_TEST
-	#error projCOVERAGE_TEST should be defined to 1 or 0 on the command line.
+    #error projCOVERAGE_TEST should be defined to 1 or 0 on the command line.
 #endif
 
-#if( projCOVERAGE_TEST == 1 )
-	/* Insert NOPs in empty decision paths to ensure both true and false paths
-	are being tested. */
-	#define mtCOVERAGE_TEST_MARKER() __asm volatile( "NOP" )
+#if ( projCOVERAGE_TEST == 1 )
 
-	/* Ensure the tick count overflows during the coverage test. */
-	#define configINITIAL_TICK_COUNT 0xffffd800UL
+/* Insert NOPs in empty decision paths to ensure both true and false paths
+ * are being tested. */
+    #define mtCOVERAGE_TEST_MARKER()    __asm volatile ( "NOP" )
 
-	/* Allows tests of trying to allocate more than the heap has free. */
-	#define configUSE_MALLOC_FAILED_HOOK			0
+/* Ensure the tick count overflows during the coverage test. */
+    #define configINITIAL_TICK_COUNT        0xffffd800UL
 
-	/* To test builds that remove the static qualifier for debug builds. */
-	#define portREMOVE_STATIC_QUALIFIER
-#else
-	/* It is a good idea to define configASSERT() while developing.  configASSERT()
-	uses the same semantics as the standard C assert() macro.  Don't define
-	configASSERT() when performing code coverage tests though, as it is not
-	intended to asserts() to fail, some some code is intended not to run if no
-	errors are present. */
-	#define configASSERT( x ) if( ( x ) == 0 ) vAssertCalled(  __FILE__, __LINE__ )
+/* Allows tests of trying to allocate more than the heap has free. */
+    #define configUSE_MALLOC_FAILED_HOOK    0
 
-	#define configUSE_MALLOC_FAILED_HOOK			1
+/* To test builds that remove the static qualifier for debug builds. */
+    #define portREMOVE_STATIC_QUALIFIER
+#else  /* if ( projCOVERAGE_TEST == 1 ) */
 
-	/* Include the FreeRTOS+Trace FreeRTOS trace macro definitions. */
-	#include "trcRecorder.h"
-#endif
+/* It is a good idea to define configASSERT() while developing.  configASSERT()
+ * uses the same semantics as the standard C assert() macro.  Don't define
+ * configASSERT() when performing code coverage tests though, as it is not
+ * intended to asserts() to fail, some some code is intended not to run if no
+ * errors are present. */
+    #define configASSERT( x )    if( ( x ) == 0 ) vAssertCalled( __FILE__, __LINE__ )
+
+    #define configUSE_MALLOC_FAILED_HOOK    1
+
+/* Include the FreeRTOS+Trace FreeRTOS trace macro definitions. */
+    #include "trcRecorder.h"
+#endif /* if ( projCOVERAGE_TEST == 1 ) */
 
 /* networking definitions */
-#define configMAC_ISR_SIMULATOR_PRIORITY	( configMAX_PRIORITIES - 1 )
+#define configMAC_ISR_SIMULATOR_PRIORITY    ( configMAX_PRIORITIES - 1 )
 
 /* Prototype for the function used to print out.  In this case it prints to the
-console before the network is connected then a UDP port after the network has
-connected. */
-extern void vLoggingPrintf( const char *pcFormatString, ... );
+ * console before the network is connected then a UDP port after the network has
+ * connected. */
+extern void vLoggingPrintf( const char * pcFormatString,
+                            ... );
 
 /* Set to 1 to print out debug messages.  If ipconfigHAS_DEBUG_PRINTF is set to
-1 then FreeRTOS_debug_printf should be defined to the function used to print
-out the debugging messages. */
-#define ipconfigHAS_DEBUG_PRINTF	1
-#if( ipconfigHAS_DEBUG_PRINTF == 1 )
-	#define FreeRTOS_debug_printf(X)	vLoggingPrintf X
+ * 1 then FreeRTOS_debug_printf should be defined to the function used to print
+ * out the debugging messages. */
+#define ipconfigHAS_DEBUG_PRINTF    1
+#if ( ipconfigHAS_DEBUG_PRINTF == 1 )
+    #define FreeRTOS_debug_printf( X )    vLoggingPrintf X
 #endif
 
 /* Set to 1 to print out non debugging messages, for example the output of the
-FreeRTOS_netstat() command, and ping replies.  If ipconfigHAS_PRINTF is set to 1
-then FreeRTOS_printf should be set to the function used to print out the
-messages. */
-#define ipconfigHAS_PRINTF			0
-#if( ipconfigHAS_PRINTF == 1 )
-	#define FreeRTOS_printf(X)			vLoggingPrintf X
+ * FreeRTOS_netstat() command, and ping replies.  If ipconfigHAS_PRINTF is set to 1
+ * then FreeRTOS_printf should be set to the function used to print out the
+ * messages. */
+#define ipconfigHAS_PRINTF    0
+#if ( ipconfigHAS_PRINTF == 1 )
+    #define FreeRTOS_printf( X )    vLoggingPrintf X
 #endif
 #endif /* FREERTOS_CONFIG_H */
diff --git a/FreeRTOS/Demo/Posix_GCC/Makefile b/FreeRTOS/Demo/Posix_GCC/Makefile
index d96573662..d74be3d3c 100644
--- a/FreeRTOS/Demo/Posix_GCC/Makefile
+++ b/FreeRTOS/Demo/Posix_GCC/Makefile
@@ -63,7 +63,7 @@ SOURCE_FILES          += ${FREERTOS_PLUS_DIR}/Source/FreeRTOS-Plus-Trace/streamp
 
 CFLAGS                :=    -ggdb3 -DprojCOVERAGE_TEST=0 -D_WINDOWS_
 LDFLAGS               :=    -ggdb3 -pthread
-CPPFLAGS              :=    $(INCLUDE_DIRS) -DBUILD_DIR=\"$(BUILD_DIR_ABS)\" 
+CPPFLAGS              :=    $(INCLUDE_DIRS) -DBUILD_DIR=\"$(BUILD_DIR_ABS)\"
 
 ifdef PROFILE
   CFLAGS              +=   -pg  -O0
diff --git a/FreeRTOS/Demo/Posix_GCC/Readme.md b/FreeRTOS/Demo/Posix_GCC/Readme.md
index a3bb352b7..95580b64c 100644
--- a/FreeRTOS/Demo/Posix_GCC/Readme.md
+++ b/FreeRTOS/Demo/Posix_GCC/Readme.md
@@ -2,11 +2,11 @@
 
 ## Introduction [(from the official gprof doc)](https://sourceware.org/binutils/docs/gprof/Introduction.html#Introduction)
 Profiling allows you to learn where your program spent its time and which
-functions called which other functions while it was executing. This information
+functions called which other functions while it was executing.  This information
 can show you which pieces of your program are slower than you expected, and
-might be candidates for rewriting to make your program execute faster. It can
+might be candidates for rewriting to make your program execute faster.  It can
 also tell you which functions are being called more or less often than you
-expected. This may help you spot bugs that had otherwise been unnoticed.
+expected.  This may help you spot bugs that had otherwise been unnoticed.
 
 ## Requirements
 ### gprof
@@ -25,26 +25,33 @@ Run your application
 $ ./build/possix_demo
 ```
 Since FreeRTOS and its application never come to an end and typically run
-forever. The user has to kill the application with **Ctrl_C**  when they feel
-satisfied that the application achieved its indented task. Killing the
+forever.  The user has to kill the application with **Ctrl_C**  when they feel
+satisfied that the application achieved its intented task.  Killing the
 application will force the profiling file *gmon.out* to be generated
 automatically.
 In order to make sense of this file, the user has to convert the file with:
 ```
 $ make profile
 ```
-two (2) files *prof_call_graph.txt* and *prof_flat.txt* will be generated in the
-build directory.
+After running the previous command, two (2) profiling files
+*prof_call_graph.txt* and *prof_flat.txt* will be generated and placed in
+the build directory.
+* *prof_call_graph.txt*: The call graph shows which functions called which
+others, and how much time each function used when its subroutine calls are
+included.
+* *prof_flat.txt*: The flat profile shows how much time was spent
+executing directly in each function.
 In order to understand the outputs generated, the best way is to read the
-official documentation of gprof [here](https://sourceware.org/binutils/docs/gprof/Output.html#Output)
+official documentation of gprof
+[here](https://sourceware.org/binutils/docs/gprof/Output.html#Output)
 
 
 # Run your application with Sanitizers
 ## Introduction
-* AddressSanitizer, a fast memory error detector. Memory
+* AddressSanitizer, a fast memory error detector.  Memory
 access instructions are instrumented to detect out-of-bounds and use-after-free
 bugs
-* LeakSanitizer, a memory leak detector. This option only matters for linking of
+* LeakSanitizer, a memory leak detector.  This option only matters for linking of
 executables and the executable is linked against a library that overrides malloc
 and other allocator functions
 
diff --git a/FreeRTOS/Demo/Posix_GCC/code_coverage_additions.c b/FreeRTOS/Demo/Posix_GCC/code_coverage_additions.c
index 05d9c7e66..b78b38819 100644
--- a/FreeRTOS/Demo/Posix_GCC/code_coverage_additions.c
+++ b/FreeRTOS/Demo/Posix_GCC/code_coverage_additions.c
@@ -88,527 +88,557 @@ static BaseType_t prvTimerQuery( void );
 
 static BaseType_t prvStaticAllocationsWithNullBuffers( void )
 {
-uintptr_t ulReturned = 0;
-BaseType_t xReturn = pdPASS;
-UBaseType_t uxDummy = 10;
-
-	/* Don't expect to create any of the objects as a NULL parameter is always
-	passed in place of a required buffer.  Hence if all passes then none of the
-	|= will be against 0, and ulReturned will still be zero at the end of this
-	function. */
-	ulReturned |= ( uintptr_t ) xEventGroupCreateStatic( NULL );
-
-	/* Try creating a task twice, once with puxStackBuffer NULL, and once with
-	pxTaskBuffer NULL. */
-	ulReturned |= ( uintptr_t ) xTaskCreateStatic( NULL, /* Task to run, not needed as the task is not created. */
-											   	  "Dummy", /* Task name. */
-												  configMINIMAL_STACK_SIZE,
-												  NULL,
-												  tskIDLE_PRIORITY,
-												  NULL,
-												  ( StaticTask_t * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
-
-	ulReturned |= ( uintptr_t ) xTaskCreateStatic( NULL, /* Task to run, not needed as the task is not created. */
-											   	  "Dummy", /* Task name. */
-												  configMINIMAL_STACK_SIZE,
-												  NULL,
-												  tskIDLE_PRIORITY,
-												  ( StackType_t  * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
-												  NULL );
-
-	ulReturned |= ( uintptr_t ) xQueueCreateStatic( uxDummy,
-												   uxDummy,
-												   ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
-												   NULL );
-
-	/* Try creating a stream buffer twice, once with pucStreamBufferStorageArea
-	set to NULL, and once with pxStaticStreamBuffer set to NULL. */
-	ulReturned |= ( uintptr_t ) xStreamBufferCreateStatic( uxDummy,
-														  uxDummy,
-														  NULL,
-														  ( StaticStreamBuffer_t  * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
-
-	ulReturned |= ( uintptr_t ) xStreamBufferCreateStatic( uxDummy,
-														  uxDummy,
-														  ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
-														  NULL );
-
-	if( ulReturned != 0 )
-	{
-		/* Something returned a non-NULL value. */
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    uintptr_t ulReturned = 0;
+    BaseType_t xReturn = pdPASS;
+    UBaseType_t uxDummy = 10;
+
+    /* Don't expect to create any of the objects as a NULL parameter is always
+     * passed in place of a required buffer.  Hence if all passes then none of the
+     |= will be against 0, and ulReturned will still be zero at the end of this
+     * function. */
+    ulReturned |= ( uintptr_t ) xEventGroupCreateStatic( NULL );
+
+    /* Try creating a task twice, once with puxStackBuffer NULL, and once with
+     * pxTaskBuffer NULL. */
+    ulReturned |= ( uintptr_t ) xTaskCreateStatic( NULL,    /* Task to run, not needed as the task is not created. */
+                                                   "Dummy", /* Task name. */
+                                                   configMINIMAL_STACK_SIZE,
+                                                   NULL,
+                                                   tskIDLE_PRIORITY,
+                                                   NULL,
+                                                   ( StaticTask_t * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
+
+    ulReturned |= ( uintptr_t ) xTaskCreateStatic( NULL,                          /* Task to run, not needed as the task is not created. */
+                                                   "Dummy",                       /* Task name. */
+                                                   configMINIMAL_STACK_SIZE,
+                                                   NULL,
+                                                   tskIDLE_PRIORITY,
+                                                   ( StackType_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+                                                   NULL );
+
+    ulReturned |= ( uintptr_t ) xQueueCreateStatic( uxDummy,
+                                                    uxDummy,
+                                                    ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+                                                    NULL );
+
+    /* Try creating a stream buffer twice, once with pucStreamBufferStorageArea
+     * set to NULL, and once with pxStaticStreamBuffer set to NULL. */
+    ulReturned |= ( uintptr_t ) xStreamBufferCreateStatic( uxDummy,
+                                                           uxDummy,
+                                                           NULL,
+                                                           ( StaticStreamBuffer_t * ) &xReturn ); /* Dummy value just to pass a non NULL value in - won't get used. */
+
+    ulReturned |= ( uintptr_t ) xStreamBufferCreateStatic( uxDummy,
+                                                           uxDummy,
+                                                           ( uint8_t * ) &xReturn, /* Dummy value just to pass a non NULL value in - won't get used. */
+                                                           NULL );
+
+    if( ulReturned != 0 )
+    {
+        /* Something returned a non-NULL value. */
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvTraceUtils( void )
 {
-EventGroupHandle_t xEventGroup;
-QueueHandle_t xQueue;
-BaseType_t xReturn = pdPASS;
-const UBaseType_t xNumber = ( UBaseType_t ) 100, xQueueLength = ( UBaseType_t ) 1;
-UBaseType_t uxValue;
-TaskHandle_t xTaskHandle;
-StreamBufferHandle_t xStreamBuffer;
-MessageBufferHandle_t xMessageBuffer;
-
-	/* Exercise the event group trace utilities. */
-	xEventGroup = xEventGroupCreate();
-
-	if( xEventGroup != NULL )
-	{
-		vEventGroupSetNumber( xEventGroup, xNumber );
-		if( uxEventGroupGetNumber( NULL ) != 0 )
-		{
-			xReturn = pdFAIL;
-		}
-		if( uxEventGroupGetNumber( xEventGroup ) != xNumber )
-		{
-			xReturn = pdFAIL;
-		}
-
-		vEventGroupDelete( xEventGroup );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Exercise the queue trace utilities. */
-	xQueue = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( uxValue ) );
-	if( xQueue != NULL )
-	{
-		vQueueSetQueueNumber( xQueue, xNumber );
-		if( uxQueueGetQueueNumber( xQueue ) != xNumber )
-		{
-			xReturn = pdFAIL;
-		}
-		if( ucQueueGetQueueType( xQueue ) != queueQUEUE_TYPE_BASE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		vQueueDelete( xQueue );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Exercise the task trace utilities.  Value of 100 is arbitrary, just want
-	to check the value that is set is also read back. */
-	uxValue = 100;
-	xTaskHandle = xTaskGetCurrentTaskHandle();
-	vTaskSetTaskNumber( xTaskHandle, uxValue );
-	if( uxTaskGetTaskNumber( xTaskHandle ) != uxValue )
-	{
-		xReturn = pdFAIL;
-	}
-	if( uxTaskGetTaskNumber( NULL ) != 0 )
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Timer trace util functions are exercised in prvTimerQuery(). */
-
-
-	/* Exercise the stream buffer utilities.  Try creating with a trigger level
-	of 0, it should then get capped to 1. */
-	xStreamBuffer = xStreamBufferCreate( sizeof( uint32_t ), 0 );
-	if( xStreamBuffer != NULL )
-	{
-		vStreamBufferSetStreamBufferNumber( xStreamBuffer, uxValue );
-		if( uxStreamBufferGetStreamBufferNumber( xStreamBuffer ) != uxValue )
-		{
-			xReturn = pdFALSE;
-		}
-		if( ucStreamBufferGetStreamBufferType( xStreamBuffer ) != 0 )
-		{
-			/* "Is Message Buffer" flag should have been 0. */
-			xReturn = pdFALSE;
-		}
-
-		vStreamBufferDelete( xStreamBuffer );
-	}
-	else
-	{
-		xReturn = pdFALSE;
-	}
-
-	xMessageBuffer = xMessageBufferCreate( sizeof( uint32_t ) );
-	if( xMessageBuffer != NULL )
-	{
-		if( ucStreamBufferGetStreamBufferType( xMessageBuffer ) == 0 )
-		{
-			/* "Is Message Buffer" flag should have been 1. */
-			xReturn = pdFALSE;
-		}
-
-		vMessageBufferDelete( xMessageBuffer );
-	}
-	else
-	{
-		xReturn = pdFALSE;
-	}
-
-	return xReturn;
+    EventGroupHandle_t xEventGroup;
+    QueueHandle_t xQueue;
+    BaseType_t xReturn = pdPASS;
+    const UBaseType_t xNumber = ( UBaseType_t ) 100, xQueueLength = ( UBaseType_t ) 1;
+    UBaseType_t uxValue;
+    TaskHandle_t xTaskHandle;
+    StreamBufferHandle_t xStreamBuffer;
+    MessageBufferHandle_t xMessageBuffer;
+
+    /* Exercise the event group trace utilities. */
+    xEventGroup = xEventGroupCreate();
+
+    if( xEventGroup != NULL )
+    {
+        vEventGroupSetNumber( xEventGroup, xNumber );
+
+        if( uxEventGroupGetNumber( NULL ) != 0 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( uxEventGroupGetNumber( xEventGroup ) != xNumber )
+        {
+            xReturn = pdFAIL;
+        }
+
+        vEventGroupDelete( xEventGroup );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Exercise the queue trace utilities. */
+    xQueue = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( uxValue ) );
+
+    if( xQueue != NULL )
+    {
+        vQueueSetQueueNumber( xQueue, xNumber );
+
+        if( uxQueueGetQueueNumber( xQueue ) != xNumber )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( ucQueueGetQueueType( xQueue ) != queueQUEUE_TYPE_BASE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        vQueueDelete( xQueue );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Exercise the task trace utilities.  Value of 100 is arbitrary, just want
+     * to check the value that is set is also read back. */
+    uxValue = 100;
+    xTaskHandle = xTaskGetCurrentTaskHandle();
+    vTaskSetTaskNumber( xTaskHandle, uxValue );
+
+    if( uxTaskGetTaskNumber( xTaskHandle ) != uxValue )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( uxTaskGetTaskNumber( NULL ) != 0 )
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Timer trace util functions are exercised in prvTimerQuery(). */
+
+
+    /* Exercise the stream buffer utilities.  Try creating with a trigger level
+     * of 0, it should then get capped to 1. */
+    xStreamBuffer = xStreamBufferCreate( sizeof( uint32_t ), 0 );
+
+    if( xStreamBuffer != NULL )
+    {
+        vStreamBufferSetStreamBufferNumber( xStreamBuffer, uxValue );
+
+        if( uxStreamBufferGetStreamBufferNumber( xStreamBuffer ) != uxValue )
+        {
+            xReturn = pdFALSE;
+        }
+
+        if( ucStreamBufferGetStreamBufferType( xStreamBuffer ) != 0 )
+        {
+            /* "Is Message Buffer" flag should have been 0. */
+            xReturn = pdFALSE;
+        }
+
+        vStreamBufferDelete( xStreamBuffer );
+    }
+    else
+    {
+        xReturn = pdFALSE;
+    }
+
+    xMessageBuffer = xMessageBufferCreate( sizeof( uint32_t ) );
+
+    if( xMessageBuffer != NULL )
+    {
+        if( ucStreamBufferGetStreamBufferType( xMessageBuffer ) == 0 )
+        {
+            /* "Is Message Buffer" flag should have been 1. */
+            xReturn = pdFALSE;
+        }
+
+        vMessageBufferDelete( xMessageBuffer );
+    }
+    else
+    {
+        xReturn = pdFALSE;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvPeekTimeout( void )
 {
-QueueHandle_t xHandle;
-const UBaseType_t xQueueLength = 1;
-BaseType_t xReturn = pdPASS;
-TickType_t xBlockTime = ( TickType_t ) 2;
-UBaseType_t uxReceived;
-
-	/* Create the queue just to try peeking it while it is empty. */
-	xHandle = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( xQueueLength ) );
-
-	if( xHandle != NULL )
-	{
-		if( uxQueueMessagesWaiting( xHandle ) != 0 )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Ensure peeking from the queue times out as the queue is empty. */
-		if( xQueuePeek( xHandle, &uxReceived, xBlockTime ) != pdFALSE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		vQueueDelete( xHandle );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    QueueHandle_t xHandle;
+    const UBaseType_t xQueueLength = 1;
+    BaseType_t xReturn = pdPASS;
+    TickType_t xBlockTime = ( TickType_t ) 2;
+    UBaseType_t uxReceived;
+
+    /* Create the queue just to try peeking it while it is empty. */
+    xHandle = xQueueCreate( xQueueLength, ( UBaseType_t ) sizeof( xQueueLength ) );
+
+    if( xHandle != NULL )
+    {
+        if( uxQueueMessagesWaiting( xHandle ) != 0 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Ensure peeking from the queue times out as the queue is empty. */
+        if( xQueuePeek( xHandle, &uxReceived, xBlockTime ) != pdFALSE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        vQueueDelete( xHandle );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvQueueQueryFromISR( void )
 {
-BaseType_t xReturn = pdPASS, xValue = 1;
-const UBaseType_t xISRQueueLength = ( UBaseType_t ) 1;
-const char *pcISRQueueName = "ISRQueue";
-QueueHandle_t xISRQueue = NULL;
-
-	xISRQueue = xQueueCreate( xISRQueueLength, ( UBaseType_t ) sizeof( BaseType_t ) );
-
-	if( xISRQueue != NULL )
-	{
-		vQueueAddToRegistry( xISRQueue, pcISRQueueName );
-		if( strcmp( pcQueueGetName( xISRQueue ), pcISRQueueName ) )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Expect the queue to be empty here. */
-		if(	uxQueueMessagesWaitingFromISR( xISRQueue ) != 0 )
-		{
-			xReturn = pdFAIL;
-		}
-
-		if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdTRUE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		if( xQueueIsQueueFullFromISR( xISRQueue ) != pdFALSE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Now fill the queue - it only has one space. */
-		if( xQueueSendFromISR( xISRQueue, &xValue, NULL ) != pdPASS )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Check it now reports as full. */
-		if(	uxQueueMessagesWaitingFromISR( xISRQueue ) != 1 )
-		{
-			xReturn = pdFAIL;
-		}
-
-		if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdFALSE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		if( xQueueIsQueueFullFromISR( xISRQueue ) != pdTRUE )
-		{
-			xReturn = pdFAIL;
-		}
-
-		vQueueDelete( xISRQueue );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    BaseType_t xReturn = pdPASS, xValue = 1;
+    const UBaseType_t xISRQueueLength = ( UBaseType_t ) 1;
+    const char * pcISRQueueName = "ISRQueue";
+    QueueHandle_t xISRQueue = NULL;
+
+    xISRQueue = xQueueCreate( xISRQueueLength, ( UBaseType_t ) sizeof( BaseType_t ) );
+
+    if( xISRQueue != NULL )
+    {
+        vQueueAddToRegistry( xISRQueue, pcISRQueueName );
+
+        if( strcmp( pcQueueGetName( xISRQueue ), pcISRQueueName ) )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Expect the queue to be empty here. */
+        if( uxQueueMessagesWaitingFromISR( xISRQueue ) != 0 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdTRUE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xQueueIsQueueFullFromISR( xISRQueue ) != pdFALSE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Now fill the queue - it only has one space. */
+        if( xQueueSendFromISR( xISRQueue, &xValue, NULL ) != pdPASS )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Check it now reports as full. */
+        if( uxQueueMessagesWaitingFromISR( xISRQueue ) != 1 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xQueueIsQueueEmptyFromISR( xISRQueue ) != pdFALSE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xQueueIsQueueFullFromISR( xISRQueue ) != pdTRUE )
+        {
+            xReturn = pdFAIL;
+        }
+
+        vQueueDelete( xISRQueue );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvTaskQueryFunctions( void )
 {
-static TaskStatus_t xStatus, *pxStatusArray;
-TaskHandle_t xTimerTask, xIdleTask;
-BaseType_t xReturn = pdPASS;
-UBaseType_t uxNumberOfTasks, uxReturned, ux;
-uint32_t ulTotalRunTime1, ulTotalRunTime2;
-const uint32_t ulRunTimeTollerance = ( uint32_t ) 0xfff;
-
-	/* Obtain task status with the stack high water mark and without the
-	state. */
-	vTaskGetInfo( NULL, &xStatus, pdTRUE, eRunning );
-
-	if( uxTaskGetStackHighWaterMark( NULL ) != xStatus.usStackHighWaterMark )
-	{
-		xReturn = pdFAIL;
-	}
-
-	if( uxTaskGetStackHighWaterMark2( NULL ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Now obtain a task status without the high water mark but with the state,
-	which in the case of the idle task should be Read. */
-	xTimerTask = xTimerGetTimerDaemonTaskHandle();
-	vTaskSuspend( xTimerTask ); /* Should never suspend Timer task normally!. */
-	vTaskGetInfo( xTimerTask, &xStatus, pdFALSE, eInvalid );
-	if( xStatus.eCurrentState != eSuspended )
-	{
-		xReturn = pdFAIL;
-	}
-	if( xStatus.uxBasePriority != uxTaskPriorityGetFromISR( xTimerTask ) )
-	{
-		xReturn = pdFAIL;
-	}
-	if( xStatus.uxBasePriority != ( configMAX_PRIORITIES - 1 ) )
-	{
-		xReturn = pdFAIL;
-	}
-	xTaskResumeFromISR( xTimerTask );
-	vTaskGetInfo( xTimerTask, &xStatus, pdTRUE, eInvalid );
-	if( ( xStatus.eCurrentState != eReady ) && ( xStatus.eCurrentState != eBlocked ) )
-	{
-		xReturn = pdFAIL;
-	}
-	if( uxTaskGetStackHighWaterMark( xTimerTask ) != xStatus.usStackHighWaterMark )
-	{
-		xReturn = pdFAIL;
-	}
-	if( uxTaskGetStackHighWaterMark2( xTimerTask ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Attempting to abort a delay in the idle task should be guaranteed to
-	fail as the idle task should never block. */
-	xIdleTask = xTaskGetIdleTaskHandle();
-	if( xTaskAbortDelay( xIdleTask ) != pdFAIL )
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Create an array of task status objects large enough to hold information
-	on the number of tasks at this time - note this may change at any time if
-	higher priority tasks are executing and creating tasks. */
-	uxNumberOfTasks = uxTaskGetNumberOfTasks();
-	pxStatusArray = ( TaskStatus_t * ) pvPortMalloc( uxNumberOfTasks * sizeof( TaskStatus_t ) );
-
-	if( pxStatusArray != NULL )
-	{
-		/* Pass part of the array into uxTaskGetSystemState() to ensure it doesn't
-		try using more space than there is available. */
-		uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks / ( UBaseType_t ) 2, NULL );
-		if( uxReturned != ( UBaseType_t ) 0 )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Now do the same but passing in the complete array size, this is done
-		twice to check for a difference in the total run time. */
-		uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime1 );
-		memset( ( void * ) pxStatusArray, 0xaa, uxNumberOfTasks * sizeof( TaskStatus_t ) );
-		uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime2 );
-		if( ( ulTotalRunTime2 - ulTotalRunTime1 ) > ulRunTimeTollerance )
-		{
-			xReturn = pdFAIL;
-		}
-
-		/* Basic santity check of array contents. */
-		for( ux = 0; ux < uxReturned; ux++ )
-		{
-			if( pxStatusArray[ ux ].eCurrentState >= ( UBaseType_t ) eInvalid )
-			{
-				xReturn = pdFAIL;
-			}
-			if( pxStatusArray[ ux ].uxCurrentPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
-			{
-				xReturn = pdFAIL;
-			}
-		}
-
-		vPortFree( pxStatusArray );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    static TaskStatus_t xStatus, * pxStatusArray;
+    TaskHandle_t xTimerTask, xIdleTask;
+    BaseType_t xReturn = pdPASS;
+    UBaseType_t uxNumberOfTasks, uxReturned, ux;
+    uint32_t ulTotalRunTime1, ulTotalRunTime2;
+    const uint32_t ulRunTimeTollerance = ( uint32_t ) 0xfff;
+
+    /* Obtain task status with the stack high water mark and without the
+     * state. */
+    vTaskGetInfo( NULL, &xStatus, pdTRUE, eRunning );
+
+    if( uxTaskGetStackHighWaterMark( NULL ) != xStatus.usStackHighWaterMark )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( uxTaskGetStackHighWaterMark2( NULL ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Now obtain a task status without the high water mark but with the state,
+     * which in the case of the idle task should be Read. */
+    xTimerTask = xTimerGetTimerDaemonTaskHandle();
+    vTaskSuspend( xTimerTask ); /* Should never suspend Timer task normally!. */
+    vTaskGetInfo( xTimerTask, &xStatus, pdFALSE, eInvalid );
+
+    if( xStatus.eCurrentState != eSuspended )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( xStatus.uxBasePriority != uxTaskPriorityGetFromISR( xTimerTask ) )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( xStatus.uxBasePriority != ( configMAX_PRIORITIES - 1 ) )
+    {
+        xReturn = pdFAIL;
+    }
+
+    xTaskResumeFromISR( xTimerTask );
+    vTaskGetInfo( xTimerTask, &xStatus, pdTRUE, eInvalid );
+
+    if( ( xStatus.eCurrentState != eReady ) && ( xStatus.eCurrentState != eBlocked ) )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( uxTaskGetStackHighWaterMark( xTimerTask ) != xStatus.usStackHighWaterMark )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( uxTaskGetStackHighWaterMark2( xTimerTask ) != ( configSTACK_DEPTH_TYPE ) xStatus.usStackHighWaterMark )
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Attempting to abort a delay in the idle task should be guaranteed to
+     * fail as the idle task should never block. */
+    xIdleTask = xTaskGetIdleTaskHandle();
+
+    if( xTaskAbortDelay( xIdleTask ) != pdFAIL )
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Create an array of task status objects large enough to hold information
+     * on the number of tasks at this time - note this may change at any time if
+     * higher priority tasks are executing and creating tasks. */
+    uxNumberOfTasks = uxTaskGetNumberOfTasks();
+    pxStatusArray = ( TaskStatus_t * ) pvPortMalloc( uxNumberOfTasks * sizeof( TaskStatus_t ) );
+
+    if( pxStatusArray != NULL )
+    {
+        /* Pass part of the array into uxTaskGetSystemState() to ensure it doesn't
+         * try using more space than there is available. */
+        uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks / ( UBaseType_t ) 2, NULL );
+
+        if( uxReturned != ( UBaseType_t ) 0 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Now do the same but passing in the complete array size, this is done
+         * twice to check for a difference in the total run time. */
+        uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime1 );
+        memset( ( void * ) pxStatusArray, 0xaa, uxNumberOfTasks * sizeof( TaskStatus_t ) );
+        uxReturned = uxTaskGetSystemState( pxStatusArray, uxNumberOfTasks, &ulTotalRunTime2 );
+
+        if( ( ulTotalRunTime2 - ulTotalRunTime1 ) > ulRunTimeTollerance )
+        {
+            xReturn = pdFAIL;
+        }
+
+        /* Basic santity check of array contents. */
+        for( ux = 0; ux < uxReturned; ux++ )
+        {
+            if( pxStatusArray[ ux ].eCurrentState >= ( UBaseType_t ) eInvalid )
+            {
+                xReturn = pdFAIL;
+            }
+
+            if( pxStatusArray[ ux ].uxCurrentPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
+            {
+                xReturn = pdFAIL;
+            }
+        }
+
+        vPortFree( pxStatusArray );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
-static BaseType_t prvDummyTagFunction( void *pvParameter )
+static BaseType_t prvDummyTagFunction( void * pvParameter )
 {
-	return ( BaseType_t ) pvParameter;
+    return ( BaseType_t ) pvParameter;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvTaskTags( void )
 {
-BaseType_t xReturn = pdPASS, xParameter = ( BaseType_t ) 0xDEADBEEF;
-TaskHandle_t xTask;
-
-	/* First try with the handle of a different task.  Use the timer task for
-	convenience. */
-	xTask = xTimerGetTimerDaemonTaskHandle();
-
-	vTaskSetApplicationTaskTag( xTask, prvDummyTagFunction );
-	if( xTaskGetApplicationTaskTag( xTask ) != prvDummyTagFunction )
-	{
-		xReturn = pdFAIL;
-	}
-	else
-	{
-		if( xTaskCallApplicationTaskHook( xTask, ( void * ) xParameter ) != xParameter )
-		{
-			xReturn = pdFAIL;
-		}
-		if( xTaskCallApplicationTaskHook( xTask, ( void * ) NULL ) != pdFAIL )
-		{
-			xReturn = pdFAIL;
-		}
-	}
-
-	/* Try FromISR version too. */
-	if( xTaskGetApplicationTaskTagFromISR( xTask ) != prvDummyTagFunction )
-	{
-		xReturn = pdFAIL;
-	}
-
-	/* Now try with a NULL handle, so using this task. */
-	vTaskSetApplicationTaskTag( NULL, NULL );
-	if( xTaskGetApplicationTaskTag( NULL ) != NULL )
-	{
-		xReturn = pdFAIL;
-	}
-	if( xTaskGetApplicationTaskTagFromISR( NULL ) != NULL )
-	{
-		xReturn = pdFAIL;
-	}
-
-	vTaskSetApplicationTaskTag( NULL, prvDummyTagFunction );
-	if( xTaskGetApplicationTaskTag( NULL ) != prvDummyTagFunction )
-	{
-		xReturn = pdFAIL;
-	}
-	else
-	{
-		if( xTaskCallApplicationTaskHook( NULL, ( void * ) xParameter ) != xParameter )
-		{
-			xReturn = pdFAIL;
-		}
-		if( xTaskCallApplicationTaskHook( NULL, ( void * ) NULL ) != pdFAIL )
-		{
-			xReturn = pdFAIL;
-		}
-	}
-
-	/* Try FromISR version too. */
-	if( xTaskGetApplicationTaskTagFromISR( NULL ) != prvDummyTagFunction )
-	{
-		xReturn = pdFAIL;
-	}
-
-	vTaskSetApplicationTaskTag( NULL, NULL );
-	if( xTaskGetApplicationTaskTag( NULL ) != NULL )
-	{
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    BaseType_t xReturn = pdPASS, xParameter = ( BaseType_t ) 0xDEADBEEF;
+    TaskHandle_t xTask;
+
+    /* First try with the handle of a different task.  Use the timer task for
+     * convenience. */
+    xTask = xTimerGetTimerDaemonTaskHandle();
+
+    vTaskSetApplicationTaskTag( xTask, prvDummyTagFunction );
+
+    if( xTaskGetApplicationTaskTag( xTask ) != prvDummyTagFunction )
+    {
+        xReturn = pdFAIL;
+    }
+    else
+    {
+        if( xTaskCallApplicationTaskHook( xTask, ( void * ) xParameter ) != xParameter )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xTaskCallApplicationTaskHook( xTask, ( void * ) NULL ) != pdFAIL )
+        {
+            xReturn = pdFAIL;
+        }
+    }
+
+    /* Try FromISR version too. */
+    if( xTaskGetApplicationTaskTagFromISR( xTask ) != prvDummyTagFunction )
+    {
+        xReturn = pdFAIL;
+    }
+
+    /* Now try with a NULL handle, so using this task. */
+    vTaskSetApplicationTaskTag( NULL, NULL );
+
+    if( xTaskGetApplicationTaskTag( NULL ) != NULL )
+    {
+        xReturn = pdFAIL;
+    }
+
+    if( xTaskGetApplicationTaskTagFromISR( NULL ) != NULL )
+    {
+        xReturn = pdFAIL;
+    }
+
+    vTaskSetApplicationTaskTag( NULL, prvDummyTagFunction );
+
+    if( xTaskGetApplicationTaskTag( NULL ) != prvDummyTagFunction )
+    {
+        xReturn = pdFAIL;
+    }
+    else
+    {
+        if( xTaskCallApplicationTaskHook( NULL, ( void * ) xParameter ) != xParameter )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( xTaskCallApplicationTaskHook( NULL, ( void * ) NULL ) != pdFAIL )
+        {
+            xReturn = pdFAIL;
+        }
+    }
+
+    /* Try FromISR version too. */
+    if( xTaskGetApplicationTaskTagFromISR( NULL ) != prvDummyTagFunction )
+    {
+        xReturn = pdFAIL;
+    }
+
+    vTaskSetApplicationTaskTag( NULL, NULL );
+
+    if( xTaskGetApplicationTaskTag( NULL ) != NULL )
+    {
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 static BaseType_t prvTimerQuery( void )
 {
-TimerHandle_t xTimer;
-BaseType_t xReturn = pdPASS;
-const char *pcTimerName = "TestTimer";
-const TickType_t xTimerPeriod = ( TickType_t ) 100;
-const UBaseType_t uxTimerNumber = ( UBaseType_t ) 55;
-
-	xTimer = xTimerCreate(  pcTimerName,
-							xTimerPeriod,
-							pdFALSE,
-							( void * ) xTimerPeriod,
-							NULL ); /* Not actually going to start timer so NULL callback is ok. */
-
-	if( xTimer != NULL )
-	{
-		if( xTimerGetPeriod( xTimer ) != xTimerPeriod )
-		{
-			xReturn = pdFAIL;
-		}
-
-		if( strcmp( pcTimerGetName( xTimer ), pcTimerName ) != 0 )
-		{
-			xReturn = pdFAIL;
-		}
-
-		vTimerSetTimerNumber( xTimer, uxTimerNumber );
-		if( uxTimerGetTimerNumber( xTimer ) != uxTimerNumber )
-		{
-			xReturn = pdFAIL;
-		}
-
-		xTimerDelete( xTimer, portMAX_DELAY );
-	}
-	else
-	{
-		xReturn = pdFAIL;
-	}
-
-	return xReturn;
+    TimerHandle_t xTimer;
+    BaseType_t xReturn = pdPASS;
+    const char * pcTimerName = "TestTimer";
+    const TickType_t xTimerPeriod = ( TickType_t ) 100;
+    const UBaseType_t uxTimerNumber = ( UBaseType_t ) 55;
+
+    xTimer = xTimerCreate( pcTimerName,
+                           xTimerPeriod,
+                           pdFALSE,
+                           ( void * ) xTimerPeriod,
+                           NULL );  /* Not actually going to start timer so NULL callback is ok. */
+
+    if( xTimer != NULL )
+    {
+        if( xTimerGetPeriod( xTimer ) != xTimerPeriod )
+        {
+            xReturn = pdFAIL;
+        }
+
+        if( strcmp( pcTimerGetName( xTimer ), pcTimerName ) != 0 )
+        {
+            xReturn = pdFAIL;
+        }
+
+        vTimerSetTimerNumber( xTimer, uxTimerNumber );
+
+        if( uxTimerGetTimerNumber( xTimer ) != uxTimerNumber )
+        {
+            xReturn = pdFAIL;
+        }
+
+        xTimerDelete( xTimer, portMAX_DELAY );
+    }
+    else
+    {
+        xReturn = pdFAIL;
+    }
+
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 BaseType_t xRunCodeCoverageTestAdditions( void )
 {
-BaseType_t xReturn = pdPASS;
+    BaseType_t xReturn = pdPASS;
 
-	xReturn &= prvStaticAllocationsWithNullBuffers();
-	xReturn &= prvTraceUtils();
-	xReturn &= prvPeekTimeout();
-	xReturn &= prvQueueQueryFromISR();
-	xReturn &= prvTaskQueryFunctions();
-	xReturn &= prvTaskTags();
-	xReturn &= prvTimerQuery();
+    xReturn &= prvStaticAllocationsWithNullBuffers();
+    xReturn &= prvTraceUtils();
+    xReturn &= prvPeekTimeout();
+    xReturn &= prvQueueQueryFromISR();
+    xReturn &= prvTaskQueryFunctions();
+    xReturn &= prvTaskTags();
+    xReturn &= prvTimerQuery();
 
-	return xReturn;
+    return xReturn;
 }
 /*-----------------------------------------------------------*/
-
diff --git a/FreeRTOS/Demo/Posix_GCC/console.c b/FreeRTOS/Demo/Posix_GCC/console.c
index abd0618ae..77da6aa95 100644
--- a/FreeRTOS/Demo/Posix_GCC/console.c
+++ b/FreeRTOS/Demo/Posix_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/Posix_GCC/console.h b/FreeRTOS/Demo/Posix_GCC/console.h
index 99fb56ed5..a8ec6bcff 100644
--- a/FreeRTOS/Demo/Posix_GCC/console.h
+++ b/FreeRTOS/Demo/Posix_GCC/console.h
@@ -25,21 +25,22 @@
  */
 
 #ifndef CONSOLE_H
-#define CONSOLE_H
+    #define CONSOLE_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+    #ifdef __cplusplus
+        extern "C" {
+    #endif
 
 /*-----------------------------------------------------------
- * 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,
+                        ... );
 
-#ifdef __cplusplus
-}
-#endif
+    #ifdef __cplusplus
+        }
+    #endif
 
 #endif /* CONSOLE_H */
diff --git a/FreeRTOS/Demo/Posix_GCC/main.c b/FreeRTOS/Demo/Posix_GCC/main.c
index 8f1fd8aa6..cf910096d 100644
--- a/FreeRTOS/Demo/Posix_GCC/main.c
+++ b/FreeRTOS/Demo/Posix_GCC/main.c
@@ -65,15 +65,15 @@
 /* Local includes. */
 #include "console.h"
 
-#define    BLINKY_DEMO       0
-#define    FULL_DEMO         1
+#define    BLINKY_DEMO              0
+#define    FULL_DEMO                1
 
-#define mainSELECTED_APPLICATION BLINKY_DEMO
+#define mainSELECTED_APPLICATION    BLINKY_DEMO
 
 #ifdef BUILD_DIR
-    #define BUILD BUILD_DIR
+    #define BUILD                   BUILD_DIR
 #else
-    #define BUILD "./"
+    #define BUILD                   "./"
 #endif
 
 /* This demo uses heap_3.c (the libc provided malloc() and free()). */
@@ -82,6 +82,7 @@
 extern void main_blinky( void );
 extern void main_full( void );
 static void traceOnEnter( void );
+
 /*
  * Only the comprehensive demo uses application hook (callback) functions.  See
  * http://www.freertos.org/a00016.html for more information.
@@ -96,14 +97,14 @@ void vFullDemoIdleFunction( void );
 void vApplicationMallocFailedHook( void );
 void vApplicationIdleHook( void );
 void vApplicationStackOverflowHook( TaskHandle_t pxTask,
-                                    char *pcTaskName );
+                                    char * pcTaskName );
 void vApplicationTickHook( void );
-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 vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
+                                     StackType_t ** ppxTimerTaskStackBuffer,
+                                     uint32_t * pulTimerTaskStackSize );
 
 /*
  * Writes trace data to a disk file when the trace recording is stopped.
@@ -115,15 +116,15 @@ static void prvSaveTraceFile( void );
  * Signal handler for Ctrl_C to cause the program to exit, and generate the
  * profiling info.
  */
-static void handle_sigint(int signal);
+static void handle_sigint( int signal );
 
 /*-----------------------------------------------------------*/
 
 /* When configSUPPORT_STATIC_ALLOCATION is set to 1 the application writer can
-use a callback function to optionally provide the memory required by the idle
-and timer tasks.  This is the stack that will be used by the timer task.  It is
-declared here, as a global, so it can be checked by a test that is implemented
-in a different file. */
+ * use a callback function to optionally provide the memory required by the idle
+ * and timer tasks.  This is the stack that will be used by the timer task.  It is
+ * declared here, as a global, so it can be checked by a test that is implemented
+ * in a different file. */
 StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
 
 /* Notes if the trace is running or not. */
@@ -140,34 +141,34 @@ int main( void )
 
     /* Do not include trace code when performing a code coverage analysis. */
     #if ( projCOVERAGE_TEST != 1 )
-    {
-        /* Initialise the trace recorder.  Use of the trace recorder is optional.
-        See http://www.FreeRTOS.org/trace for more information. */
-        vTraceEnable( TRC_START );
-
-        /* Start the trace recording - the recording is written to a file if
-        configASSERT() is called. */
-        printf( "\r\nTrace started.\r\nThe trace will be dumped to disk if a call to configASSERT() fails.\r\n" );
-        printf( "\r\nThe trace will be dumped to disk if Enter is hit.\r\n" );
-        uiTraceStart();
-    }
+        {
+            /* Initialise the trace recorder.  Use of the trace recorder is optional.
+             * See http://www.FreeRTOS.org/trace for more information. */
+            vTraceEnable( TRC_START );
+
+            /* Start the trace recording - the recording is written to a file if
+             * configASSERT() is called. */
+            printf( "\r\nTrace started.\r\nThe trace will be dumped to disk if a call to configASSERT() fails.\r\n" );
+            printf( "\r\nThe trace will be dumped to disk if Enter is hit.\r\n" );
+            uiTraceStart();
+        }
     #endif
 
     console_init();
     #if ( mainSELECTED_APPLICATION == BLINKY_DEMO )
-    {
-        console_print("Starting echo blinky demo\n");
-        main_blinky();
-    }
-    #elif ( mainSELECTED_APPLICATION == FULL_DEMO)
-    {
-        console_print("Starting full demo\n");
-        main_full();
-    }
+        {
+            console_print( "Starting echo blinky demo\n" );
+            main_blinky();
+        }
+    #elif ( mainSELECTED_APPLICATION == FULL_DEMO )
+        {
+            console_print( "Starting full demo\n" );
+            main_full();
+        }
     #else
-    {
-        #error "The selected demo is not valid"
-    }
+        {
+            #error "The selected demo is not valid"
+        }
     #endif /* if ( mainSELECTED_APPLICATION ) */
 
     return 0;
@@ -177,17 +178,17 @@ int main( void )
 void vApplicationMallocFailedHook( void )
 {
     /* vApplicationMallocFailedHook() will only be called if
-    configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h.  It is a hook
-    function that will get called if a call to pvPortMalloc() fails.
-    pvPortMalloc() is called internally by the kernel whenever a task, queue,
-    timer or semaphore is created.  It is also called by various parts of the
-    demo application.  If heap_1.c, heap_2.c or heap_4.c is being used, then the
-    size of the    heap available to pvPortMalloc() is defined by
-    configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize()
-    API function can be used to query the size of free heap space that remains
-    (although it does not provide information on how the remaining heap might be
-    fragmented).  See http://www.freertos.org/a00111.html for more
-    information. */
+     * configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h.  It is a hook
+     * function that will get called if a call to pvPortMalloc() fails.
+     * pvPortMalloc() is called internally by the kernel whenever a task, queue,
+     * timer or semaphore is created.  It is also called by various parts of the
+     * demo application.  If heap_1.c, heap_2.c or heap_4.c is being used, then the
+     * size of the    heap available to pvPortMalloc() is defined by
+     * configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize()
+     * API function can be used to query the size of free heap space that remains
+     * (although it does not provide information on how the remaining heap might be
+     * fragmented).  See http://www.freertos.org/a00111.html for more
+     * information. */
     vAssertCalled( __FILE__, __LINE__ );
 }
 /*-----------------------------------------------------------*/
@@ -195,40 +196,40 @@ void vApplicationMallocFailedHook( void )
 void vApplicationIdleHook( void )
 {
     /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set
-    to 1 in FreeRTOSConfig.h.  It will be called on each iteration of the idle
-    task.  It is essential that code added to this hook function never attempts
-    to block in any way (for example, call xQueueReceive() with a block time
-    specified, or call vTaskDelay()).  If application tasks make use of the
-    vTaskDelete() API function to delete themselves then it is also important
-    that vApplicationIdleHook() is permitted to return to its calling function,
-    because it is the responsibility of the idle task to clean up memory
-    allocated by the kernel to any task that has since deleted itself. */
+     * to 1 in FreeRTOSConfig.h.  It will be called on each iteration of the idle
+     * task.  It is essential that code added to this hook function never attempts
+     * to block in any way (for example, call xQueueReceive() with a block time
+     * specified, or call vTaskDelay()).  If application tasks make use of the
+     * vTaskDelete() API function to delete themselves then it is also important
+     * that vApplicationIdleHook() is permitted to return to its calling function,
+     * because it is the responsibility of the idle task to clean up memory
+     * allocated by the kernel to any task that has since deleted itself. */
 
 
-    usleep(15000);
+    usleep( 15000 );
     traceOnEnter();
 
     #if ( mainSELECTED_APPLICATION == FULL_DEMO )
-    {
-        /* Call the idle task processing used by the full demo.  The simple
-        blinky demo does not use the idle task hook. */
-        vFullDemoIdleFunction();
-    }
+        {
+            /* Call the idle task processing used by the full demo.  The simple
+             * blinky demo does not use the idle task hook. */
+            vFullDemoIdleFunction();
+        }
     #endif
 }
 /*-----------------------------------------------------------*/
 
 void vApplicationStackOverflowHook( TaskHandle_t pxTask,
-                                    char *pcTaskName )
+                                    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.  This function is
-    provided as an example only as stack overflow checking does not function
-    when running the FreeRTOS POSIX port. */
+     * configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2.  This hook
+     * function is called if a stack overflow is detected.  This function is
+     * provided as an example only as stack overflow checking does not function
+     * when running the FreeRTOS POSIX port. */
     vAssertCalled( __FILE__, __LINE__ );
 }
 /*-----------------------------------------------------------*/
@@ -236,15 +237,15 @@ void vApplicationStackOverflowHook( TaskHandle_t pxTask,
 void vApplicationTickHook( void )
 {
     /* This function will be called by each tick interrupt if
-    configUSE_TICK_HOOK is set to 1 in FreeRTOSConfig.h.  User code can be
-    added here, but the tick hook is called from an interrupt context, so
-    code must not attempt to block, and only the interrupt safe FreeRTOS API
-    functions can be used (those that end in FromISR()). */
+     * configUSE_TICK_HOOK is set to 1 in FreeRTOSConfig.h.  User code can be
+     * added here, but the tick hook is called from an interrupt context, so
+     * code must not attempt to block, and only the interrupt safe FreeRTOS API
+     * functions can be used (those that end in FromISR()). */
 
-    #if (mainSELECTED_APPLICATION == FULL_DEMO )
-    {
-        vFullDemoTickHookFunction();
-    }
+    #if ( mainSELECTED_APPLICATION == FULL_DEMO )
+        {
+            vFullDemoTickHookFunction();
+        }
     #endif /* mainSELECTED_APPLICATION */
 }
 
@@ -253,25 +254,28 @@ void traceOnEnter()
     int xReturn;
     struct timeval tv = { 0L, 0L };
     fd_set fds;
-    FD_ZERO(&fds);
-    FD_SET(0, &fds);
-    xReturn = select(1, &fds, NULL, NULL, &tv);
-    if ( xReturn > 0 )
-    {
-    if( xTraceRunning == pdTRUE )
+
+    FD_ZERO( &fds );
+    FD_SET( 0, &fds );
+    xReturn = select( 1, &fds, NULL, NULL, &tv );
+
+    if( xReturn > 0 )
     {
-        prvSaveTraceFile();
-    }
-    /* clear the buffer */
-    char buffer[200];
-    read(1, &buffer, 200);
+        if( xTraceRunning == pdTRUE )
+        {
+            prvSaveTraceFile();
+        }
+
+        /* clear the buffer */
+        char buffer[ 200 ];
+        read( 1, &buffer, 200 );
     }
 }
 
-void vLoggingPrintf( const char *pcFormat,
+void vLoggingPrintf( const char * pcFormat,
                      ... )
 {
-va_list arg;
+    va_list arg;
 
     va_start( arg, pcFormat );
     vprintf( pcFormat, arg );
@@ -282,20 +286,20 @@ va_list arg;
 void vApplicationDaemonTaskStartupHook( void )
 {
     /* This function will be called once only, when the daemon task starts to
-    execute    (sometimes called the timer task).  This is useful if the
-    application includes initialisation code that would benefit from executing
-    after the scheduler has been started. */
+     * execute    (sometimes called the timer task).  This is useful if the
+     * application includes initialisation code that would benefit from executing
+     * after the scheduler has been started. */
 }
 /*-----------------------------------------------------------*/
 
 void vAssertCalled( const char * const pcFileName,
                     unsigned long ulLine )
 {
-static BaseType_t xPrinted = pdFALSE;
-volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
+    static BaseType_t xPrinted = pdFALSE;
+    volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
 
     /* Called if an assertion passed to configASSERT() fails.  See
-    http://www.freertos.org/a00110.html#configASSERT for more information. */
+     * http://www.freertos.org/a00110.html#configASSERT for more information. */
 
     /* Parameters are not used. */
     ( void ) ulLine;
@@ -316,8 +320,8 @@ volatile uint32_t ulSetToNonZeroInDebuggerToContinue = 0;
         }
 
         /* You can step out of this function to debug the assertion by using
-        the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
-        value. */
+         * the debugger to set ulSetToNonZeroInDebuggerToContinue to a non-zero
+         * value. */
         while( ulSetToNonZeroInDebuggerToContinue == 0 )
         {
             __asm volatile ( "NOP" );
@@ -332,77 +336,77 @@ static void prvSaveTraceFile( void )
 {
     /* Tracing is not used when code coverage analysis is being performed. */
     #if ( projCOVERAGE_TEST != 1 )
-    {
-    FILE * pxOutputFile;
+        {
+            FILE * pxOutputFile;
 
-        vTraceStop();
+            vTraceStop();
 
-        pxOutputFile = fopen( "Trace.dump", "wb" );
+            pxOutputFile = fopen( "Trace.dump", "wb" );
 
-        if( pxOutputFile != NULL )
-        {
-            fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
-            fclose( pxOutputFile );
-            printf( "\r\nTrace output saved to Trace.dump\r\n" );
-        }
-        else
-        {
-            printf( "\r\nFailed to create trace dump file\r\n" );
+            if( pxOutputFile != NULL )
+            {
+                fwrite( RecorderDataPtr, sizeof( RecorderDataType ), 1, pxOutputFile );
+                fclose( pxOutputFile );
+                printf( "\r\nTrace output saved to Trace.dump\r\n" );
+            }
+            else
+            {
+                printf( "\r\nFailed to create trace dump file\r\n" );
+            }
         }
-    }
     #endif /* if ( projCOVERAGE_TEST != 1 ) */
 }
 /*-----------------------------------------------------------*/
 
 /* 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;
 }
 /*-----------------------------------------------------------*/
 
 /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
-application must provide an implementation of vApplicationGetTimerTaskMemory()
-to provide the memory that is used by the Timer service task. */
-void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
-                                     StackType_t **ppxTimerTaskStackBuffer,
-                                     uint32_t *pulTimerTaskStackSize )
+ * application must provide an implementation of vApplicationGetTimerTaskMemory()
+ * to provide the memory that is used by the Timer service task. */
+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. */
+     * 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;
 }
 
@@ -414,5 +418,6 @@ void handle_sigint( int signal )
     {
         printf( "chdir into %s error is %d\n", BUILD,  errno );
     }
+
     exit( 1 );
 }
diff --git a/FreeRTOS/Demo/Posix_GCC/main_blinky.c b/FreeRTOS/Demo/Posix_GCC/main_blinky.c
index 493dc9f44..f9a8cef20 100644
--- a/FreeRTOS/Demo/Posix_GCC/main_blinky.c
+++ b/FreeRTOS/Demo/Posix_GCC/main_blinky.c
@@ -93,29 +93,29 @@
 #include "console.h"
 
 /* Priorities at which the tasks are created. */
-#define mainQUEUE_RECEIVE_TASK_PRIORITY		( tskIDLE_PRIORITY + 2 )
-#define	mainQUEUE_SEND_TASK_PRIORITY		( tskIDLE_PRIORITY + 1 )
+#define mainQUEUE_RECEIVE_TASK_PRIORITY    ( tskIDLE_PRIORITY + 2 )
+#define mainQUEUE_SEND_TASK_PRIORITY       ( tskIDLE_PRIORITY + 1 )
 
 /* The rate at which data is sent to the queue.  The times are converted from
-milliseconds to ticks using the pdMS_TO_TICKS() macro. */
-#define mainTASK_SEND_FREQUENCY_MS			pdMS_TO_TICKS( 200UL )
-#define mainTIMER_SEND_FREQUENCY_MS			pdMS_TO_TICKS( 2000UL )
+ * milliseconds to ticks using the pdMS_TO_TICKS() macro. */
+#define mainTASK_SEND_FREQUENCY_MS         pdMS_TO_TICKS( 200UL )
+#define mainTIMER_SEND_FREQUENCY_MS        pdMS_TO_TICKS( 2000UL )
 
 /* The number of items the queue can hold at once. */
-#define mainQUEUE_LENGTH					( 2 )
+#define mainQUEUE_LENGTH                   ( 2 )
 
 /* The values sent to the queue receive task from the queue send task and the
-queue send software timer respectively. */
-#define mainVALUE_SENT_FROM_TASK			( 100UL )
-#define mainVALUE_SENT_FROM_TIMER			( 200UL )
+ * queue send software timer respectively. */
+#define mainVALUE_SENT_FROM_TASK           ( 100UL )
+#define mainVALUE_SENT_FROM_TIMER          ( 200UL )
 
 /*-----------------------------------------------------------*/
 
 /*
  * The tasks as described in the comments at the top of this file.
  */
-static void prvQueueReceiveTask( void *pvParameters );
-static void prvQueueSendTask( void *pvParameters );
+static void prvQueueReceiveTask( void * pvParameters );
+static void prvQueueSendTask( void * pvParameters );
 
 /*
  * The callback function executed when the software timer expires.
@@ -135,130 +135,132 @@ static TimerHandle_t xTimer = NULL;
 /*** SEE THE COMMENTS AT THE TOP OF THIS FILE ***/
 void main_blinky( void )
 {
-const TickType_t xTimerPeriod = mainTIMER_SEND_FREQUENCY_MS;
-
-	/* Create the queue. */
-	xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( uint32_t ) );
-
-	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 simple 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 );
-
-		/* Create the software timer, but don't start it yet. */
-		xTimer = xTimerCreate( "Timer",				/* The text name assigned to the software timer - for debug only as it is not used by the kernel. */
-								xTimerPeriod,		/* The period of the software timer in ticks. */
-								pdTRUE,				/* xAutoReload is set to pdTRUE. */
-								NULL,				/* The timer's ID is not used. */
-								prvQueueSendTimerCallback );/* The function executed when the timer expires. */
-
-		if( xTimer != NULL )
-		{
-			xTimerStart( xTimer, 0 );
-		}
-
-		/* 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. */
-	for( ;; );
+    const TickType_t xTimerPeriod = mainTIMER_SEND_FREQUENCY_MS;
+
+    /* Create the queue. */
+    xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( uint32_t ) );
+
+    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 simple 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 );
+
+        /* Create the software timer, but don't start it yet. */
+        xTimer = xTimerCreate( "Timer",                     /* The text name assigned to the software timer - for debug only as it is not used by the kernel. */
+                               xTimerPeriod,                /* The period of the software timer in ticks. */
+                               pdTRUE,                      /* xAutoReload is set to pdTRUE. */
+                               NULL,                        /* The timer's ID is not used. */
+                               prvQueueSendTimerCallback ); /* The function executed when the timer expires. */
+
+        if( xTimer != NULL )
+        {
+            xTimerStart( xTimer, 0 );
+        }
+
+        /* 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. */
+    for( ; ; )
+    {
+    }
 }
 /*-----------------------------------------------------------*/
 
-static void prvQueueSendTask( void *pvParameters )
+static void prvQueueSendTask( void * pvParameters )
 {
-TickType_t xNextWakeTime;
-const TickType_t xBlockTime = mainTASK_SEND_FREQUENCY_MS;
-const uint32_t ulValueToSend = mainVALUE_SENT_FROM_TASK;
-
-	/* Prevent the compiler warning about the unused parameter. */
-	( 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.
-		The block time is specified in ticks, pdMS_TO_TICKS() was used to
-		convert a time specified in milliseconds into a time specified in ticks.
-		While in the Blocked state this task will not consume any CPU time. */
-		vTaskDelayUntil( &xNextWakeTime, xBlockTime );
-
-		/* Send to the queue - causing the queue receive task to unblock and
-		write to the console.  0 is used as the block time so the send operation
-		will not block - it shouldn't need to block as the queue should always
-		have at least one space at this point in the code. */
-		xQueueSend( xQueue, &ulValueToSend, 0U );
-	}
+    TickType_t xNextWakeTime;
+    const TickType_t xBlockTime = mainTASK_SEND_FREQUENCY_MS;
+    const uint32_t ulValueToSend = mainVALUE_SENT_FROM_TASK;
+
+    /* Prevent the compiler warning about the unused parameter. */
+    ( 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.
+        *  The block time is specified in ticks, pdMS_TO_TICKS() was used to
+        *  convert a time specified in milliseconds into a time specified in ticks.
+        *  While in the Blocked state this task will not consume any CPU time. */
+        vTaskDelayUntil( &xNextWakeTime, xBlockTime );
+
+        /* Send to the queue - causing the queue receive task to unblock and
+         * write to the console.  0 is used as the block time so the send operation
+         * will not block - it shouldn't need to block as the queue should always
+         * have at least one space at this point in the code. */
+        xQueueSend( xQueue, &ulValueToSend, 0U );
+    }
 }
 /*-----------------------------------------------------------*/
 
 static void prvQueueSendTimerCallback( TimerHandle_t xTimerHandle )
 {
-const uint32_t ulValueToSend = mainVALUE_SENT_FROM_TIMER;
+    const uint32_t ulValueToSend = mainVALUE_SENT_FROM_TIMER;
 
-	/* This is the software timer callback function.  The software timer has a
-	period of two seconds and is reset each time a key is pressed.  This
-	callback function will execute if the timer expires, which will only happen
-	if a key is not pressed for two seconds. */
+    /* This is the software timer callback function.  The software timer has a
+     * period of two seconds and is reset each time a key is pressed.  This
+     * callback function will execute if the timer expires, which will only happen
+     * if a key is not pressed for two seconds. */
 
-	/* Avoid compiler warnings resulting from the unused parameter. */
-	( void ) xTimerHandle;
+    /* Avoid compiler warnings resulting from the unused parameter. */
+    ( void ) xTimerHandle;
 
-	/* Send to the queue - causing the queue receive task to unblock and
-	write out a message.  This function is called from the timer/daemon task, so
-	must not block.  Hence the block time is set to 0. */
-	xQueueSend( xQueue, &ulValueToSend, 0U );
+    /* Send to the queue - causing the queue receive task to unblock and
+     * write out a message.  This function is called from the timer/daemon task, so
+     * must not block.  Hence the block time is set to 0. */
+    xQueueSend( xQueue, &ulValueToSend, 0U );
 }
 /*-----------------------------------------------------------*/
 
-static void prvQueueReceiveTask( void *pvParameters )
+static void prvQueueReceiveTask( void * pvParameters )
 {
-uint32_t ulReceivedValue;
-
-	/* Prevent the compiler warning about the unused parameter. */
-	( void ) pvParameters;
-
-	for( ;; )
-	{
-		/* Wait until something arrives in the queue - this task will block
-		indefinitely provided INCLUDE_vTaskSuspend is set to 1 in
-		FreeRTOSConfig.h.  It will not use any CPU time while it is in the
-		Blocked state. */
-		xQueueReceive( xQueue, &ulReceivedValue, portMAX_DELAY );
-
-		/* To get here something must have been received from the queue, but
-		is it an expected value?  Normally calling printf() from a task is not
-		a good idea.  Here there is lots of stack space and only one task is
-		using console IO so it is ok.  However, note the comments at the top of
-		this file about the risks of making Linux system calls (such as
-		console output) from a FreeRTOS task. */
-		if( ulReceivedValue == mainVALUE_SENT_FROM_TASK )
-		{
-			console_print( "Message received from task\n" );
-		}
-		else if( ulReceivedValue == mainVALUE_SENT_FROM_TIMER )
-		{
-			console_print( "Message received from software timer\n" );
-		}
-		else
-		{
-			console_print( "Unexpected message\n" );
-		}
-	}
+    uint32_t ulReceivedValue;
+
+    /* Prevent the compiler warning about the unused parameter. */
+    ( void ) pvParameters;
+
+    for( ; ; )
+    {
+        /* Wait until something arrives in the queue - this task will block
+         * indefinitely provided INCLUDE_vTaskSuspend is set to 1 in
+         * FreeRTOSConfig.h.  It will not use any CPU time while it is in the
+         * Blocked state. */
+        xQueueReceive( xQueue, &ulReceivedValue, portMAX_DELAY );
+
+        /* To get here something must have been received from the queue, but
+         * is it an expected value?  Normally calling printf() from a task is not
+         * a good idea.  Here there is lots of stack space and only one task is
+         * using console IO so it is ok.  However, note the comments at the top of
+         * this file about the risks of making Linux system calls (such as
+         * console output) from a FreeRTOS task. */
+        if( ulReceivedValue == mainVALUE_SENT_FROM_TASK )
+        {
+            console_print( "Message received from task\n" );
+        }
+        else if( ulReceivedValue == mainVALUE_SENT_FROM_TIMER )
+        {
+            console_print( "Message received from software timer\n" );
+        }
+        else
+        {
+            console_print( "Unexpected message\n" );
+        }
+    }
 }
 /*-----------------------------------------------------------*/
diff --git a/FreeRTOS/Demo/Posix_GCC/main_full.c b/FreeRTOS/Demo/Posix_GCC/main_full.c
index 8cfdc2519..a55277ddf 100644
--- a/FreeRTOS/Demo/Posix_GCC/main_full.c
+++ b/FreeRTOS/Demo/Posix_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,747 +166,754 @@ 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;
+    const unsigned long ulMSToSleep = 5;
 
-	/* Just to remove compiler warnings. */
-	( void ) pvParameters;
+    /* 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. */
+    /* 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. */
         struct timespec ts;
-		ts.tv_sec = ulMSToSleep / 1000;
-		ts.tv_nsec = ulMSToSleep % 1000l * 1000000l;
-		nanosleep( &ts, NULL );
-	}
+        ts.tv_sec = ulMSToSleep / 1000;
+        ts.tv_nsec = ulMSToSleep % 1000l * 1000000l;
+        nanosleep( &ts, NULL );
+    }
 }
 /*-----------------------------------------------------------*/
 
 /* 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. */
-	struct timespec ts;
-	ts.tv_sec = ulMSToSleep / 1000;
-	ts.tv_nsec = ulMSToSleep % 1000l * 1000000l;
-	nanosleep( &ts, NULL );
-
-	/* 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. */
+    struct timespec ts;
+
+    ts.tv_sec = ulMSToSleep / 1000;
+    ts.tv_nsec = ulMSToSleep % 1000l * 1000000l;
+    nanosleep( &ts, NULL );
+
+    /* 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. */
-	ulParameter1++;
-	ulParameter2++;
+    /* prvPendedFunction() just expects the parameters to be incremented by one
+     * each time it is called. */
 
-	/* Pend the function call, sending the parameters. */
-	xTimerPendFunctionCall( prvPendedFunction, ( void * ) ulParameter1, ulParameter2, xDontBlock );
+    ulParameter1++;
+    ulParameter2++;
+
+    /* 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/Posix_GCC/run-time-stats-utils.c b/FreeRTOS/Demo/Posix_GCC/run-time-stats-utils.c
index d43042a38..080778fb5 100644
--- a/FreeRTOS/Demo/Posix_GCC/run-time-stats-utils.c
+++ b/FreeRTOS/Demo/Posix_GCC/run-time-stats-utils.c
@@ -34,7 +34,7 @@
  *
  * Also note that it is assumed this demo is going to be used for short periods
  * of time only, and therefore timer overflows are not handled.
-*/
+ */
 
 #include <time.h>
 
@@ -48,20 +48,20 @@ static unsigned long ulStartTimeNs;
 
 void vConfigureTimerForRunTimeStats( void )
 {
-struct timespec xNow;
+    struct timespec xNow;
 
-	clock_gettime(CLOCK_MONOTONIC, &xNow);
-	ulStartTimeNs = xNow.tv_sec * 1000000000ul + xNow.tv_nsec;
+    clock_gettime( CLOCK_MONOTONIC, &xNow );
+    ulStartTimeNs = xNow.tv_sec * 1000000000ul + xNow.tv_nsec;
 }
 /*-----------------------------------------------------------*/
 
 unsigned long ulGetRunTimeCounterValue( void )
 {
-struct timespec xNow;
+    struct timespec xNow;
 
-	/* Time at start. */
-	clock_gettime(CLOCK_MONOTONIC, &xNow);
+    /* Time at start. */
+    clock_gettime( CLOCK_MONOTONIC, &xNow );
 
-	return xNow.tv_sec * 1000000000ul + xNow.tv_nsec - ulStartTimeNs;
+    return xNow.tv_sec * 1000000000ul + xNow.tv_nsec - ulStartTimeNs;
 }
 /*-----------------------------------------------------------*/
diff --git a/FreeRTOS/Demo/Posix_GCC/trcConfig.h b/FreeRTOS/Demo/Posix_GCC/trcConfig.h
index 30e049658..d39de12cf 100644
--- a/FreeRTOS/Demo/Posix_GCC/trcConfig.h
+++ b/FreeRTOS/Demo/Posix_GCC/trcConfig.h
@@ -46,13 +46,13 @@
  ******************************************************************************/
 
 #ifndef TRC_CONFIG_H
-#define TRC_CONFIG_H
+    #define TRC_CONFIG_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+    #ifdef __cplusplus
+        extern "C" {
+    #endif
 
-#include "trcPortDefines.h"
+    #include "trcPortDefines.h"
 
 /******************************************************************************
  * Include of processor header file
@@ -61,7 +61,7 @@ extern "C" {
  * required at least for the ARM Cortex-M port, that uses the ARM CMSIS API.
  * Try that in case of build problems. Otherwise, remove the #error line below.
  *****************************************************************************/
-//#error "Trace Recorder: Please include your processor's header file here and remove this line."
+/*#error "Trace Recorder: Please include your processor's header file here and remove this line." */
 
 /*******************************************************************************
  * Configuration Macro: TRC_CFG_HARDWARE_PORT
@@ -81,7 +81,7 @@ extern "C" {
  * See trcHardwarePort.h for available ports and information on how to
  * define your own port, if not already present.
  ******************************************************************************/
-#define TRC_CFG_HARDWARE_PORT TRC_HARDWARE_PORT_Win32
+    #define TRC_CFG_HARDWARE_PORT                    TRC_HARDWARE_PORT_Win32
 
 /*******************************************************************************
  * Configuration Macro: TRC_CFG_RECORDER_MODE
@@ -97,7 +97,8 @@ extern "C" {
  * TRC_RECORDER_MODE_SNAPSHOT
  * TRC_RECORDER_MODE_STREAMING
  ******************************************************************************/
-#define TRC_CFG_RECORDER_MODE TRC_RECORDER_MODE_SNAPSHOT
+    #define TRC_CFG_RECORDER_MODE                    TRC_RECORDER_MODE_SNAPSHOT
+
 /******************************************************************************
  * TRC_CFG_FREERTOS_VERSION
  *
@@ -105,7 +106,7 @@ extern "C" {
  * trace recorder library with an older version of FreeRTOS).
  *
  * TRC_FREERTOS_VERSION_7_3_X          If using FreeRTOS v7.3.X
- * TRC_FREERTOS_VERSION_7_4_X          If using FreeRTOS v7.4.X 
+ * TRC_FREERTOS_VERSION_7_4_X          If using FreeRTOS v7.4.X
  * TRC_FREERTOS_VERSION_7_5_X          If using FreeRTOS v7.5.X
  * TRC_FREERTOS_VERSION_7_6_X          If using FreeRTOS v7.6.X
  * TRC_FREERTOS_VERSION_8_X_X          If using FreeRTOS v8.X.X
@@ -122,7 +123,7 @@ extern "C" {
  * TRC_FREERTOS_VERSION_10_3_1         If using FreeRTOS v10.3.1
  * TRC_FREERTOS_VERSION_10_4_0         If using FreeRTOS v10.4.0 or later
  *****************************************************************************/
-#define TRC_CFG_FREERTOS_VERSION TRC_FREERTOS_VERSION_10_4_0
+    #define TRC_CFG_FREERTOS_VERSION                 TRC_FREERTOS_VERSION_10_4_0
 
 /*******************************************************************************
  * TRC_CFG_SCHEDULING_ONLY
@@ -134,9 +135,9 @@ extern "C" {
  *
  * Default value is 0 (= include additional events).
  ******************************************************************************/
-#define TRC_CFG_SCHEDULING_ONLY 0
+    #define TRC_CFG_SCHEDULING_ONLY                  0
 
- /******************************************************************************
+/******************************************************************************
  * TRC_CFG_INCLUDE_MEMMANG_EVENTS
  *
  * Macro which should be defined as either zero (0) or one (1).
@@ -146,20 +147,20 @@ extern "C" {
  *
  * Default value is 1.
  *****************************************************************************/
-#define TRC_CFG_INCLUDE_MEMMANG_EVENTS 1
+    #define TRC_CFG_INCLUDE_MEMMANG_EVENTS           1
 
- /******************************************************************************
+/******************************************************************************
  * TRC_CFG_INCLUDE_USER_EVENTS
  *
  * Macro which should be defined as either zero (0) or one (1).
  *
- * If this is zero (0), all code related to User Events is excluded in order 
+ * If this is zero (0), all code related to User Events is excluded in order
  * to reduce code size. Any attempts of storing User Events are then silently
  * ignored.
  *
- * User Events are application-generated events, like "printf" but for the 
- * trace log, generated using vTracePrint and vTracePrintF. 
- * The formatting is done on host-side, by Tracealyzer. User Events are 
+ * User Events are application-generated events, like "printf" but for the
+ * trace log, generated using vTracePrint and vTracePrintF.
+ * The formatting is done on host-side, by Tracealyzer. User Events are
  * therefore much faster than a console printf and can often be used
  * in timing critical code without problems.
  *
@@ -171,84 +172,84 @@ extern "C" {
  *
  * Default value is 1.
  *****************************************************************************/
-#define TRC_CFG_INCLUDE_USER_EVENTS 1
+    #define TRC_CFG_INCLUDE_USER_EVENTS              1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_ISR_TRACING
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If this is zero (0), the code for recording Interrupt Service Routines is
- * excluded, in order to reduce code size.
- *
- * Default value is 1.
- *
- * Note: tracing ISRs requires that you insert calls to vTraceStoreISRBegin
- * and vTraceStoreISREnd in your interrupt handlers.
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_ISR_TRACING 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_ISR_TRACING
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If this is zero (0), the code for recording Interrupt Service Routines is
+* excluded, in order to reduce code size.
+*
+* Default value is 1.
+*
+* Note: tracing ISRs requires that you insert calls to vTraceStoreISRBegin
+* and vTraceStoreISREnd in your interrupt handlers.
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_ISR_TRACING              1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_READY_EVENTS
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If one (1), events are recorded when tasks enter scheduling state "ready".
- * This allows Tracealyzer to show the initial pending time before tasks enter
- * the execution state, and present accurate response times.
- * If zero (0), "ready events" are not created, which allows for recording
- * longer traces in the same amount of RAM.
- *
- * Default value is 1.
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_READY_EVENTS 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_READY_EVENTS
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If one (1), events are recorded when tasks enter scheduling state "ready".
+* This allows Tracealyzer to show the initial pending time before tasks enter
+* the execution state, and present accurate response times.
+* If zero (0), "ready events" are not created, which allows for recording
+* longer traces in the same amount of RAM.
+*
+* Default value is 1.
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_READY_EVENTS             1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_OSTICK_EVENTS
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If this is one (1), events will be generated whenever the OS clock is
- * increased. If zero (0), OS tick events are not generated, which allows for
- * recording longer traces in the same amount of RAM.
- *
- * Default value is 1.
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_OSTICK_EVENTS 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_OSTICK_EVENTS
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If this is one (1), events will be generated whenever the OS clock is
+* increased. If zero (0), OS tick events are not generated, which allows for
+* recording longer traces in the same amount of RAM.
+*
+* Default value is 1.
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_OSTICK_EVENTS            1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If this is zero (0), the trace will exclude any "event group" events.
- *
- * Default value is 0 (excluded) since dependent on event_groups.c
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If this is zero (0), the trace will exclude any "event group" events.
+*
+* Default value is 0 (excluded) since dependent on event_groups.c
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_EVENT_GROUP_EVENTS       1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_TIMER_EVENTS
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If this is zero (0), the trace will exclude any Timer events.
- *
- * Default value is 0 since dependent on timers.c
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_TIMER_EVENTS 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_TIMER_EVENTS
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If this is zero (0), the trace will exclude any Timer events.
+*
+* Default value is 0 since dependent on timers.c
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_TIMER_EVENTS             1
 
- /*****************************************************************************
- * TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS
- *
- * Macro which should be defined as either zero (0) or one (1).
- *
- * If this is zero (0), the trace will exclude any "pending function call" 
- * events, such as xTimerPendFunctionCall().
- *
- * Default value is 0 since dependent on timers.c
- *****************************************************************************/
-#define TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS 1
+/*****************************************************************************
+* TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS
+*
+* Macro which should be defined as either zero (0) or one (1).
+*
+* If this is zero (0), the trace will exclude any "pending function call"
+* events, such as xTimerPendFunctionCall().
+*
+* Default value is 0 since dependent on timers.c
+*****************************************************************************/
+    #define TRC_CFG_INCLUDE_PEND_FUNC_CALL_EVENTS    1
 
 /*******************************************************************************
  * Configuration Macro: TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS
@@ -260,7 +261,7 @@ extern "C" {
  *
  * Default value is 0 since dependent on stream_buffer.c (new in FreeRTOS v10)
  ******************************************************************************/
-#define TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS 1
+    #define TRC_CFG_INCLUDE_STREAM_BUFFER_EVENTS     1
 
 /*******************************************************************************
  * Configuration Macro: TRC_CFG_RECORDER_BUFFER_ALLOCATION
@@ -278,7 +279,7 @@ extern "C" {
  * The custom mode allows you to control how and where the allocation is made,
  * for details see TRC_ALLOC_CUSTOM_BUFFER and vTraceSetRecorderDataBuffer().
  ******************************************************************************/
-#define TRC_CFG_RECORDER_BUFFER_ALLOCATION TRC_RECORDER_BUFFER_ALLOCATION_STATIC
+    #define TRC_CFG_RECORDER_BUFFER_ALLOCATION       TRC_RECORDER_BUFFER_ALLOCATION_STATIC
 
 /******************************************************************************
  * TRC_CFG_MAX_ISR_NESTING
@@ -293,17 +294,17 @@ extern "C" {
  *
  * Default value: 8
  *****************************************************************************/
-#define TRC_CFG_MAX_ISR_NESTING 8
+    #define TRC_CFG_MAX_ISR_NESTING                  8
 
 /* Specific configuration, depending on Streaming/Snapshot mode */
-#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT)
-#include "trcSnapshotConfig.h"
-#elif (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING)
-#include "trcStreamingConfig.h"
-#endif
+    #if ( TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT )
+        #include "trcSnapshotConfig.h"
+    #elif ( TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING )
+        #include "trcStreamingConfig.h"
+    #endif
 
-#ifdef __cplusplus
-}
-#endif
+    #ifdef __cplusplus
+        }
+    #endif
 
 #endif /* _TRC_CONFIG_H */
diff --git a/FreeRTOS/Demo/Posix_GCC/trcSnapshotConfig.h b/FreeRTOS/Demo/Posix_GCC/trcSnapshotConfig.h
index 45c920584..c543e28d2 100644
--- a/FreeRTOS/Demo/Posix_GCC/trcSnapshotConfig.h
+++ b/FreeRTOS/Demo/Posix_GCC/trcSnapshotConfig.h
@@ -46,8 +46,8 @@
 #ifndef TRC_SNAPSHOT_CONFIG_H
 #define TRC_SNAPSHOT_CONFIG_H
 
-#define TRC_SNAPSHOT_MODE_RING_BUFFER		(0x01)
-#define TRC_SNAPSHOT_MODE_STOP_WHEN_FULL	(0x02)
+#define TRC_SNAPSHOT_MODE_RING_BUFFER       ( 0x01 )
+#define TRC_SNAPSHOT_MODE_STOP_WHEN_FULL    ( 0x02 )
 
 /******************************************************************************
  * TRC_CFG_SNAPSHOT_MODE
@@ -67,7 +67,7 @@
  * recording is stopped when the buffer becomes full. This is useful for
  * recording events following a specific state, e.g., the startup sequence.
  *****************************************************************************/
-#define TRC_CFG_SNAPSHOT_MODE TRC_SNAPSHOT_MODE_RING_BUFFER
+#define TRC_CFG_SNAPSHOT_MODE               TRC_SNAPSHOT_MODE_RING_BUFFER
 
 /*******************************************************************************
  * TRC_CFG_EVENT_BUFFER_SIZE
@@ -82,7 +82,7 @@
  * Default value is 1000, which means that 4000 bytes is allocated for the
  * event buffer.
  ******************************************************************************/
-#define TRC_CFG_EVENT_BUFFER_SIZE 32000
+#define TRC_CFG_EVENT_BUFFER_SIZE           32000
 
 /*******************************************************************************
  * TRC_CFG_NTASK, TRC_CFG_NISR, TRC_CFG_NQUEUE, TRC_CFG_NSEMAPHORE...
@@ -106,15 +106,15 @@
  * check the actual usage by selecting View menu -> Trace Details ->
  * Resource Usage -> Object Table.
  ******************************************************************************/
-#define TRC_CFG_NTASK			150
-#define TRC_CFG_NISR			90
-#define TRC_CFG_NQUEUE			90
-#define TRC_CFG_NSEMAPHORE		90
-#define TRC_CFG_NMUTEX			90
-#define TRC_CFG_NTIMER			250
-#define TRC_CFG_NEVENTGROUP		90
-#define TRC_CFG_NSTREAMBUFFER	100
-#define TRC_CFG_NMESSAGEBUFFER	100
+#define TRC_CFG_NTASK                       150
+#define TRC_CFG_NISR                        90
+#define TRC_CFG_NQUEUE                      90
+#define TRC_CFG_NSEMAPHORE                  90
+#define TRC_CFG_NMUTEX                      90
+#define TRC_CFG_NTIMER                      250
+#define TRC_CFG_NEVENTGROUP                 90
+#define TRC_CFG_NSTREAMBUFFER               100
+#define TRC_CFG_NMESSAGEBUFFER              100
 
 
 /******************************************************************************
@@ -133,7 +133,7 @@
  *
  * Default value is 0.
  *****************************************************************************/
-#define TRC_CFG_INCLUDE_FLOAT_SUPPORT 0
+#define TRC_CFG_INCLUDE_FLOAT_SUPPORT    0
 
 /*******************************************************************************
  * TRC_CFG_SYMBOL_TABLE_SIZE
@@ -149,10 +149,10 @@
  *
  * Default value is 800.
  ******************************************************************************/
-#define TRC_CFG_SYMBOL_TABLE_SIZE 32000
+#define TRC_CFG_SYMBOL_TABLE_SIZE        32000
 
-#if (TRC_CFG_SYMBOL_TABLE_SIZE == 0)
-#error "TRC_CFG_SYMBOL_TABLE_SIZE may not be zero!"
+#if ( TRC_CFG_SYMBOL_TABLE_SIZE == 0 )
+    #error "TRC_CFG_SYMBOL_TABLE_SIZE may not be zero!"
 #endif
 
 /******************************************************************************
@@ -162,15 +162,15 @@
  * kernel objects, such as tasks and queues. If longer names are used, they will
  * be truncated when stored in the recorder.
  *****************************************************************************/
-#define TRC_CFG_NAME_LEN_TASK			15
-#define TRC_CFG_NAME_LEN_ISR			15
-#define TRC_CFG_NAME_LEN_QUEUE			15
-#define TRC_CFG_NAME_LEN_SEMAPHORE		15
-#define TRC_CFG_NAME_LEN_MUTEX			15
-#define TRC_CFG_NAME_LEN_TIMER			15
-#define TRC_CFG_NAME_LEN_EVENTGROUP 	15
-#define TRC_CFG_NAME_LEN_STREAMBUFFER 	15
-#define TRC_CFG_NAME_LEN_MESSAGEBUFFER 	15
+#define TRC_CFG_NAME_LEN_TASK             15
+#define TRC_CFG_NAME_LEN_ISR              15
+#define TRC_CFG_NAME_LEN_QUEUE            15
+#define TRC_CFG_NAME_LEN_SEMAPHORE        15
+#define TRC_CFG_NAME_LEN_MUTEX            15
+#define TRC_CFG_NAME_LEN_TIMER            15
+#define TRC_CFG_NAME_LEN_EVENTGROUP       15
+#define TRC_CFG_NAME_LEN_STREAMBUFFER     15
+#define TRC_CFG_NAME_LEN_MESSAGEBUFFER    15
 
 /******************************************************************************
  *** ADVANCED SETTINGS ********************************************************
@@ -190,7 +190,7 @@
 *
 * Default value is 0.
 ******************************************************************************/
-#define TRC_CFG_HEAP_SIZE_BELOW_16M 0
+#define TRC_CFG_HEAP_SIZE_BELOW_16M                0
 
 /******************************************************************************
  * TRC_CFG_USE_IMPLICIT_IFE_RULES
@@ -222,7 +222,7 @@
  * For details, see trcSnapshotKernelPort.h and look for references to the
  * macro trcKERNEL_HOOKS_SET_TASK_INSTANCE_FINISHED.
  *****************************************************************************/
-#define TRC_CFG_USE_IMPLICIT_IFE_RULES 1
+#define TRC_CFG_USE_IMPLICIT_IFE_RULES             1
 
 /******************************************************************************
  * TRC_CFG_USE_16BIT_OBJECT_HANDLES
@@ -246,7 +246,7 @@
  * the event buffer whenever the object is referenced. Moreover, some internal
  * tables in the recorder gets slightly larger when using 16-bit handles.
  *****************************************************************************/
-#define TRC_CFG_USE_16BIT_OBJECT_HANDLES 0
+#define TRC_CFG_USE_16BIT_OBJECT_HANDLES           0
 
 /******************************************************************************
  * TRC_CFG_USE_TRACE_ASSERT
@@ -264,7 +264,7 @@
  * parameters. Can be switched off to reduce the footprint of the tracing, but
  * we recommend to have it enabled initially.
  *****************************************************************************/
-#define TRC_CFG_USE_TRACE_ASSERT 1
+#define TRC_CFG_USE_TRACE_ASSERT                   1
 
 /*******************************************************************************
  * TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER
@@ -320,9 +320,9 @@
  *
  *  // Finds the existing UB channel
  *  vTracePrintF(chn2, "%Z: %d", value2);
-
+ *
  ******************************************************************************/
-#define TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER 0
+#define TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER     0
 
 /*******************************************************************************
  * TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE
@@ -334,7 +334,7 @@
  *
  * Only applicable if TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER is 1.
  ******************************************************************************/
-#define TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE 200
+#define TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE    200
 
 /*******************************************************************************
  * TRC_CFG_UB_CHANNELS
@@ -348,7 +348,7 @@
  *
  * Only applicable if TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER is 1.
  ******************************************************************************/
-#define TRC_CFG_UB_CHANNELS 32
+#define TRC_CFG_UB_CHANNELS                        32
 
 /*******************************************************************************
  * TRC_CFG_ISR_TAILCHAINING_THRESHOLD
@@ -373,6 +373,6 @@
  * Note: This setting has separate definitions in trcSnapshotConfig.h and
  * trcStreamingConfig.h, since it is affected by the recorder mode.
  ******************************************************************************/
-#define TRC_CFG_ISR_TAILCHAINING_THRESHOLD 0
+#define TRC_CFG_ISR_TAILCHAINING_THRESHOLD         0
 
 #endif /*TRC_SNAPSHOT_CONFIG_H*/
diff --git a/lexicon.txt b/lexicon.txt
index ccf80ca52..b62a189d2 100644
--- a/lexicon.txt
+++ b/lexicon.txt
@@ -204,6 +204,7 @@ cg
 ch
 chacha
 chachapoly
+chdir
 checklogin
 checknullarg
 checktimer
@@ -777,6 +778,7 @@ gir
 girq
 girqm
 github
+gmon
 gnd
 gnuc
 googleapis
@@ -2158,6 +2160,7 @@ shouldn
 shtml
 sice
 sifive
+sigint
 signalled
 signatureverificationstate
 signatureverificationstateptr