Added new type definitions - moving towards V3.0

28 files changed, 227 insertions, 477 deletions

diff --git a/src/gos/gos.h b/src/gos/gos.h
index 9ba12889..f68c9fda 100644
--- a/src/gos/gos.h
+++ b/src/gos/gos.h
@@ -28,16 +28,28 @@
 
 	/**
 	 * @name	Various integer sizes
-	 * @note	Your platform may use slightly different definitions to these
+	 * @note	Your platform may define these differently to these.
+	 * @note	These sizes are guaranteed minimum sizes for the type. It might actually be larger.
+	 *			eg gI8 may actually be 9 bits.
+	 * @{
+	 */
+	typedef unsigned char	gBool;
+	typedef signed char		gI8;
+	typedef unsigned char	gU8;
+	typedef short			gI16;
+	typedef unsigned short	gU16;
+	typedef long			gI32;
+	typedef unsigned long	gU32;
+	/** @} */
+	
+	/**
+	 * @name	More integer sizes
+	 * @pre		These are only available if GFX_TYPE_64 is GFXON as not all compilers support 64 bit.
+	 * @note	GFX_TYPE_64 is set to GFXON or GFXOFF by the compiler detector. It is not a user configuration macro.
 	 * @{
 	 */
-	typedef unsigned char	bool_t;
-	typedef char			int8_t;
-	typedef unsigned char	uint8_t;
-	typedef short			int16_t;
-	typedef unsigned short	uint16_t;
-	typedef long			int32_t;
-	typedef unsigned long	uint32_t;
+	typedef long long		gI64;
+	typedef unsigned long long	gU64;
 	/** @} */
 
 	/**
@@ -45,7 +57,6 @@
 	 * @note	Your platform may use slightly different definitions to these
 	 * @{
 	 */
-	typedef unsigned long	size_t;
 	typedef unsigned long	delaytime_t;
 	typedef unsigned long	systemticks_t;
 	typedef short			semcount_t;
@@ -118,10 +129,6 @@
 	/* Function declarations.                                                    */
 	/*===========================================================================*/
 
-	#ifdef __cplusplus
-	extern "C" {
-	#endif
-
 	/**
 	 * @brief	Halt the GFX application due to an error.
 	 *
@@ -354,26 +361,26 @@
 	 * @brief	Wait on a semaphore
 	 * @details	The semaphore counter is decreased and if the result becomes negative the thread waits for it to become
 	 * 				non-negative again
-	 * @return	FALSE if the wait timeout occurred otherwise TRUE
+	 * @return	gFalse if the wait timeout occurred otherwise gTrue
 	 *
 	 * @param[in] psem		A pointer to the semaphore
 	 * @param[in] ms		The maximum time to wait for the semaphore
 	 *
 	 * @api
 	 */
-	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
+	gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
 
 	/**
 	 * @brief	Test if a wait on a semaphore can be satisfied immediately
 	 * @details	Equivalent to @p gfxSemWait(psem, TIME_IMMEDIATE) except it can be called at interrupt level
-	 * @return	FALSE if the wait would occur occurred otherwise TRUE
+	 * @return	gFalse if the wait would occur occurred otherwise gTrue
 	 *
 	 * @param[in] psem		A pointer to the semaphore
 	 *
 	 * @iclass
 	 * @api
 	 */
-	bool_t gfxSemWaitI(gfxSem *psem);
+	gBool gfxSemWaitI(gfxSem *psem);
 
 	/**
 	 * @brief	Signal a semaphore
@@ -446,10 +453,6 @@
 	 */
 	void gfxThreadClose(gfxThreadHandle thread);
 
-	#ifdef __cplusplus
-	}
-	#endif
-
 /**
  * All the above was just for the doxygen documentation. All the implementation of the above
  * (without any of the documentation overheads) is in the files below.
diff --git a/src/gos/gos_arduino.h b/src/gos/gos_arduino.h
index a9b0c140..b14f812a 100644
--- a/src/gos/gos_arduino.h
+++ b/src/gos/gos_arduino.h
@@ -31,29 +31,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-typedef unsigned char	bool_t;
-
-#if 0
-	// Already defined by Arduino
-	typedef signed char		int8_t;
-	typedef unsigned char	uint8_t;
-	typedef signed short	int16_t;
-	typedef unsigned short	uint16_t;
-	typedef signed int		int32_t;
-	typedef unsigned int	uint32_t;
-	typedef uint32_t		size_t;
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	void gfxHalt(const char *msg);
-	void gfxExit(void);
-
-#ifdef __cplusplus
-}
-#endif
+void gfxHalt(const char *msg);
+void gfxExit(void);
 
 /*===========================================================================*/
 /* Use the generic thread handling and heap handling                         */
diff --git a/src/gos/gos_chibios.c b/src/gos/gos_chibios.c
index cb2193fe..725a8763 100644
--- a/src/gos/gos_chibios.c
+++ b/src/gos/gos_chibios.c
@@ -120,34 +120,34 @@ void gfxSemDestroy(gfxSem *psem)
 	chSemReset(&psem->sem, 1);
 }
 
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
 {
 	#if CH_KERNEL_MAJOR == 2
 		switch(ms) {
 		case TIME_IMMEDIATE:	return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != RDY_TIMEOUT;
-		case TIME_INFINITE:		chSemWait(&psem->sem);	return TRUE;
+		case TIME_INFINITE:		chSemWait(&psem->sem);	return gTrue;
 		default:				return chSemWaitTimeout(&psem->sem, MS2ST(ms)) != RDY_TIMEOUT;
 		}
 	#elif (CH_KERNEL_MAJOR == 3) || (CH_KERNEL_MAJOR == 4)
 		switch(ms) {
 		case TIME_IMMEDIATE:	return chSemWaitTimeout(&psem->sem, TIME_IMMEDIATE) != MSG_TIMEOUT;
-		case TIME_INFINITE:		chSemWait(&psem->sem);	return TRUE;
+		case TIME_INFINITE:		chSemWait(&psem->sem);	return gTrue;
 		default:				return chSemWaitTimeout(&psem->sem, MS2ST(ms)) != MSG_TIMEOUT;
 		}
 	#endif
 }
 
-bool_t gfxSemWaitI(gfxSem *psem)
+gBool gfxSemWaitI(gfxSem *psem)
 {
 	#if (CH_KERNEL_MAJOR == 2) || (CH_KERNEL_MAJOR == 3)
 		if (psem->sem.s_cnt <= 0)
-			return FALSE;
+			return gFalse;
 	#elif (CH_KERNEL_MAJOR == 4)
 		if (psem->sem.cnt <= 0)
-			return FALSE;
+			return gFalse;
 	#endif
 	chSemFastWaitI(&psem->sem);
-	return TRUE;
+	return gTrue;
 }
 
 void gfxSemSignal(gfxSem *psem)
