Format code, and rmove implicit tests (#489)
diff --git a/portable/ThirdParty/GCC/Posix/port.c b/portable/ThirdParty/GCC/Posix/port.c
index 5cb70a5..a9347d3 100644
--- a/portable/ThirdParty/GCC/Posix/port.c
+++ b/portable/ThirdParty/GCC/Posix/port.c
@@ -27,28 +27,29 @@
*/
/*-----------------------------------------------------------
- * Implementation of functions defined in portable.h for the Posix port.
- *
- * Each task has a pthread which eases use of standard debuggers
- * (allowing backtraces of tasks etc). Threads for tasks that are not
- * running are blocked in sigwait().
- *
- * Task switch is done by resuming the thread for the next task by
- * signaling the condition variable and then waiting on a condition variable
- * with the current thread.
- *
- * The timer interrupt uses SIGALRM and care is taken to ensure that
- * the signal handler runs only on the thread for the current task.
- *
- * Use of part of the standard C library requires care as some
- * functions can take pthread mutexes internally which can result in
- * deadlocks as the FreeRTOS kernel can switch tasks while they're
- * holding a pthread mutex.
- *
- * stdio (printf() and friends) should be called from a single task
- * only or serialized with a FreeRTOS primitive such as a binary
- * semaphore or mutex.
- *----------------------------------------------------------*/
+* Implementation of functions defined in portable.h for the Posix port.
+*
+* Each task has a pthread which eases use of standard debuggers
+* (allowing backtraces of tasks etc). Threads for tasks that are not
+* running are blocked in sigwait().
+*
+* Task switch is done by resuming the thread for the next task by
+* signaling the condition variable and then waiting on a condition variable
+* with the current thread.
+*
+* The timer interrupt uses SIGALRM and care is taken to ensure that
+* the signal handler runs only on the thread for the current task.
+*
+* Use of part of the standard C library requires care as some
+* functions can take pthread mutexes internally which can result in
+* deadlocks as the FreeRTOS kernel can switch tasks while they're
+* holding a pthread mutex.
+*
+* stdio (printf() and friends) should be called from a single task
+* only or serialized with a FreeRTOS primitive such as a binary
+* semaphore or mutex.
+*----------------------------------------------------------*/
+#include "portmacro.h"
#include <errno.h>
#include <pthread.h>
@@ -67,26 +68,26 @@
#include "utils/wait_for_event.h"
/*-----------------------------------------------------------*/
-#define SIG_RESUME SIGUSR1
+#define SIG_RESUME SIGUSR1
typedef struct THREAD
{
pthread_t pthread;
pdTASK_CODE pxCode;
- void *pvParams;
+ void * pvParams;
BaseType_t xDying;
- struct event *ev;
+ struct event * ev;
} Thread_t;
/*
* The additional per-thread data is stored at the beginning of the
* task's stack.
*/
-static inline Thread_t *prvGetThreadFromTask(TaskHandle_t xTask)
+static inline Thread_t * prvGetThreadFromTask( TaskHandle_t xTask )
{
-StackType_t *pxTopOfStack = *(StackType_t **)xTask;
+ StackType_t * pxTopOfStack = *( StackType_t ** ) xTask;
- return (Thread_t *)(pxTopOfStack + 1);
+ return ( Thread_t * ) ( pxTopOfStack + 1 );
}
/*-----------------------------------------------------------*/
@@ -95,7 +96,7 @@
static sigset_t xResumeSignals;
static sigset_t xAllSignals;
static sigset_t xSchedulerOriginalSignalMask;
-static pthread_t hMainThread = ( pthread_t )NULL;
+static pthread_t hMainThread = ( pthread_t ) NULL;
static volatile portBASE_TYPE uxCriticalNesting;
/*-----------------------------------------------------------*/
@@ -104,17 +105,18 @@
static void prvSetupSignalsAndSchedulerPolicy( void );
static void prvSetupTimerInterrupt( void );
-static void *prvWaitForStart( void * pvParams );
+static void * prvWaitForStart( void * pvParams );
static void prvSwitchThread( Thread_t * xThreadToResume,
- Thread_t *xThreadToSuspend );
-static void prvSuspendSelf( Thread_t * thread);
+ Thread_t * xThreadToSuspend );
+static void prvSuspendSelf( Thread_t * thread );
static void prvResumeThread( Thread_t * xThreadId );
static void vPortSystemTickHandler( int sig );
static void vPortStartFirstTask( void );
static void prvPortYieldFromISR( void );
/*-----------------------------------------------------------*/
-static void prvFatalError( const char *pcCall, int iErrno )
+static void prvFatalError( const char * pcCall,
+ int iErrno )
{
fprintf( stderr, "%s: %s\n", pcCall, strerror( iErrno ) );
abort();
@@ -123,23 +125,24 @@
/*
* See header file for description.
*/
-portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack,
- portSTACK_TYPE *pxEndOfStack,
- pdTASK_CODE pxCode, void *pvParameters )
+portSTACK_TYPE * pxPortInitialiseStack( portSTACK_TYPE * pxTopOfStack,
+ portSTACK_TYPE * pxEndOfStack,
+ pdTASK_CODE pxCode,
+ void * pvParameters )
{
-Thread_t *thread;
-pthread_attr_t xThreadAttributes;
-size_t ulStackSize;
-int iRet;
+ Thread_t * thread;
+ pthread_attr_t xThreadAttributes;
+ size_t ulStackSize;
+ int iRet;
- (void)pthread_once( &hSigSetupThread, prvSetupSignalsAndSchedulerPolicy );
+ ( void ) pthread_once( &hSigSetupThread, prvSetupSignalsAndSchedulerPolicy );
/*
* Store the additional thread data at the start of the stack.
*/
- thread = (Thread_t *)(pxTopOfStack + 1) - 1;
- pxTopOfStack = (portSTACK_TYPE *)thread - 1;
- ulStackSize = (pxTopOfStack + 1 - pxEndOfStack) * sizeof(*pxTopOfStack);
+ thread = ( Thread_t * ) ( pxTopOfStack + 1 ) - 1;
+ pxTopOfStack = ( portSTACK_TYPE * ) thread - 1;
+ ulStackSize = ( pxTopOfStack + 1 - pxEndOfStack ) * sizeof( *pxTopOfStack );
thread->pxCode = pxCode;
thread->pvParams = pvParameters;
@@ -154,7 +157,8 @@
iRet = pthread_create( &thread->pthread, &xThreadAttributes,
prvWaitForStart, thread );
- if ( iRet )
+
+ if( iRet != 0 )
{
prvFatalError( "pthread_create", iRet );
}
@@ -167,7 +171,7 @@
void vPortStartFirstTask( void )
{
-Thread_t *pxFirstThread = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
+ Thread_t * pxFirstThread = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
/* Start the first task. */
prvResumeThread( pxFirstThread );
@@ -179,13 +183,13 @@
*/
portBASE_TYPE xPortStartScheduler( void )
{
-int iSignal;
-sigset_t xSignals;
+ int iSignal;
+ sigset_t xSignals;
hMainThread = pthread_self();
/* Start the timer that generates the tick ISR(SIGALRM).
- Interrupts are disabled here already. */
+ * Interrupts are disabled here already. */
prvSetupTimerInterrupt();
/* Start the first task. */
@@ -195,23 +199,23 @@
sigemptyset( &xSignals );
sigaddset( &xSignals, SIG_RESUME );
- while ( !xSchedulerEnd )
+ while( xSchedulerEnd != pdTRUE )
{
sigwait( &xSignals, &iSignal );
}
/* Cancel the Idle task and free its resources */
-#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
- vPortCancelThread( xTaskGetIdleTaskHandle() );
-#endif
+ #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
+ vPortCancelThread( xTaskGetIdleTaskHandle() );
+ #endif
-#if ( configUSE_TIMERS == 1 )
- /* Cancel the Timer task and free its resources */
- vPortCancelThread( xTimerGetTimerDaemonTaskHandle() );
-#endif /* configUSE_TIMERS */
+ #if ( configUSE_TIMERS == 1 )
+ /* Cancel the Timer task and free its resources */
+ vPortCancelThread( xTimerGetTimerDaemonTaskHandle() );
+ #endif /* configUSE_TIMERS */
/* Restore original signal mask. */
- (void)pthread_sigmask( SIG_SETMASK, &xSchedulerOriginalSignalMask, NULL );
+ ( void ) pthread_sigmask( SIG_SETMASK, &xSchedulerOriginalSignalMask, NULL );
return 0;
}
@@ -219,9 +223,9 @@
void vPortEndScheduler( void )
{
-struct itimerval itimer;
-struct sigaction sigtick;
-Thread_t *xCurrentThread;
+ struct itimerval itimer;
+ struct sigaction sigtick;
+ Thread_t * xCurrentThread;
/* Stop the timer and ignore any pending SIGALRMs that would end
* up running on the main thread when it is resumed. */
@@ -230,7 +234,7 @@
itimer.it_interval.tv_sec = 0;
itimer.it_interval.tv_usec = 0;
- (void)setitimer( ITIMER_REAL, &itimer, NULL );
+ ( void ) setitimer( ITIMER_REAL, &itimer, NULL );
sigtick.sa_flags = 0;
sigtick.sa_handler = SIG_IGN;
@@ -239,19 +243,20 @@
/* Signal the scheduler to exit its loop. */
xSchedulerEnd = pdTRUE;
- (void)pthread_kill( hMainThread, SIG_RESUME );
+ ( void ) pthread_kill( hMainThread, SIG_RESUME );
xCurrentThread = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
- prvSuspendSelf(xCurrentThread);
+ prvSuspendSelf( xCurrentThread );
}
/*-----------------------------------------------------------*/
void vPortEnterCritical( void )
{
- if ( uxCriticalNesting == 0 )
+ if( uxCriticalNesting == 0 )
{
vPortDisableInterrupts();
}
+
uxCriticalNesting++;
}
/*-----------------------------------------------------------*/
@@ -270,8 +275,8 @@
static void prvPortYieldFromISR( void )
{
-Thread_t *xThreadToSuspend;
-Thread_t *xThreadToResume;
+ Thread_t * xThreadToSuspend;
+ Thread_t * xThreadToResume;
xThreadToSuspend = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
@@ -308,7 +313,7 @@
portBASE_TYPE xPortSetInterruptMask( void )
{
/* Interrupts are always disabled inside ISRs (signals
- handlers). */
+ * handlers). */
return pdTRUE;
}
/*-----------------------------------------------------------*/
@@ -318,16 +323,17 @@
}
/*-----------------------------------------------------------*/
-static uint64_t prvGetTimeNs(void)
+static uint64_t prvGetTimeNs( void )
{
-struct timespec t;
+ struct timespec t;
- clock_gettime(CLOCK_MONOTONIC, &t);
+ clock_gettime( CLOCK_MONOTONIC, &t );
- return t.tv_sec * 1000000000ull + t.tv_nsec;
+ return t.tv_sec * 1000000000ULL + t.tv_nsec;
}
static uint64_t prvStartTimeNs;
+
/* commented as part of the code below in vPortSystemTickHandler,
* to adjust timing according to full demo requirements */
/* static uint64_t prvTickCount; */
@@ -338,12 +344,13 @@
*/
void prvSetupTimerInterrupt( void )
{
-struct itimerval itimer;
-int iRet;
+ struct itimerval itimer;
+ int iRet;
/* Initialise the structure with the current timer information. */
iRet = getitimer( ITIMER_REAL, &itimer );
- if ( iRet )
+
+ if( iRet == -1 )
{
prvFatalError( "getitimer", errno );
}
@@ -358,7 +365,8 @@
/* Set-up the timer interrupt. */
iRet = setitimer( ITIMER_REAL, &itimer, NULL );
- if ( iRet )
+
+ if( iRet == -1 )
{
prvFatalError( "setitimer", errno );
}
@@ -369,51 +377,55 @@
static void vPortSystemTickHandler( int sig )
{
-Thread_t *pxThreadToSuspend;
-Thread_t *pxThreadToResume;
+ Thread_t * pxThreadToSuspend;
+ Thread_t * pxThreadToResume;
+
/* uint64_t xExpectedTicks; */
uxCriticalNesting++; /* Signals are blocked in this signal handler. */
-#if ( configUSE_PREEMPTION == 1 )
- pxThreadToSuspend = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
-#endif
+ #if ( configUSE_PREEMPTION == 1 )
+ pxThreadToSuspend = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
+ #endif
/* Tick Increment, accounting for any lost signals or drift in
* the timer. */
+
/*
* Comment code to adjust timing according to full demo requirements
* xExpectedTicks = (prvGetTimeNs() - prvStartTimeNs)
* / (portTICK_RATE_MICROSECONDS * 1000);
* do { */
- xTaskIncrementTick();
+ xTaskIncrementTick();
+
/* prvTickCount++;
* } while (prvTickCount < xExpectedTicks);
-*/
+ */
-#if ( configUSE_PREEMPTION == 1 )
- /* Select Next Task. */
- vTaskSwitchContext();
+ #if ( configUSE_PREEMPTION == 1 )
+ /* Select Next Task. */
+ vTaskSwitchContext();
- pxThreadToResume = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
+ pxThreadToResume = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
- prvSwitchThread(pxThreadToResume, pxThreadToSuspend);
-#endif
+ prvSwitchThread( pxThreadToResume, pxThreadToSuspend );
+ #endif
uxCriticalNesting--;
}
/*-----------------------------------------------------------*/
-void vPortThreadDying( void *pxTaskToDelete, volatile BaseType_t *pxPendYield )
+void vPortThreadDying( void * pxTaskToDelete,
+ volatile BaseType_t * pxPendYield )
{
-Thread_t *pxThread = prvGetThreadFromTask( pxTaskToDelete );
+ Thread_t * pxThread = prvGetThreadFromTask( pxTaskToDelete );
pxThread->xDying = pdTRUE;
}
-void vPortCancelThread( void *pxTaskToDelete )
+void vPortCancelThread( void * pxTaskToDelete )
{
-Thread_t *pxThreadToCancel = prvGetThreadFromTask( pxTaskToDelete );
+ Thread_t * pxThreadToCancel = prvGetThreadFromTask( pxTaskToDelete );
/*
* The thread has already been suspended so it can be safely cancelled.
@@ -424,11 +436,11 @@
}
/*-----------------------------------------------------------*/
-static void *prvWaitForStart( void * pvParams )
+static void * prvWaitForStart( void * pvParams )
{
-Thread_t *pxThread = pvParams;
+ Thread_t * pxThread = pvParams;
- prvSuspendSelf(pxThread);
+ prvSuspendSelf( pxThread );
/* Resumed for the first time, unblocks all signals. */
uxCriticalNesting = 0;
@@ -438,22 +450,22 @@
pxThread->pxCode( pxThread->pvParams );
/* A function that implements a task must not exit or attempt to return to
- * its caller as there is nothing to return to. If a task wants to exit it
- * should instead call vTaskDelete( NULL ). Artificially force an assert()
- * to be triggered if configASSERT() is defined, so application writers can
- * catch the error. */
+ * its caller as there is nothing to return to. If a task wants to exit it
+ * should instead call vTaskDelete( NULL ). Artificially force an assert()
+ * to be triggered if configASSERT() is defined, so application writers can
+ * catch the error. */
configASSERT( pdFALSE );
return NULL;
}
/*-----------------------------------------------------------*/
-static void prvSwitchThread( Thread_t *pxThreadToResume,
- Thread_t *pxThreadToSuspend )
+static void prvSwitchThread( Thread_t * pxThreadToResume,
+ Thread_t * pxThreadToSuspend )
{
-BaseType_t uxSavedCriticalNesting;
+ BaseType_t uxSavedCriticalNesting;
- if ( pxThreadToSuspend != pxThreadToResume )
+ if( pxThreadToSuspend != pxThreadToResume )
{
/*
* Switch tasks.
@@ -465,10 +477,12 @@
uxSavedCriticalNesting = uxCriticalNesting;
prvResumeThread( pxThreadToResume );
- if ( pxThreadToSuspend->xDying )
+
+ if( pxThreadToSuspend->xDying == pdTRUE )
{
pthread_exit( NULL );
}
+
prvSuspendSelf( pxThreadToSuspend );
uxCriticalNesting = uxSavedCriticalNesting;
@@ -476,7 +490,7 @@
}
/*-----------------------------------------------------------*/
-static void prvSuspendSelf( Thread_t *thread )
+static void prvSuspendSelf( Thread_t * thread )
{
/*
* Suspend this thread by waiting for a pthread_cond_signal event.
@@ -490,25 +504,25 @@
* - From a signal handler that has all signals masked.
*
* - A thread with all signals blocked with pthread_sigmask().
- */
- event_wait(thread->ev);
+ */
+ event_wait( thread->ev );
}
/*-----------------------------------------------------------*/
-static void prvResumeThread( Thread_t *xThreadId )
+static void prvResumeThread( Thread_t * xThreadId )
{
- if ( pthread_self() != xThreadId->pthread )
+ if( pthread_self() != xThreadId->pthread )
{
- event_signal(xThreadId->ev);
+ event_signal( xThreadId->ev );
}
}
/*-----------------------------------------------------------*/
static void prvSetupSignalsAndSchedulerPolicy( void )
{
-struct sigaction sigresume, sigtick;
-int iRet;
+ struct sigaction sigresume, sigtick;
+ int iRet;
hMainThread = pthread_self();
@@ -516,6 +530,7 @@
sigemptyset( &xResumeSignals );
sigaddset( &xResumeSignals, SIG_RESUME );
sigfillset( &xAllSignals );
+
/* Don't block SIGINT so this can be used to break into GDB while
* in a critical section. */
sigdelset( &xAllSignals, SIGINT );
@@ -527,11 +542,12 @@
* When a thread is resumed for the first time, all signals
* will be unblocked.
*/
- (void)pthread_sigmask( SIG_SETMASK, &xAllSignals,
- &xSchedulerOriginalSignalMask );
+ ( void ) pthread_sigmask( SIG_SETMASK,
+ &xAllSignals,
+ &xSchedulerOriginalSignalMask );
/* SIG_RESUME is only used with sigwait() so doesn't need a
- handler. */
+ * handler. */
sigresume.sa_flags = 0;
sigresume.sa_handler = SIG_IGN;
sigfillset( &sigresume.sa_mask );
@@ -541,13 +557,15 @@
sigfillset( &sigtick.sa_mask );
iRet = sigaction( SIG_RESUME, &sigresume, NULL );
- if ( iRet )
+
+ if( iRet == -1 )
{
prvFatalError( "sigaction", errno );
}
iRet = sigaction( SIGALRM, &sigtick, NULL );
- if ( iRet )
+
+ if( iRet == -1 )
{
prvFatalError( "sigaction", errno );
}
@@ -556,7 +574,7 @@
unsigned long ulPortGetRunTime( void )
{
-struct tms xTimes;
+ struct tms xTimes;
times( &xTimes );