diff --git a/src/gos/gos_chibios.h b/src/gos/gos_chibios.h
index cb683631..7c0d1447 100644
--- a/src/gos/gos_chibios.h
+++ b/src/gos/gos_chibios.h
@@ -26,20 +26,10 @@
 /*===========================================================================*/
 
 /**
- * bool_t,
- * int8_t, uint8_t,
- * int16_t, uint16_t,
- * int32_t, uint32_t,
- * size_t
- * TRUE, FALSE
  * TIME_IMMEDIATE, TIME_INFINITE
  * are already defined by ChibiOS
  */
 
-#if (CH_KERNEL_MAJOR == 3) || (CH_KERNEL_MAJOR == 4)
-	typedef char	bool_t;
-#endif
-
 typedef systime_t	delaytime_t;
 typedef systime_t	systemticks_t;
 typedef cnt_t		semcount_t;
@@ -66,7 +56,7 @@ typedef tprio_t		threadpriority_t;
 #elif (CH_KERNEL_MAJOR == 3) || (CH_KERNEL_MAJOR == 4)
 	#undef DECLARE_THREAD_STACK
 	#define DECLARE_THREAD_STACK(a, b)  THD_WORKING_AREA(a, b)
-	
+
 	typedef struct {
 		semaphore_t	sem;
 		semcount_t	limit;
@@ -81,10 +71,6 @@ typedef tprio_t		threadpriority_t;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 // First the kernel version specific ones
 #if CH_KERNEL_MAJOR == 2
 	#define gfxSystemTicks()			chTimeNow()
@@ -113,8 +99,8 @@ void gfxSleepMilliseconds(delaytime_t ms);
 void gfxSleepMicroseconds(delaytime_t ms);
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem *psem);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem *psem);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem *psem);
 void gfxSemSignal(gfxSem *psem);
 void gfxSemSignalI(gfxSem *psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
@@ -122,9 +108,5 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
 #define gfxThreadMe()				chThdSelf()
 #define gfxThreadClose(thread)		(void)thread
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_CHIBIOS */
 #endif /* _GOS_CHIBIOS_H */
diff --git a/src/gos/gos_cmsis.c b/src/gos/gos_cmsis.c
index 2798dcba..5859752b 100644
--- a/src/gos/gos_cmsis.c
+++ b/src/gos/gos_cmsis.c
@@ -61,16 +61,16 @@ void gfxSemDestroy(gfxSem* psem)
 	osSemaphoreDelete(psem->id);
 }
 
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
 {
 	if (osSemaphoreWait(psem->id, ms) > 0) {
 		psem->available++;
-		return TRUE;
+		return gTrue;
 	}
-	return FALSE;
+	return gFalse;
 }
 
-bool_t gfxSemWaitI(gfxSem* psem)
+gBool gfxSemWaitI(gfxSem* psem)
 {
 	return gfxSemWait(psem, 0);
 }
diff --git a/src/gos/gos_cmsis.h b/src/gos/gos_cmsis.h
index aad4cb84..72b59ce9 100644
--- a/src/gos/gos_cmsis.h
+++ b/src/gos/gos_cmsis.h
@@ -15,7 +15,6 @@
 
 #if GFX_USE_OS_CMSIS
 
-#include <stdbool.h>
 #include "cmsis_os.h"
 
 #ifndef GFX_OS_HEAP_SIZE
@@ -26,8 +25,6 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-typedef bool				bool_t;
-
 #define TIME_IMMEDIATE		0
 #define TIME_INFINITE		osWaitForever
 typedef uint32_t			delaytime_t;
@@ -62,10 +59,6 @@ typedef osThreadId			gfxThreadHandle;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define gfxExit()					os_error(0)
 #define gfxHalt(msg)				os_error(1)
 #define gfxSystemTicks()			osKernelSysTick()
@@ -81,8 +74,8 @@ void gfxMutexInit(gfxMutex* pmutex);
 
 void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem* psem);
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem* psem);
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem* psem);
 void gfxSemSignal(gfxSem* psem);
 void gfxSemSignalI(gfxSem* psem);
 
@@ -91,10 +84,6 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
 #define gfxThreadMe()				osThreadGetId()
 #define gfxThreadClose(thread)		{}
 
-#ifdef __cplusplus
-}
-#endif
-
 /*===========================================================================*/
 /* Use the generic heap handling                                             */
 /*===========================================================================*/
diff --git a/src/gos/gos_cmsis2.c b/src/gos/gos_cmsis2.c
index ca2d6eb6..46ee79cb 100644
--- a/src/gos/gos_cmsis2.c
+++ b/src/gos/gos_cmsis2.c
@@ -69,11 +69,11 @@ void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
 	*psem = osSemaphoreNew(limit, val, NULL);
 }
 
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
 {
 	if (osSemaphoreAcquire(*psem, gfxMillisecondsToTicks(ms)) == osOK)
-		return TRUE;
-	return FALSE;
+		return gTrue;
+	return gFalse;
 }
 
 gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
diff --git a/src/gos/gos_cmsis2.h b/src/gos/gos_cmsis2.h
index 1f4eab5e..7504d530 100644
--- a/src/gos/gos_cmsis2.h
+++ b/src/gos/gos_cmsis2.h
@@ -15,7 +15,6 @@
 
 #if GFX_USE_OS_CMSIS2
 
-#include <stdbool.h>
 #include "cmsis_os2.h"
 
 #ifndef GFX_OS_HEAP_SIZE
@@ -26,8 +25,6 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-typedef bool				bool_t;
-
 #define TIME_IMMEDIATE		0
 #define TIME_INFINITE		osWaitForever
 typedef uint32_t			delaytime_t;
@@ -55,10 +52,6 @@ typedef osThreadId_t		gfxThreadHandle;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define gfxExit()					os_error(0)
 #define gfxHalt(msg)				os_error(1)
 #define gfxSystemTicks()			osKernelGetTickCount()
@@ -74,7 +67,7 @@ void gfxMutexInit(gfxMutex* pmutex);
 
 void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
 #define gfxSemDestroy(psem)		osSemaphoreDelete(*(psem))
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
 #define gfxSemWaitI(psem)		gfxSemWait((psem), 0)
 #define gfxSemSignal(psem)		osSemaphoreRelease(*(psem))
 #define gfxSemSignalI(psem)		osSemaphoreRelease(*(psem))
@@ -84,10 +77,6 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
 #define gfxThreadMe()				osThreadGetId()
 #define gfxThreadClose(thread)		{}
 
-#ifdef __cplusplus
-}
-#endif
-
 /*===========================================================================*/
 /* Use the generic heap handling                                             */
 /*===========================================================================*/
diff --git a/src/gos/gos_ecos.c b/src/gos/gos_ecos.c
index a2af5dbf..2f875f0f 100644
--- a/src/gos/gos_ecos.c
+++ b/src/gos/gos_ecos.c
@@ -64,7 +64,7 @@ void gfxSemDestroy(gfxSem *psem)
 	cyg_semaphore_destroy(&psem->sem);
 }
 
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
 {
 	switch(ms) {
 	case TIME_IMMEDIATE:	return cyg_semaphore_trywait(&psem->sem);
@@ -73,7 +73,7 @@ bool_t gfxSemWait(gfxSem *psem, delaytime_t ms)
 	}
 }
 
-bool_t gfxSemWaitI(gfxSem *psem)
+gBool gfxSemWaitI(gfxSem *psem)
 {
 	return cyg_semaphore_trywait(&psem->sem);
 }
diff --git a/src/gos/gos_ecos.h b/src/gos/gos_ecos.h
index b03243f3..910924c0 100644
--- a/src/gos/gos_ecos.h
+++ b/src/gos/gos_ecos.h
@@ -18,15 +18,6 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-typedef cyg_bool_t			bool_t;
-typedef cyg_int8			int8_t;
-typedef cyg_uint8	 		uint8_t;
-typedef cyg_int16	 		int16_t;
-typedef cyg_uint16	 		uint16_t;
-typedef cyg_int32 			int32_t;
-typedef cyg_uint32 			uint32_t;
-typedef cyg_uint32 			size_t;
-
 #define TIME_IMMEDIATE		0
 #define TIME_INFINITE		0xFFFFFFFF
 
@@ -58,10 +49,6 @@ typedef cyg_mutex_t		gfxMutex;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define gfxSystemTicks()			cyg_current_time()
 #define gfxExit()					exit(0)
 #define gfxHalt(msg)				exit(-1)
@@ -85,8 +72,8 @@ void gfxSleepMicroseconds(delaytime_t ms);
 
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem *psem);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem *psem);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem *psem);
 void gfxSemSignal(gfxSem *psem);
 void gfxSemSignalI(gfxSem *psem);
 
@@ -95,9 +82,5 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
 #define gfxThreadMe()				cyg_thread_self()
 #define gfxThreadClose(thread)		(void)thread
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_ECOS */
 #endif /* _GOS_ECOS_H */
diff --git a/src/gos/gos_freertos.c b/src/gos/gos_freertos.c
index ff424e70..025d57b2 100644
--- a/src/gos/gos_freertos.c
+++ b/src/gos/gos_freertos.c
@@ -117,20 +117,20 @@ void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
 	#endif
 }
 
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
 {
 	if (xSemaphoreTake(*psem, gfxMillisecondsToTicks(ms)) == pdPASS)
-		return TRUE;
-	return FALSE;
+		return gTrue;
+	return gFalse;
 }
 
-bool_t gfxSemWaitI(gfxSem* psem)
+gBool gfxSemWaitI(gfxSem* psem)
 {
 	portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
 
 	if (xSemaphoreTakeFromISR(*psem, &xHigherPriorityTaskWoken) == pdTRUE)
-		return TRUE;
-	return FALSE;
+		return gTrue;
+	return gFalse;
 }
 
 void gfxSemSignal(gfxSem* psem)
diff --git a/src/gos/gos_freertos.h b/src/gos/gos_freertos.h
index 87ef8163..e7ee43b8 100644
--- a/src/gos/gos_freertos.h
+++ b/src/gos/gos_freertos.h
@@ -24,29 +24,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-/* Additional types are required when FreeRTOS 7.x is used */
-#if !defined(tskKERNEL_VERSION_MAJOR) && !tskKERNEL_VERSION_MAJOR == 8
-	typedef signed char					int8_t
-	typedef unsigned char				uint8_t
-	typedef signed int					int16_t
-	typedef unsigned int				uint16_t
-	typedef signed long int				int32_t
-	typedef unsigned long int			uint32_t
-	typedef signed long long int		int64_t
-	typedef unsigned long long int		uint64_t
-#endif
-
-/**
- * bool_t,
- * int8_t, uint8_t,
- * int16_t, uint16_t,
- * int32_t, uint32_t,
- * size_t
- * are already defined by FreeRTOS
- */
 #define TIME_IMMEDIATE		0
 #define TIME_INFINITE		((delaytime_t)-1)
-typedef int8_t				bool_t;
 typedef uint32_t			delaytime_t;
 typedef portTickType		systemticks_t;
 typedef int32_t				semcount_t;
@@ -71,10 +50,6 @@ typedef xTaskHandle				gfxThreadHandle;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define gfxHalt(msg)				{while(1);}
 #define gfxExit()					{while(1);}
 #define gfxAlloc(sz)				pvPortMalloc(sz)
@@ -96,8 +71,8 @@ void gfxSleepMicroseconds(delaytime_t ms);
 
 void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
 #define gfxSemDestroy(psem)			vSemaphoreDelete(*(psem))
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem* psem);
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem* psem);
 void gfxSemSignal(gfxSem* psem);
 void gfxSemSignalI(gfxSem* psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
@@ -108,9 +83,5 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
 #endif
 #define gfxThreadClose(thread)
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_FREERTOS */
 #endif /* _GOS_CHIBIOS_H */
diff --git a/src/gos/gos_linux.c b/src/gos/gos_linux.c
index bd4e0060..7e71ca95 100644
--- a/src/gos/gos_linux.c
+++ b/src/gos/gos_linux.c
@@ -145,13 +145,13 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 	void gfxSemDestroy(gfxSem *pSem) {
 		sem_destroy(&pSem->sem);
 	}
-	bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+	gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 		switch (ms) {
 		case TIME_INFINITE:
-			return sem_wait(&pSem->sem) ? FALSE : TRUE;
+			return sem_wait(&pSem->sem) ? gFalse : gTrue;
 
 		case TIME_IMMEDIATE:
-			return sem_trywait(&pSem->sem) ? FALSE : TRUE;
+			return sem_trywait(&pSem->sem) ? gFalse : gTrue;
 
 		default:
 			{
@@ -160,7 +160,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 				clock_gettime(CLOCK_REALTIME, &tm);
 				tm.tv_sec += ms / 1000;
 				tm.tv_nsec += (ms % 1000) * 1000000;
-				return sem_timedwait(&pSem->sem, &tm) ? FALSE : TRUE;
+				return sem_timedwait(&pSem->sem, &tm) ? gFalse : gTrue;
 			}
 		}
 	}
@@ -185,7 +185,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 		pthread_mutex_destroy(&pSem->mtx);
 		pthread_cond_destroy(&pSem->cond);
 	}
-	bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+	gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 		pthread_mutex_lock(&pSem->mtx);
 
 		switch (ms) {
@@ -197,7 +197,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 			case TIME_IMMEDIATE:
 				if (!pSem->cnt) {
 					pthread_mutex_unlock(&pSem->mtx);
-					return FALSE;
+					return gFalse;
 				}
 				break;
 
@@ -211,11 +211,11 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 					while (!pSem->cnt) {
 						// We used to test the return value for ETIMEDOUT. This doesn't
 						//	work in some current pthread libraries which return -1 instead
-						//	and set errno to ETIMEDOUT. So, we will return FALSE on any error
+						//	and set errno to ETIMEDOUT. So, we will return gFalse on any error
 						//	including a ETIMEDOUT.
 						if (pthread_cond_timedwait(&pSem->cond, &pSem->mtx, &tm)) {
 							pthread_mutex_unlock(&pSem->mtx);
-							return FALSE;
+							return gFalse;
 						}
 					}
 				}
@@ -224,7 +224,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
 
 		pSem->cnt--;
 		pthread_mutex_unlock(&pSem->mtx);
-		return TRUE;
+		return gTrue;
 	}
 	void gfxSemSignal(gfxSem *pSem) {
 		pthread_mutex_lock(&pSem->mtx);
diff --git a/src/gos/gos_linux.h b/src/gos/gos_linux.h
index f1973615..3d463226 100644
--- a/src/gos/gos_linux.h
+++ b/src/gos/gos_linux.h
@@ -17,16 +17,12 @@
 
 #include <sys/types.h>
 #include <stdlib.h>
-#include <stdint.h>
 #include <pthread.h>
 
 #if GFX_USE_POSIX_SEMAPHORES
 	#include <semaphore.h>
 #endif
 
-/* Already defined int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, size_t */
-
-typedef int8_t				bool_t;
 typedef unsigned long		systemticks_t;
 typedef void *				threadreturn_t;
 typedef unsigned long		delaytime_t;
@@ -78,10 +74,6 @@ typedef pthread_mutex_t		gfxMutex;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void gfxYield(void);
 void gfxHalt(const char *msg);
 void gfxSleepMilliseconds(delaytime_t ms);
@@ -91,15 +83,11 @@ void gfxSystemLock(void);
 void gfxSystemUnlock(void);
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem *psem);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
 void gfxSemSignal(gfxSem *psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
 threadreturn_t gfxThreadWait(gfxThreadHandle thread);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_LINUX */
 
 #endif /* _GOS_LINUX_H */
diff --git a/src/gos/gos_nios.h b/src/gos/gos_nios.h
index 75bf5676..3ef7756f 100644
--- a/src/gos/gos_nios.h
+++ b/src/gos/gos_nios.h
@@ -10,29 +10,16 @@
 
 #if GFX_USE_OS_NIOS
 
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
 #include <sys/alt_alarm.h>
 
 typedef alt_u32 systemticks_t;
 typedef alt_u32 delaytime_t;
-typedef unsigned char bool_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 void gfxHalt(const char* msg);
 void gfxExit(void);
 systemticks_t gfxSystemTicks(void);
 systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
 
-#ifdef __cplusplus
-}
-#endif
-
-
 // Use the generic thread handling and heap handling
 #define GOS_NEED_X_THREADS	GFXON
 #define GOS_NEED_X_HEAP		GFXON
diff --git a/src/gos/gos_osx.c b/src/gos/gos_osx.c
index 56d64d98..a09647ee 100644
--- a/src/gos/gos_osx.c
+++ b/src/gos/gos_osx.c
@@ -132,7 +132,7 @@ void gfxSemDestroy(gfxSem *pSem) {
 	pthread_cond_destroy(&pSem->cond);
 }
 
-bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 	pthread_mutex_lock(&pSem->mtx);
 	switch (ms) {
 	case TIME_INFINITE:
@@ -142,7 +142,7 @@ bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 	case TIME_IMMEDIATE:
 		if (!pSem->cnt) {
 			pthread_mutex_unlock(&pSem->mtx);
-			return FALSE;
+			return gFalse;
 		}
 		break;
 	default:
@@ -156,11 +156,11 @@ bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 			while (!pSem->cnt) {
 				// We used to test the return value for ETIMEDOUT. This doesn't
 				//	work in some current pthread libraries which return -1 instead
-				//	and set errno to ETIMEDOUT. So, we will return FALSE on any error
+				//	and set errno to ETIMEDOUT. So, we will return gFalse on any error
 				//	including a ETIMEDOUT.
 				if (pthread_cond_timedwait(&pSem->cond, &pSem->mtx, &tm)) {
 					pthread_mutex_unlock(&pSem->mtx);
-					return FALSE;
+					return gFalse;
 				}
 			}
 		}
@@ -168,7 +168,7 @@ bool_t gfxSemWait(gfxSem *pSem, delaytime_t ms) {
 	}
 	pSem->cnt--;
 	pthread_mutex_unlock(&pSem->mtx);
-	return TRUE;
+	return gTrue;
 }
 
 void gfxSemSignal(gfxSem *pSem) {
diff --git a/src/gos/gos_osx.h b/src/gos/gos_osx.h
index 94c67eab..6b5a762a 100644
--- a/src/gos/gos_osx.h
+++ b/src/gos/gos_osx.h
@@ -11,13 +11,9 @@
 #if GFX_USE_OS_OSX
 
 #include <sys/types.h>
-#include <stdint.h>
 #include <pthread.h>
 #include <stdlib.h>
 
-/* Already defined int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, size_t */
-
-typedef int8_t				bool_t;
 typedef unsigned long		systemticks_t;
 typedef void *				threadreturn_t;
 typedef unsigned long		delaytime_t;
@@ -63,10 +59,6 @@ typedef struct gfxSem {
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void gfxHalt(const char *msg);
 void gfxSleepMilliseconds(delaytime_t ms);
 void gfxSleepMicroseconds(delaytime_t ms);
@@ -75,14 +67,10 @@ void gfxSystemLock(void);
 void gfxSystemUnlock(void);
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem *psem);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
 void gfxSemSignal(gfxSem *psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
 threadreturn_t gfxThreadWait(gfxThreadHandle thread);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_OSX */
 #endif /* _GOS_OSX_H */
diff --git a/src/gos/gos_qt.cpp b/src/gos/gos_qt.cpp
index c6eb6f8d..4171d4fe 100644
--- a/src/gos/gos_qt.cpp
+++ b/src/gos/gos_qt.cpp
@@ -165,12 +165,12 @@ void gfxSemDestroy(gfxSem *psem)
     delete static_cast<QSemaphore*>(*psem);
 }
 
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
 {
     return static_cast<QSemaphore*>(*psem)->tryAcquire(1, ms);
 }
 
-bool_t gfxSemWaitI(gfxSem *psem)
+gBool gfxSemWaitI(gfxSem *psem)
 {
     return static_cast<QSemaphore*>(*psem)->tryAcquire(1);
 }
diff --git a/src/gos/gos_qt.h b/src/gos/gos_qt.h
index 75947242..367e2a87 100644
--- a/src/gos/gos_qt.h
+++ b/src/gos/gos_qt.h
@@ -10,10 +10,6 @@
 
 #if GFX_USE_OS_QT
 
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
 #define DECLARE_THREAD_FUNCTION(fnName, param)	threadreturn_t fnName(void *param)
 #define DECLARE_THREAD_STACK(name, sz)          uint8_t name[0]
 #define THREAD_RETURN(retval)					return retval
@@ -25,7 +21,6 @@
 #define NORMAL_PRIORITY				3
 #define HIGH_PRIORITY				4
 
-typedef bool bool_t;
 typedef int systemticks_t;
 typedef int delaytime_t;
 typedef void* gfxMutex;
@@ -35,10 +30,6 @@ typedef int threadreturn_t;
 typedef int threadpriority_t;
 typedef void* gfxThreadHandle;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void _gosInit();
 void _gosDeinit();
 
@@ -60,8 +51,8 @@ void gfxMutexEnter(gfxMutex *pmutex);
 void gfxMutexExit(gfxMutex *pmutex);
 void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 void gfxSemDestroy(gfxSem *psem);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem *psem);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem *psem);
 void gfxSemSignal(gfxSem *psem);
 void gfxSemSignalI(gfxSem *psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
@@ -69,9 +60,5 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread);
 gfxThreadHandle gfxThreadMe(void);
 void gfxThreadClose(gfxThreadHandle thread);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_QT */
 #endif /* _GOS_QT_H */
diff --git a/src/gos/gos_raw32.h b/src/gos/gos_raw32.h
index 5ff38028..6b6bce93 100644
--- a/src/gos/gos_raw32.h
+++ b/src/gos/gos_raw32.h
@@ -29,42 +29,8 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-typedef unsigned char	bool_t;
-
-#if __STDC_VERSION__ >= 199901L
-	#include <stdint.h>
-#elif defined(__GNUC__) || defined(__GNUG__)
-	typedef __INT8_TYPE__	int8_t;
-	typedef __UINT8_TYPE__	uint8_t;
-	typedef __INT16_TYPE__	int16_t;
-	typedef __UINT16_TYPE__	uint16_t;
-	typedef __INT32_TYPE__	int32_t;
-	typedef __UINT32_TYPE__	uint32_t;
-#else
-	typedef signed char		int8_t;
-	typedef unsigned char	uint8_t;
-	typedef signed short	int16_t;
-	typedef unsigned short	uint16_t;
-	typedef signed int		int32_t;
-	typedef unsigned int	uint32_t;
-#endif
-
-#if defined(__STDC__)
-	#include <stddef.h>
-#else
-	typedef uint32_t		size_t;
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	void gfxHalt(const char *msg);
-	void gfxExit(void);
-
-#ifdef __cplusplus
-}
-#endif
+void gfxHalt(const char *msg);
+void gfxExit(void);
 
 /*===========================================================================*/
 /* Use the generic thread handling and heap handling                         */
diff --git a/src/gos/gos_rawrtos.c b/src/gos/gos_rawrtos.c
index 8ff53883..fd50a3f7 100644
--- a/src/gos/gos_rawrtos.c
+++ b/src/gos/gos_rawrtos.c
@@ -59,20 +59,20 @@ void gfxSleepMicroseconds(delaytime_t us)
 	raw_sleep(ticks);
 }
 
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
 {
 	systemticks_t ticks = ms*RAW_TICKS_PER_SECOND/1000;
 	if(!ticks)ticks=1;
 	if(raw_semaphore_get((psem), ticks)==RAW_SUCCESS)
-		return TRUE;
-	return FALSE;
+		return gTrue;
+	return gFalse;
 }
 
-bool_t gfxSemWaitI(gfxSem* psem)
+gBool gfxSemWaitI(gfxSem* psem)
 {
 	if(raw_semaphore_get((psem), TIME_IMMEDIATE)==RAW_SUCCESS)
-		return TRUE;
-	return FALSE;
+		return gTrue;
+	return gFalse;
 }
 
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
diff --git a/src/gos/gos_rawrtos.h b/src/gos/gos_rawrtos.h
index d1026c9d..8dc5549e 100644
--- a/src/gos/gos_rawrtos.h
+++ b/src/gos/gos_rawrtos.h
@@ -4,17 +4,14 @@
 #if GFX_USE_OS_RAWRTOS
 
 #include "raw_api.h"
-#include <stdint.h>
 
 #define TIME_IMMEDIATE		(RAW_NO_WAIT)
 #define TIME_INFINITE		(RAW_WAIT_FOREVER)
-typedef int8_t				bool_t;
 typedef uint32_t			delaytime_t;
 typedef RAW_TICK_TYPE		systemticks_t;
 typedef int32_t				semcount_t;
 typedef uint32_t			threadreturn_t;
 typedef RAW_U8				threadpriority_t;
-typedef uint32_t			size_t;
 
 #define MAX_SEMAPHORE_COUNT	RAW_SEMAPHORE_COUNT
 #define LOW_PRIORITY		(CONFIG_RAW_PRIO_MAX-2)
@@ -53,7 +50,7 @@ typedef RAW_TASK_OBJ*		gfxThreadHandle;
 extern RAW_VOID *raw_malloc(RAW_U32 size);
 extern RAW_VOID raw_free(void *ptr);
 extern RAW_VOID *raw_calloc(RAW_U32 nmemb, RAW_U32 size);
-	
+
 extern RAW_U16 raw_sleep(RAW_TICK_TYPE dly);
 extern RAW_TICK_TYPE  raw_system_time_get(void);
 
@@ -68,8 +65,8 @@ extern RAW_U16 raw_semaphore_put(RAW_SEMAPHORE *semaphore_ptr);
 
 void gfxSleepMilliseconds(delaytime_t ms);
 void gfxSleepMicroseconds(delaytime_t us);
-bool_t gfxSemWait(gfxSem* psem, delaytime_t ms);
-bool_t gfxSemWaitI(gfxSem* psem);
+gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem* psem);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
 
 #endif
diff --git a/src/gos/gos_win32.c b/src/gos/gos_win32.c
index 1aa13dd6..11b2e0aa 100644
--- a/src/gos/gos_win32.c
+++ b/src/gos/gos_win32.c
@@ -74,7 +74,7 @@ void gfxSystemUnlock(void) {
 	ReleaseMutex(SystemMutex);
 }
 
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms) {
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms) {
 	return WaitForSingleObject(*psem, ms) == WAIT_OBJECT_0;
 }
 
diff --git a/src/gos/gos_win32.h b/src/gos/gos_win32.h
index 62602ad3..3cdd5214 100644
--- a/src/gos/gos_win32.h
+++ b/src/gos/gos_win32.h
@@ -25,21 +25,6 @@
 
 #include <malloc.h>
 
-/* Stop cygwin from defining these types */
-#define __int8_t_defined
-
-/**
- * size_t
- * TRUE, FALSE
- * are already defined by Win32
- */
-typedef __int8				bool_t;
-typedef __int8				int8_t;
-typedef unsigned __int8		uint8_t;
-typedef __int16				int16_t;
-typedef unsigned __int16	uint16_t;
-typedef __int32				int32_t;
-typedef unsigned __int32	uint32_t;
 typedef DWORD				delaytime_t;
 typedef DWORD				systemticks_t;
 typedef LONG				semcount_t;
@@ -85,22 +70,14 @@ typedef HANDLE gfxThreadHandle;
 /* Function declarations.                                                    */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void gfxHalt(const char *msg);
 void gfxSleepMicroseconds(delaytime_t ms);
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
 void gfxSystemLock(void);
 void gfxSystemUnlock(void);
 gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param);
 threadreturn_t gfxThreadWait(gfxThreadHandle thread);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GFX_USE_OS_WIN32 */
 #endif /* _GOS_WIN32_H */
 
diff --git a/src/gos/gos_x_heap.h b/src/gos/gos_x_heap.h
index 0fbfc905..1434b991 100644
--- a/src/gos/gos_x_heap.h
+++ b/src/gos/gos_x_heap.h
@@ -14,31 +14,23 @@
 /* Type definitions                                                          */
 /*===========================================================================*/
 
-#ifdef __cplusplus
-extern "C" {
+#if GFX_OS_HEAP_SIZE != 0 || defined(__DOXYGEN__)
+	/**
+	 * @brief	Take a chunk of memory and add it to the available heap
+	 * @note	Memory added must obviously not already be on the heap.
+	 * @note	It is allowable to add multiple non-contiguous blocks of memory
+	 * 			to the heap. If however it is contiguous with a previously added block
+	 * 			it will get merged with the existing block in order to allow
+	 * 			allocations that span the boundary.
+	 * @pre		GFX_OS_HEAP_SIZE != 0 and an operating system that uses the
+	 * 			internal ugfx heap allocator rather than its own allocator.
+	 */
+	void gfxAddHeapBlock(void *ptr, size_t sz);
 #endif
 
-	#if GFX_OS_HEAP_SIZE != 0 || defined(__DOXYGEN__)
-		/**
-		 * @brief	Take a chunk of memory and add it to the available heap
-		 * @note	Memory added must obviously not already be on the heap.
-		 * @note	It is allowable to add multiple non-contiguous blocks of memory
-		 * 			to the heap. If however it is contiguous with a previously added block
-		 * 			it will get merged with the existing block in order to allow
-		 * 			allocations that span the boundary.
-		 * @pre		GFX_OS_HEAP_SIZE != 0 and an operating system that uses the
-		 * 			internal ugfx heap allocator rather than its own allocator.
-		 */
-		void gfxAddHeapBlock(void *ptr, size_t sz);
-	#endif
-
-	void *gfxAlloc(size_t sz);
-	void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
-	void gfxFree(void *ptr);
-
-#ifdef __cplusplus
-}
-#endif
+void *gfxAlloc(size_t sz);
+void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
+void gfxFree(void *ptr);
 
 #endif /* GOS_NEED_X_HEAP */
 #endif /* _GOS_X_HEAP_H */
diff --git a/src/gos/gos_x_threads.c b/src/gos/gos_x_threads.c
index 52afd5c1..efff9f20 100644
--- a/src/gos/gos_x_threads.c
+++ b/src/gos/gos_x_threads.c
@@ -50,7 +50,7 @@ void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) {
 	psem->limit = limit;
 }
 
-bool_t gfxSemWait(gfxSem *psem, delaytime_t ms) {
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms) {
 	systemticks_t	starttm, delay;
 
 	// Convert our delay to ticks
@@ -74,12 +74,12 @@ bool_t gfxSemWait(gfxSem *psem, delaytime_t ms) {
 		// Check if we have exceeded the defined delay
 		switch (delay) {
 		case TIME_IMMEDIATE:
-			return FALSE;
+			return gFalse;
 		case TIME_INFINITE:
 			break;
 		default:
 			if (gfxSystemTicks() - starttm >= delay)
-				return FALSE;
+				return gFalse;
 			break;
 		}
 		gfxYield();
@@ -87,14 +87,14 @@ bool_t gfxSemWait(gfxSem *psem, delaytime_t ms) {
 	}
 	psem->cnt--;
 	INTERRUPTS_ON();
-	return TRUE;
+	return gTrue;
 }
 
-bool_t gfxSemWaitI(gfxSem *psem) {
+gBool gfxSemWaitI(gfxSem *psem) {
 	if (psem->cnt <= 0)
-		return FALSE;
+		return gFalse;
 	psem->cnt--;
-	return TRUE;
+	return gTrue;
 }
 
 void gfxSemSignal(gfxSem *psem) {
@@ -243,7 +243,7 @@ static thread		mainthread;				// The main thread context
 	 * MACROS:
 	 *
 	 *	AUTO_DETECT_STACKFRAME	GFXON/GFXOFF			- GFXON to auto-detect stack frame structure
-	 *	STACK_DIR_UP			Macro/bool_t		- GFXON if the stack grows up instead of down
+	 *	STACK_DIR_UP			Macro/gBool		- GFXON if the stack grows up instead of down
 	 *	MASK1					Macro/uint32_t		- The 1st mask of jmp_buf elements that need relocation
 	 *	MASK2					Macro/uint32_t		- The 2nd mask of jmp_buf elements that need relocation
 	 *	STACK_BASE				Macro/size_t		- The base of the stack frame relative to the local variables
@@ -275,7 +275,7 @@ static thread		mainthread;				// The main thread context
 			jmp_buf		cxt;
 		} saveloc;
 
-		static bool_t		stackdirup;
+		static gBool		stackdirup;
 		static uint32_t		jmpmask1;
 		static uint32_t		jmpmask2;
 		static size_t		stackbase;
@@ -384,7 +384,7 @@ static thread		mainthread;				// The main thread context
 			}
 		#endif
 	}
-	static void _gfxXSwitch(thread *oldt, thread *newt, bool_t doBuildFrame) {
+	static void _gfxXSwitch(thread *oldt, thread *newt, gBool doBuildFrame) {
 
 		// Save the old context
 		if (CXT_SAVE(oldt->cxt)) return;
@@ -415,8 +415,8 @@ static thread		mainthread;				// The main thread context
 		CXT_RESTORE(newt->cxt, 1);
 	}
 
-	#define _gfxTaskSwitch(oldt, newt)		_gfxXSwitch(oldt, newt, FALSE)
-	#define _gfxStartThread(oldt, newt)		_gfxXSwitch(oldt, newt, TRUE)
+	#define _gfxTaskSwitch(oldt, newt)		_gfxXSwitch(oldt, newt, gFalse)
+	#define _gfxStartThread(oldt, newt)		_gfxXSwitch(oldt, newt, gTrue)
 #endif
 #undef GFX_THREADS_DONE
 
diff --git a/src/gos/gos_x_threads.h b/src/gos/gos_x_threads.h
index 546e9e13..7f7b57e7 100644
--- a/src/gos/gos_x_threads.h
+++ b/src/gos/gos_x_threads.h
@@ -49,52 +49,44 @@ typedef struct {
 typedef uint32_t		gfxMutex;
 typedef void *			gfxThreadHandle;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	// Required timing functions - supplied by the user or the operating system
-	systemticks_t gfxSystemTicks(void);
-	systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
-
-	// Sleep Functions
-	void gfxSleepMilliseconds(delaytime_t ms);
-	void gfxSleepMicroseconds(delaytime_t ms);
-	void gfxYield(void);
-
-	// System Locking
-	void gfxSystemLock(void);
-	void gfxSystemUnlock(void);
-
-	// Mutexes
-	void gfxMutexInit(gfxMutex *pmutex);
-	#define gfxMutexDestroy(pmutex)
-	void gfxMutexEnter(gfxMutex *pmutex);
-	void gfxMutexExit(gfxMutex *pmutex);
-
-	// Semaphores
-	void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
-	#define gfxSemDestroy(psem)
-	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-	bool_t gfxSemWaitI(gfxSem *psem);
-	void gfxSemSignal(gfxSem *psem);
-	void gfxSemSignalI(gfxSem *psem);
-
-	// Threads
-	gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
-	#define gfxThreadClose(thread)
-	threadreturn_t gfxThreadWait(gfxThreadHandle thread);
-	gfxThreadHandle gfxThreadMe(void);
-
-	/** The following is not part of the public ugfx API as some operating systems
-	 * 	simply do not provide this capability.
-	 * 	For RAW32 we need it anyway so we might as well declare it here.
-	 */
-	void gfxThreadExit(threadreturn_t ret);
-
-#ifdef __cplusplus
-}
-#endif
+// Required timing functions - supplied by the user or the operating system
+systemticks_t gfxSystemTicks(void);
+systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+
+// Sleep Functions
+void gfxSleepMilliseconds(delaytime_t ms);
+void gfxSleepMicroseconds(delaytime_t ms);
+void gfxYield(void);
+
+// System Locking
+void gfxSystemLock(void);
+void gfxSystemUnlock(void);
+
+// Mutexes
+void gfxMutexInit(gfxMutex *pmutex);
+#define gfxMutexDestroy(pmutex)
+void gfxMutexEnter(gfxMutex *pmutex);
+void gfxMutexExit(gfxMutex *pmutex);
+
+// Semaphores
+void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+#define gfxSemDestroy(psem)
+gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWaitI(gfxSem *psem);
+void gfxSemSignal(gfxSem *psem);
+void gfxSemSignalI(gfxSem *psem);
+
+// Threads
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+#define gfxThreadClose(thread)
+threadreturn_t gfxThreadWait(gfxThreadHandle thread);
+gfxThreadHandle gfxThreadMe(void);
+
+/** The following is not part of the public ugfx API as some operating systems
+ * 	simply do not provide this capability.
+ * 	For RAW32 we need it anyway so we might as well declare it here.
+ */
+void gfxThreadExit(threadreturn_t ret);
 
 #endif /* GOS_NEED_X_THREADS */
 #endif /* _GOS_X_THREADS_H */
diff --git a/src/gos/gos_zephyr.h b/src/gos/gos_zephyr.h
index 0acb2c43..07f9107b 100644
--- a/src/gos/gos_zephyr.h
+++ b/src/gos/gos_zephyr.h
@@ -10,99 +10,79 @@
 

 #if GFX_USE_OS_ZEPHYR

 

-// #include <stdbool.h>

-// #include <stdint.h>

-

 #include <zephyr.h>

 

-	/*===========================================================================*/

-	/* Type definitions                                                          */

-	/*===========================================================================*/

-

-	typedef bool	bool_t;

-	typedef s8_t	int8_t;

-	typedef u8_t	uint8_t;

-	typedef s16_t	int16_t;

-	typedef u16_t	uint16_t;

-	typedef s32_t	int32_t;

-	typedef u32_t	uint32_t;

-

-	// typedef unsigned long	size_t;

-	typedef s32_t 	delaytime_t;

-	typedef u32_t	systemticks_t;

-	typedef u32_t	semcount_t;

-	typedef void	threadreturn_t;

-	typedef int	threadpriority_t;

-

-	#define DECLARE_THREAD_FUNCTION(fnName, param)\

-		threadreturn_t fnName(void* param, void* p2, void* p3)

-

-	#define DECLARE_THREAD_STACK(name, sz)\

-		K_THREAD_STACK_DEFINE(name, sz)

-

-	#define THREAD_RETURN(retval)		return

-

-	#define TIME_IMMEDIATE			K_NO_WAIT

-	#define TIME_INFINITE			K_FOREVER

-	#define MAX_SEMAPHORE_COUNT		((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))

-	#define LOW_PRIORITY			CONFIG_NUM_PREEMPT_PRIORITIES-1

-	#define NORMAL_PRIORITY			1

-	#define HIGH_PRIORITY			0

-

-	typedef struct k_sem gfxSem;

-

-	typedef struct k_mutex gfxMutex;

-

-	typedef k_tid_t gfxThreadHandle;

-

-	/*===========================================================================*/

-	/* Function declarations.                                                    */

-	/*===========================================================================*/

-

-	#ifdef __cplusplus

-	extern "C" {

-	#endif

-

-	#define gfxHalt(msg)	do{}while(0)

-	#define gfxExit()		do{}while(0)

-

-	// Don't forget to set CONFIG_HEAP_MEM_POOL_SIZE

-	 #define gfxAlloc(sz)					k_malloc(sz)

-	 #define gfxFree(ptr)					k_free(ptr)

-	 #define gfxRealloc(ptr, oldsz, newsz)	do{}while(0)

-

-	 #define gfxYield()						k_yield()

-	 #define gfxSleepMilliseconds(ms)		k_sleep(ms)

-	 #define gfxSleepMicroseconds(us)		do{}while(0)

-	 #define gfxMillisecondsToTicks(ms)		CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000

-	 systemticks_t gfxSystemTicks();

-

-	 #define gfxSystemLock()		k_sched_lock()

-	 #define gfxSystemUnlock()		k_sched_unlock()

-

-	 #define gfxMutexInit(pmutex)		k_mutex_init(pmutex)

-	 #define gfxMutexDestroy(pmutex)	do{}while(0)

-	 #define gfxMutexEnter(pmutex)		k_mutex_lock(pmutex, K_FOREVER)

-	 #define gfxMutexExit(pmutex)		k_mutex_unlock(pmutex)

-

-	 #define gfxSemInit(psem, val, limit) 	k_sem_init(psem, val, limit)

-	 #define gfxSemDestroy(psem)			do{}while(0)

-	 #define gfxSemWait(psem, ms)  			(k_sem_take(psem, ms) == 0) ? TRUE : FALSE

-	 #define gfxSemWaitI(psem) 				(k_sem_take(psem, K_NO_WAIT) == 0) ? TRUE : FALSE

-	 #define gfxSemSignal(psem)				k_sem_give(psem)

-	 #define gfxSemSignalI(psem)			k_sem_give(psem)

-	 #define gfxSemCounter(psem)			k_sem_count_get(psem)

-	 #define gfxSemCounterI(psem)			k_sem_count_get(psem)

-

-	#define gfxThreadCreate(stackarea, stacksz, prio, fn, param)\

-		k_thread_spawn(stackarea, stacksz, fn, param, NULL, NULL, prio, 0, K_NO_WAIT)

-	#define gfxThreadWait(thread)		0

-	#define gfxThreadMe()				k_current_get()

-	#define gfxThreadClose(thread)		k_thread_abort(thread)

-

-	#ifdef __cplusplus

-	}

-	#endif

+/*===========================================================================*/

+/* Type definitions                                                          */

+/*===========================================================================*/

+

+typedef s32_t 	delaytime_t;

+typedef u32_t	systemticks_t;

+typedef u32_t	semcount_t;

+typedef void	threadreturn_t;

+typedef int	threadpriority_t;

+

+#define DECLARE_THREAD_FUNCTION(fnName, param)\

+	threadreturn_t fnName(void* param, void* p2, void* p3)

+

+#define DECLARE_THREAD_STACK(name, sz)\

+	K_THREAD_STACK_DEFINE(name, sz)

+

+#define THREAD_RETURN(retval)		return

+

+#define TIME_IMMEDIATE			K_NO_WAIT

+#define TIME_INFINITE			K_FOREVER

+#define MAX_SEMAPHORE_COUNT		((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))

+#define LOW_PRIORITY			CONFIG_NUM_PREEMPT_PRIORITIES-1

+#define NORMAL_PRIORITY			1

+#define HIGH_PRIORITY			0

+

+typedef struct k_sem gfxSem;

+

+typedef struct k_mutex gfxMutex;

+

+typedef k_tid_t gfxThreadHandle;

+

+/*===========================================================================*/

+/* Function declarations.                                                    */

+/*===========================================================================*/

+

+#define gfxHalt(msg)	do{}while(0)

+#define gfxExit()		do{}while(0)

+

+// Don't forget to set CONFIG_HEAP_MEM_POOL_SIZE

+#define gfxAlloc(sz)					k_malloc(sz)

+#define gfxFree(ptr)					k_free(ptr)

+#define gfxRealloc(ptr, oldsz, newsz)	do{}while(0)

+

+#define gfxYield()						k_yield()

+#define gfxSleepMilliseconds(ms)		k_sleep(ms)

+#define gfxSleepMicroseconds(us)		do{}while(0)

+#define gfxMillisecondsToTicks(ms)		CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000

+systemticks_t gfxSystemTicks();

+

+#define gfxSystemLock()					k_sched_lock()

+#define gfxSystemUnlock()				k_sched_unlock()

+

+#define gfxMutexInit(pmutex)			k_mutex_init(pmutex)

+#define gfxMutexDestroy(pmutex)			do{}while(0)

+#define gfxMutexEnter(pmutex)			k_mutex_lock(pmutex, K_FOREVER)

+#define gfxMutexExit(pmutex)			k_mutex_unlock(pmutex)

+

+#define gfxSemInit(psem, val, limit) 	k_sem_init(psem, val, limit)

+#define gfxSemDestroy(psem)				do{}while(0)

+#define gfxSemWait(psem, ms)  			(k_sem_take(psem, ms) == 0) ? gTrue : gFalse

+#define gfxSemWaitI(psem) 				(k_sem_take(psem, K_NO_WAIT) == 0) ? gTrue : gFalse

+#define gfxSemSignal(psem)				k_sem_give(psem)

+#define gfxSemSignalI(psem)				k_sem_give(psem)

+#define gfxSemCounter(psem)				k_sem_count_get(psem)

+#define gfxSemCounterI(psem)			k_sem_count_get(psem)

+

+#define gfxThreadCreate(stackarea, stacksz, prio, fn, param)\

+	k_thread_spawn(stackarea, stacksz, fn, param, NULL, NULL, prio, 0, K_NO_WAIT)

+#define gfxThreadWait(thread)			0

+#define gfxThreadMe()					k_current_get()

+#define gfxThreadClose(thread)			k_thread_abort(thread)

 

 #endif /* GFX_USE_OS_ZEPHYR */

 #endif /* _GOS_H */