aboutsummaryrefslogtreecommitdiffstats
path: root/src/gos
diff options
context:
space:
mode:
Diffstat (limited to 'src/gos')
-rw-r--r--src/gos/gos.h39
-rw-r--r--src/gos/gos_arduino.c4
-rw-r--r--src/gos/gos_arduino.h4
-rw-r--r--src/gos/gos_chibios.c10
-rw-r--r--src/gos/gos_chibios.h30
-rw-r--r--src/gos/gos_cmsis.c8
-rw-r--r--src/gos/gos_cmsis.h20
-rw-r--r--src/gos/gos_cmsis2.c8
-rw-r--r--src/gos/gos_cmsis2.h18
-rw-r--r--src/gos/gos_ecos.c10
-rw-r--r--src/gos/gos_ecos.h24
-rw-r--r--src/gos/gos_freertos.c12
-rw-r--r--src/gos/gos_freertos.h32
-rw-r--r--src/gos/gos_linux.c20
-rw-r--r--src/gos/gos_linux.h36
-rw-r--r--src/gos/gos_nios.c4
-rw-r--r--src/gos/gos_nios.h8
-rw-r--r--src/gos/gos_osx.c16
-rw-r--r--src/gos/gos_osx.h34
-rw-r--r--src/gos/gos_qt.cpp24
-rw-r--r--src/gos/gos_qt.h32
-rw-r--r--src/gos/gos_raw32.c4
-rw-r--r--src/gos/gos_raw32.h4
-rw-r--r--src/gos/gos_rawrtos.c14
-rw-r--r--src/gos/gos_rawrtos.h20
-rw-r--r--src/gos/gos_win32.c10
-rw-r--r--src/gos/gos_win32.h22
-rw-r--r--src/gos/gos_x_threads.c24
-rw-r--r--src/gos/gos_x_threads.h40
-rw-r--r--src/gos/gos_zephyr.c2
-rw-r--r--src/gos/gos_zephyr.h16
31 files changed, 278 insertions, 271 deletions
diff --git a/src/gos/gos.h b/src/gos/gos.h
index f68c9fda..5db10fef 100644
--- a/src/gos/gos.h
+++ b/src/gos/gos.h
@@ -57,11 +57,11 @@
* @note Your platform may use slightly different definitions to these
* @{
*/
- typedef unsigned long delaytime_t;
- typedef unsigned long systemticks_t;
- typedef short semcount_t;
- typedef int threadreturn_t;
- typedef int threadpriority_t;
+ typedef unsigned long gDelay;
+ typedef unsigned long gTicks;
+ typedef short gSemcount;
+ typedef int gThreadreturn;
+ typedef int gThreadpriority;
/** @} */
/**
@@ -70,7 +70,7 @@
* @param[in] fnName The name of the function
* @param[in] param A custom parameter that is passed to the function
*/
- #define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+ #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
/**
* @brief Declare a thread stack
@@ -100,8 +100,8 @@
* @{
*/
#define TIME_IMMEDIATE 0
- #define TIME_INFINITE ((delaytime_t)-1)
- #define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+ #define TIME_INFINITE ((gDelay)-1)
+ #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 0
#define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 2
@@ -221,7 +221,7 @@
*
* @api
*/
- void gfxSleepMilliseconds(delaytime_t ms);
+ void gfxSleepMilliseconds(gDelay ms);
/**
* @brief Put the current thread to sleep for the specified period in microseconds
@@ -233,7 +233,7 @@
*
* @api
*/
- void gfxSleepMicroseconds(delaytime_t us);
+ void gfxSleepMicroseconds(gDelay us);
/**
* @brief Get the current operating system tick time
@@ -249,7 +249,7 @@
*
* @api
*/
- systemticks_t gfxSystemTicks(void);
+ gTicks gfxSystemTicks(void);
/**
* @brief Convert a given number of millseconds to a number of operating system ticks
@@ -262,7 +262,7 @@
*
* @api
*/
- systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+ gTicks gfxMillisecondsToTicks(gDelay ms);
/**
* @brief Lock the operating system to protect a sequence of code
@@ -344,7 +344,7 @@
*
* @api
*/
- void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+ void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
/**
* @brief Destroy a Counted Semaphore
@@ -368,7 +368,7 @@
*
* @api
*/
- gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+ gBool gfxSemWait(gfxSem *psem, gDelay ms);
/**
* @brief Test if a wait on a semaphore can be satisfied immediately
@@ -420,7 +420,7 @@
*
* @api
*/
- gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
/**
* @brief Wait for a thread to finish.
@@ -432,7 +432,7 @@
* once the thread has ended.
* @api
*/
- threadreturn_t gfxThreadWait(gfxThreadHandle thread);
+ gThreadreturn gfxThreadWait(gfxThreadHandle thread);
/**
* @brief Get the current thread handle.
@@ -493,5 +493,12 @@
#error "Your operating system is not supported yet"
#endif
+#if GFX_COMPAT_V2
+ typedef gDelay delaytime_t;
+ typedef gTicks systemticks_t;
+ typedef gThreadreturn threadreturn_t;
+ typedef gThreadpriority threadpriority_t;
+#endif
+
#endif /* _GOS_H */
/** @} */
diff --git a/src/gos/gos_arduino.c b/src/gos/gos_arduino.c
index 0eec8957..f1e0b340 100644
--- a/src/gos/gos_arduino.c
+++ b/src/gos/gos_arduino.c
@@ -72,10 +72,10 @@ void gfxExit(void) {
* Sleep functions
*********************************************************/
-systemticks_t gfxSystemTicks(void) {
+gTicks gfxSystemTicks(void) {
return millis();
}
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms) {
+gTicks gfxMillisecondsToTicks(gDelay ms) {
return ms;
}
diff --git a/src/gos/gos_arduino.h b/src/gos/gos_arduino.h
index b14f812a..7aadfa75 100644
--- a/src/gos/gos_arduino.h
+++ b/src/gos/gos_arduino.h
@@ -17,8 +17,8 @@
* malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0
*
* You must also define the following routines in your own code so that timing functions will work...
- * systemticks_t gfxSystemTicks(void);
- * systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+ * gTicks gfxSystemTicks(void);
+ * gTicks gfxMillisecondsToTicks(gDelay ms);
*/
#ifndef _GOS_ARDUINO_H
#define _GOS_ARDUINO_H
diff --git a/src/gos/gos_chibios.c b/src/gos/gos_chibios.c
index 4d2358b5..ef7a3336 100644
--- a/src/gos/gos_chibios.c
+++ b/src/gos/gos_chibios.c
@@ -81,7 +81,7 @@ void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz)
return np;
}
-void gfxSleepMilliseconds(delaytime_t ms)
+void gfxSleepMilliseconds(gDelay ms)
{
switch(ms) {
case TIME_IMMEDIATE: chThdYield(); return;
@@ -90,7 +90,7 @@ void gfxSleepMilliseconds(delaytime_t ms)
}
}
-void gfxSleepMicroseconds(delaytime_t ms)
+void gfxSleepMicroseconds(gDelay ms)
{
switch(ms) {
case TIME_IMMEDIATE: return;
@@ -99,7 +99,7 @@ void gfxSleepMicroseconds(delaytime_t ms)
}
}
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{
if (val > limit)
val = limit;
@@ -118,7 +118,7 @@ void gfxSemDestroy(gfxSem *psem)
chSemReset(&psem->sem, 1);
}
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, gDelay ms)
{
#if CH_KERNEL_MAJOR <= 2
switch(ms) {
@@ -175,7 +175,7 @@ void gfxSemSignalI(gfxSem *psem)
#endif
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{
if (!stackarea) {
if (!stacksz) stacksz = 256;
diff --git a/src/gos/gos_chibios.h b/src/gos/gos_chibios.h
index e1c5839f..77680a9c 100644
--- a/src/gos/gos_chibios.h
+++ b/src/gos/gos_chibios.h
@@ -31,28 +31,28 @@
*/
#if CH_KERNEL_MAJOR <= 4
- typedef systime_t delaytime_t;
+ typedef systime_t gDelay;
#else
- typedef sysinterval_t delaytime_t;
+ typedef sysinterval_t gDelay;
#endif
-typedef systime_t systemticks_t;
-typedef cnt_t semcount_t;
-typedef msg_t threadreturn_t;
-typedef tprio_t threadpriority_t;
+typedef systime_t gTicks;
+typedef cnt_t gSemcount;
+typedef msg_t gThreadreturn;
+typedef tprio_t gThreadpriority;
-#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY LOWPRIO
#define NORMAL_PRIORITY NORMALPRIO
#define HIGH_PRIORITY HIGHPRIO
#define DECLARE_THREAD_STACK(name, sz) WORKING_AREA(name, sz)
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define THREAD_RETURN(retval) return retval
#if CH_KERNEL_MAJOR <= 2
typedef struct {
Semaphore sem;
- semcount_t limit;
+ gSemcount limit;
} gfxSem;
typedef Mutex gfxMutex;
@@ -63,7 +63,7 @@ typedef tprio_t threadpriority_t;
typedef struct {
semaphore_t sem;
- semcount_t limit;
+ gSemcount limit;
} gfxSem;
typedef mutex_t gfxMutex;
@@ -104,15 +104,15 @@ typedef tprio_t threadpriority_t;
#define gfxMutexDestroy(pmutex) (void)pmutex
#define gfxMutexEnter(pmutex) chMtxLock(pmutex)
void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadWait(thread) chThdWait(thread)
#define gfxThreadMe() chThdSelf()
#define gfxThreadClose(thread) (void)thread
diff --git a/src/gos/gos_cmsis.c b/src/gos/gos_cmsis.c
index 5859752b..00316142 100644
--- a/src/gos/gos_cmsis.c
+++ b/src/gos/gos_cmsis.c
@@ -46,7 +46,7 @@ void gfxMutexInit(gfxMutex* pmutex)
pmutex->id = osMutexCreate(&def);
}
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{
osSemaphoreDef_t def;
def.semaphore = psem->semaphore;
@@ -61,7 +61,7 @@ void gfxSemDestroy(gfxSem* psem)
osSemaphoreDelete(psem->id);
}
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, gDelay ms)
{
if (osSemaphoreWait(psem->id, ms) > 0) {
psem->available++;
@@ -88,7 +88,7 @@ void gfxSemSignalI(gfxSem* psem)
}
}
-gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
+gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
{
osThreadDef_t def;
@@ -102,7 +102,7 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
return osThreadCreate(&def, param);
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
+gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while(osThreadGetPriority(thread) == osPriorityError)
gfxYield();
}
diff --git a/src/gos/gos_cmsis.h b/src/gos/gos_cmsis.h
index 72b59ce9..4473b9d1 100644
--- a/src/gos/gos_cmsis.h
+++ b/src/gos/gos_cmsis.h
@@ -27,11 +27,11 @@
#define TIME_IMMEDIATE 0
#define TIME_INFINITE osWaitForever
-typedef uint32_t delaytime_t;
-typedef uint32_t systemticks_t;
-typedef uint16_t semcount_t;
-typedef void threadreturn_t;
-typedef osPriority threadpriority_t;
+typedef uint32_t gDelay;
+typedef uint32_t gTicks;
+typedef uint16_t gSemcount;
+typedef void gThreadreturn;
+typedef osPriority gThreadpriority;
#define MAX_SEMAPHORE_COUNT osFeature_Semaphore
#define LOW_PRIORITY osPriorityLow
@@ -41,7 +41,7 @@ typedef osPriority threadpriority_t;
typedef struct gfxSem {
uint32_t semaphore[2];
osSemaphoreId id;
- semcount_t available;
+ gSemcount available;
} gfxSem;
typedef struct gfxMutex {
@@ -52,7 +52,7 @@ typedef struct gfxMutex {
typedef osThreadId gfxThreadHandle;
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void* param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void* param)
#define THREAD_RETURN(retval)
/*===========================================================================*/
@@ -72,14 +72,14 @@ void gfxMutexInit(gfxMutex* pmutex);
#define gfxMutexEnter(pmutex) osMutexWait((pmutex)->id, TIME_INFINITE)
#define gfxMutexExit(pmutex) osMutexRelease((pmutex)->id)
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem* psem);
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem* psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param);
#define gfxYield() osThreadYield()
#define gfxThreadMe() osThreadGetId()
#define gfxThreadClose(thread) {}
diff --git a/src/gos/gos_cmsis2.c b/src/gos/gos_cmsis2.c
index 46ee79cb..31c79164 100644
--- a/src/gos/gos_cmsis2.c
+++ b/src/gos/gos_cmsis2.c
@@ -64,19 +64,19 @@ void gfxMutexInit(gfxMutex* pmutex)
*pmutex = osMutexNew(NULL);
}
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{
*psem = osSemaphoreNew(limit, val, NULL);
}
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, gDelay ms)
{
if (osSemaphoreAcquire(*psem, gfxMillisecondsToTicks(ms)) == osOK)
return gTrue;
return gFalse;
}
-gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
+gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
{
osThreadAttr_t def;
@@ -93,7 +93,7 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
return osThreadNew((osThreadFunc_t)fn, param, &def);
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
+gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while(1) {
switch(osThreadGetState(thread)) {
case osThreadReady:
diff --git a/src/gos/gos_cmsis2.h b/src/gos/gos_cmsis2.h
index 7504d530..a6cde139 100644
--- a/src/gos/gos_cmsis2.h
+++ b/src/gos/gos_cmsis2.h
@@ -27,11 +27,11 @@
#define TIME_IMMEDIATE 0
#define TIME_INFINITE osWaitForever
-typedef uint32_t delaytime_t;
-typedef uint32_t systemticks_t;
-typedef uint16_t semcount_t;
-typedef void threadreturn_t;
-typedef osPriority_t threadpriority_t;
+typedef uint32_t gDelay;
+typedef uint32_t gTicks;
+typedef uint16_t gSemcount;
+typedef void gThreadreturn;
+typedef osPriority_t gThreadpriority;
#define MAX_SEMAPHORE_COUNT 65535UL
#define LOW_PRIORITY osPriorityLow
@@ -45,7 +45,7 @@ typedef osMutexId_t gfxMutex;
typedef osThreadId_t gfxThreadHandle;
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void* param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void* param)
#define THREAD_RETURN(retval)
/*===========================================================================*/
@@ -65,14 +65,14 @@ void gfxMutexInit(gfxMutex* pmutex);
#define gfxMutexEnter(pmutex) osMutexAcquire(*(pmutex), TIME_INFINITE)
#define gfxMutexExit(pmutex) osMutexRelease(*(pmutex))
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem) osSemaphoreDelete(*(psem))
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem* psem, gDelay ms);
#define gfxSemWaitI(psem) gfxSemWait((psem), 0)
#define gfxSemSignal(psem) osSemaphoreRelease(*(psem))
#define gfxSemSignalI(psem) osSemaphoreRelease(*(psem))
-gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param);
+gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param);
#define gfxYield() osThreadYield()
#define gfxThreadMe() osThreadGetId()
#define gfxThreadClose(thread) {}
diff --git a/src/gos/gos_ecos.c b/src/gos/gos_ecos.c
index 2f875f0f..9b38d3b0 100644
--- a/src/gos/gos_ecos.c
+++ b/src/gos/gos_ecos.c
@@ -32,7 +32,7 @@ void _gosDeinit(void)
/* ToDo */
}
-void gfxSleepMilliseconds(delaytime_t ms)
+void gfxSleepMilliseconds(gDelay ms)
{
switch(ms) {
case TIME_IMMEDIATE: cyg_thread_yield(); return;
@@ -41,7 +41,7 @@ void gfxSleepMilliseconds(delaytime_t ms)
}
}
-void gfxSleepMicroseconds(delaytime_t ms)
+void gfxSleepMicroseconds(gDelay ms)
{
switch(ms) {
case TIME_IMMEDIATE: return;
@@ -50,7 +50,7 @@ void gfxSleepMicroseconds(delaytime_t ms)
}
}
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{
if (val > limit)
val = limit;
@@ -64,7 +64,7 @@ void gfxSemDestroy(gfxSem *psem)
cyg_semaphore_destroy(&psem->sem);
}
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, gDelay ms)
{
switch(ms) {
case TIME_IMMEDIATE: return cyg_semaphore_trywait(&psem->sem);
@@ -96,7 +96,7 @@ void gfxSemSignalI(gfxSem *psem)
cyg_semaphore_post(&psem->sem);
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{
gfxThreadHandle th;
diff --git a/src/gos/gos_ecos.h b/src/gos/gos_ecos.h
index 910924c0..6f360ba1 100644
--- a/src/gos/gos_ecos.h
+++ b/src/gos/gos_ecos.h
@@ -21,11 +21,11 @@
#define TIME_IMMEDIATE 0
#define TIME_INFINITE 0xFFFFFFFF
-typedef cyg_ucount32 delaytime_t;
-typedef cyg_tick_count_t systemticks_t;
-typedef cyg_count32 semcount_t;
-typedef void threadreturn_t;
-typedef cyg_addrword_t threadpriority_t;
+typedef cyg_ucount32 gDelay;
+typedef cyg_tick_count_t gTicks;
+typedef cyg_count32 gSemcount;
+typedef void gThreadreturn;
+typedef cyg_addrword_t gThreadpriority;
typedef cyg_handle_t gfxThreadHandle;
#define MAX_SEMAPHORE_COUNT 0x7FFFFFFF
@@ -34,12 +34,12 @@ typedef cyg_handle_t gfxThreadHandle;
#define HIGH_PRIORITY 0
#define DECLARE_THREAD_STACK(name, sz) struct { cyg_thread t; unsigned char stk[(sz) & ~3]; } name[1]
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(cyg_addrword_t param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(cyg_addrword_t param)
#define THREAD_RETURN(retval)
typedef struct {
cyg_sem_t sem;
- semcount_t limit;
+ gSemcount limit;
} gfxSem;
typedef cyg_mutex_t gfxMutex;
@@ -55,8 +55,8 @@ typedef cyg_mutex_t gfxMutex;
#define gfxYield() cyg_thread_yield()
#define gfxMillisecondsToTicks(ms) (((ms)*(CYGNUM_HAL_RTC_DENOMINATOR*1000))/(CYGNUM_HAL_RTC_NUMERATOR/1000))
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
#define gfxAlloc(sz) malloc(sz)
#define gfxFree(ptr) free(ptr)
@@ -70,14 +70,14 @@ void gfxSleepMicroseconds(delaytime_t ms);
#define gfxMutexDestroy(pmutex) cyg_mutex_destroy(pmutex)
#define gfxMutexEnter(pmutex) cyg_mutex_lock(pmutex)
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadWait(thread) NOTIMPLEMENTED_YET
#define gfxThreadMe() cyg_thread_self()
#define gfxThreadClose(thread) (void)thread
diff --git a/src/gos/gos_freertos.c b/src/gos/gos_freertos.c
index 025d57b2..d4aa0462 100644
--- a/src/gos/gos_freertos.c
+++ b/src/gos/gos_freertos.c
@@ -85,12 +85,12 @@ void* gfxRealloc(void *ptr, size_t oldsz, size_t newsz)
return np;
}
-void gfxSleepMilliseconds(delaytime_t ms)
+void gfxSleepMilliseconds(gDelay ms)
{
vTaskDelay(gfxMillisecondsToTicks(ms));
}
-void gfxSleepMicroseconds(delaytime_t ms)
+void gfxSleepMicroseconds(gDelay ms)
{
// delay milli seconds - microsecond resolution delay is not supported in FreeRTOS
@@ -106,7 +106,7 @@ void gfxMutexInit(gfxMutex *pmutex)
#endif
}
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{
if (val > limit)
val = limit;
@@ -117,7 +117,7 @@ void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
#endif
}
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, gDelay ms)
{
if (xSemaphoreTake(*psem, gfxMillisecondsToTicks(ms)) == pdPASS)
return gTrue;
@@ -146,7 +146,7 @@ void gfxSemSignalI(gfxSem* psem)
xSemaphoreGiveFromISR(*psem,&xHigherPriorityTaskWoken);
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{
gfxThreadHandle task;
(void) stackarea;
@@ -165,7 +165,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
}
#if INCLUDE_eTaskGetState == 1
- threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
+ gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while (eTaskGetState(thread) != eDeleted)
gfxYield();
}
diff --git a/src/gos/gos_freertos.h b/src/gos/gos_freertos.h
index e7ee43b8..68831d02 100644
--- a/src/gos/gos_freertos.h
+++ b/src/gos/gos_freertos.h
@@ -25,21 +25,21 @@
/*===========================================================================*/
#define TIME_IMMEDIATE 0
-#define TIME_INFINITE ((delaytime_t)-1)
-typedef uint32_t delaytime_t;
-typedef portTickType systemticks_t;
-typedef int32_t semcount_t;
-typedef void threadreturn_t;
-typedef portBASE_TYPE threadpriority_t;
-
-#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define TIME_INFINITE ((gDelay)-1)
+typedef uint32_t gDelay;
+typedef portTickType gTicks;
+typedef int32_t gSemcount;
+typedef void gThreadreturn;
+typedef portBASE_TYPE gThreadpriority;
+
+#define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 0
#define NORMAL_PRIORITY configMAX_PRIORITIES/2
#define HIGH_PRIORITY configMAX_PRIORITIES-1
/* FreeRTOS will allocate the stack when creating the thread */
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define THREAD_RETURN(retval)
typedef xSemaphoreHandle gfxSem;
@@ -56,7 +56,7 @@ typedef xTaskHandle gfxThreadHandle;
#define gfxFree(ptr) vPortFree(ptr)
#define gfxYield() taskYIELD()
#define gfxSystemTicks() xTaskGetTickCount()
-#define gfxMillisecondsToTicks(ms) ((systemticks_t)((ms) / portTICK_PERIOD_MS))
+#define gfxMillisecondsToTicks(ms) ((gTicks)((ms) / portTICK_PERIOD_MS))
#define gfxSystemLock() taskENTER_CRITICAL()
#define gfxSystemUnlock() taskEXIT_CRITICAL()
@@ -66,20 +66,20 @@ void gfxMutexInit(gfxMutex* s);
#define gfxMutexExit(pmutex) xSemaphoreGive(*(pmutex))
void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
-void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem) vSemaphoreDelete(*(psem))
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem* psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadMe() xTaskGetCurrentTaskHandle()
#if INCLUDE_eTaskGetState == 1
- threadreturn_t gfxThreadWait(gfxThreadHandle thread);
+ gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif
#define gfxThreadClose(thread)
diff --git a/src/gos/gos_linux.c b/src/gos/gos_linux.c
index 7e71ca95..ca6b2576 100644
--- a/src/gos/gos_linux.c
+++ b/src/gos/gos_linux.c
@@ -60,7 +60,7 @@ void gfxHalt(const char *msg) {
exit(1);
}
-void gfxSleepMilliseconds(delaytime_t ms) {
+void gfxSleepMilliseconds(gDelay ms) {
struct timespec ts;
switch(ms) {
@@ -81,7 +81,7 @@ void gfxSleepMilliseconds(delaytime_t ms) {
}
}
-void gfxSleepMicroseconds(delaytime_t us) {
+void gfxSleepMicroseconds(gDelay us) {
struct timespec ts;
switch(us) {
@@ -102,14 +102,14 @@ void gfxSleepMicroseconds(delaytime_t us) {
}
}
-systemticks_t gfxSystemTicks(void) {
+gTicks gfxSystemTicks(void) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
gfxThreadHandle th;
(void) stackarea;
(void) stacksz;
@@ -128,8 +128,8 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return th;
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
- threadreturn_t retval;
+gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
+ gThreadreturn retval;
if (pthread_join(thread, &retval))
return 0;
@@ -138,14 +138,14 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
}
#if GFX_USE_POSIX_SEMAPHORES
- void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) {
+ void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pSem->max = limit;
sem_init(&pSem->sem, 0, val);
}
void gfxSemDestroy(gfxSem *pSem) {
sem_destroy(&pSem->sem);
}
- gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+ gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
switch (ms) {
case TIME_INFINITE:
return sem_wait(&pSem->sem) ? gFalse : gTrue;
@@ -173,7 +173,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
sem_post(&pSem->sem);
}
#else
- void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) {
+ void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pthread_mutex_init(&pSem->mtx, 0);
pthread_cond_init(&pSem->cond, 0);
pthread_mutex_lock(&pSem->mtx);
@@ -185,7 +185,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
pthread_mutex_destroy(&pSem->mtx);
pthread_cond_destroy(&pSem->cond);
}
- gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+ gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
pthread_mutex_lock(&pSem->mtx);
switch (ms) {
diff --git a/src/gos/gos_linux.h b/src/gos/gos_linux.h
index 3d463226..201ee61c 100644
--- a/src/gos/gos_linux.h
+++ b/src/gos/gos_linux.h
@@ -23,15 +23,15 @@
#include <semaphore.h>
#endif
-typedef unsigned long systemticks_t;
-typedef void * threadreturn_t;
-typedef unsigned long delaytime_t;
+typedef unsigned long gTicks;
+typedef void * gThreadreturn;
+typedef unsigned long gDelay;
typedef pthread_t gfxThreadHandle;
-typedef int threadpriority_t;
-typedef uint32_t semcount_t;
+typedef int gThreadpriority;
+typedef uint32_t gSemcount;
typedef pthread_mutex_t gfxMutex;
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0];
#define THREAD_RETURN(retval) return retval
@@ -50,8 +50,8 @@ typedef pthread_mutex_t gfxMutex;
#define gfxSemSignalI(psem) gfxSemSignal(psem)
#define TIME_IMMEDIATE 0
-#define TIME_INFINITE ((delaytime_t)-1)
-#define MAX_SEMAPHORE_COUNT ((semcount_t)-1)
+#define TIME_INFINITE ((gDelay)-1)
+#define MAX_SEMAPHORE_COUNT ((gSemcount)-1)
#define LOW_PRIORITY 10
#define NORMAL_PRIORITY 0
#define HIGH_PRIORITY -10
@@ -59,14 +59,14 @@ typedef pthread_mutex_t gfxMutex;
#if GFX_USE_POSIX_SEMAPHORES
typedef struct gfxSem {
sem_t sem;
- semcount_t max;
+ gSemcount max;
} gfxSem;
#else
typedef struct gfxSem {
pthread_mutex_t mtx;
pthread_cond_t cond;
- semcount_t cnt;
- semcount_t max;
+ gSemcount cnt;
+ gSemcount max;
} gfxSem;
#endif
@@ -76,17 +76,17 @@ typedef pthread_mutex_t gfxMutex;
void gfxYield(void);
void gfxHalt(const char *msg);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
-systemticks_t gfxSystemTicks(void);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
+gTicks gfxSystemTicks(void);
void gfxSystemLock(void);
void gfxSystemUnlock(void);
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_LINUX */
diff --git a/src/gos/gos_nios.c b/src/gos/gos_nios.c
index b7709c8c..90d625fa 100644
--- a/src/gos/gos_nios.c
+++ b/src/gos/gos_nios.c
@@ -52,12 +52,12 @@ void gfxExit(void) {
}
}
-systemticks_t gfxSystemTicks(void)
+gTicks gfxSystemTicks(void)
{
return alt_nticks();
}
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms)
+gTicks gfxMillisecondsToTicks(gDelay ms)
{
return ms;
}
diff --git a/src/gos/gos_nios.h b/src/gos/gos_nios.h
index 3ef7756f..463607b5 100644
--- a/src/gos/gos_nios.h
+++ b/src/gos/gos_nios.h
@@ -12,13 +12,13 @@
#include <sys/alt_alarm.h>
-typedef alt_u32 systemticks_t;
-typedef alt_u32 delaytime_t;
+typedef alt_u32 gTicks;
+typedef alt_u32 gDelay;
void gfxHalt(const char* msg);
void gfxExit(void);
-systemticks_t gfxSystemTicks(void);
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+gTicks gfxSystemTicks(void);
+gTicks gfxMillisecondsToTicks(gDelay ms);
// Use the generic thread handling and heap handling
#define GOS_NEED_X_THREADS GFXON
diff --git a/src/gos/gos_osx.c b/src/gos/gos_osx.c
index a09647ee..5aae802f 100644
--- a/src/gos/gos_osx.c
+++ b/src/gos/gos_osx.c
@@ -53,7 +53,7 @@ void gfxHalt(const char *msg) {
exit(1);
}
-void gfxSleepMilliseconds(delaytime_t ms) {
+void gfxSleepMilliseconds(gDelay ms) {
struct timespec ts;
switch(ms) {
@@ -67,7 +67,7 @@ void gfxSleepMilliseconds(delaytime_t ms) {
}
}
-void gfxSleepMicroseconds(delaytime_t us) {
+void gfxSleepMicroseconds(gDelay us) {
struct timespec ts;
switch(us) {
@@ -81,7 +81,7 @@ void gfxSleepMicroseconds(delaytime_t us) {
}
}
-systemticks_t gfxSystemTicks(void) {
+gTicks gfxSystemTicks(void) {
mach_timespec_t ts;
clock_serv_t cclock;
@@ -92,7 +92,7 @@ systemticks_t gfxSystemTicks(void) {
return ts.tv_sec * 1000UL + ts.tv_nsec / 1000000;
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
gfxThreadHandle th;
(void) stackarea;
(void) stacksz;
@@ -110,15 +110,15 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return th;
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
- threadreturn_t retval;
+gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
+ gThreadreturn retval;
if (pthread_join(thread, &retval))
return 0;
return retval;
}
-void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) {
+void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pthread_mutex_init(&pSem->mtx, 0);
pthread_cond_init(&pSem->cond, 0);
pthread_mutex_lock(&pSem->mtx);
@@ -132,7 +132,7 @@ void gfxSemDestroy(gfxSem *pSem) {
pthread_cond_destroy(&pSem->cond);
}
-gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) {
+gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
pthread_mutex_lock(&pSem->mtx);
switch (ms) {
case TIME_INFINITE:
diff --git a/src/gos/gos_osx.h b/src/gos/gos_osx.h
index 6b5a762a..33ead2b4 100644
--- a/src/gos/gos_osx.h
+++ b/src/gos/gos_osx.h
@@ -14,15 +14,15 @@
#include <pthread.h>
#include <stdlib.h>
-typedef unsigned long systemticks_t;
-typedef void * threadreturn_t;
-typedef unsigned long delaytime_t;
+typedef unsigned long gTicks;
+typedef void * gThreadreturn;
+typedef unsigned long gDelay;
typedef pthread_t gfxThreadHandle;
-typedef int threadpriority_t;
-typedef uint32_t semcount_t;
+typedef int gThreadpriority;
+typedef uint32_t gSemcount;
typedef pthread_mutex_t gfxMutex;
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0];
#define THREAD_RETURN(retval) return retval
@@ -42,8 +42,8 @@ typedef pthread_mutex_t gfxMutex;
#define gfxSemSignalI(psem) gfxSemSignal(psem)
#define TIME_IMMEDIATE 0
-#define TIME_INFINITE ((delaytime_t)-1)
-#define MAX_SEMAPHORE_COUNT ((semcount_t)-1)
+#define TIME_INFINITE ((gDelay)-1)
+#define MAX_SEMAPHORE_COUNT ((gSemcount)-1)
#define LOW_PRIORITY 10
#define NORMAL_PRIORITY 0
#define HIGH_PRIORITY -10
@@ -51,8 +51,8 @@ typedef pthread_mutex_t gfxMutex;
typedef struct gfxSem {
pthread_mutex_t mtx;
pthread_cond_t cond;
- semcount_t cnt;
- semcount_t max;
+ gSemcount cnt;
+ gSemcount max;
} gfxSem;
/*===========================================================================*/
@@ -60,17 +60,17 @@ typedef struct gfxSem {
/*===========================================================================*/
void gfxHalt(const char *msg);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
-systemticks_t gfxSystemTicks(void);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
+gTicks gfxSystemTicks(void);
void gfxSystemLock(void);
void gfxSystemUnlock(void);
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_OSX */
#endif /* _GOS_OSX_H */
diff --git a/src/gos/gos_qt.cpp b/src/gos/gos_qt.cpp
index 4171d4fe..3aa0f7be 100644
--- a/src/gos/gos_qt.cpp
+++ b/src/gos/gos_qt.cpp
@@ -18,7 +18,7 @@ extern "C" void _gosPostInit(void);
class Thread : public QThread
{
public:
- typedef threadreturn_t (*fptr)(void* param);
+ typedef gThreadreturn (*fptr)(void* param);
void setFunction(fptr function, void* param)
{
@@ -26,7 +26,7 @@ public:
_param = param;
}
- threadreturn_t returnValue()
+ gThreadreturn returnValue()
{
return _returnValue;
}
@@ -43,7 +43,7 @@ public:
private:
fptr _function;
void* _param;
- threadreturn_t _returnValue;
+ gThreadreturn _returnValue;
};
static QElapsedTimer _systickTimer;
@@ -103,22 +103,22 @@ void gfxYield(void)
QThread::msleep(0);
}
-void gfxSleepMilliseconds(delaytime_t ms)
+void gfxSleepMilliseconds(gDelay ms)
{
QThread::msleep(ms);
}
-void gfxSleepMicroseconds(delaytime_t us)
+void gfxSleepMicroseconds(gDelay us)
{
QThread::usleep(us);
}
-systemticks_t gfxSystemTicks(void)
+gTicks gfxSystemTicks(void)
{
return _systickTimer.elapsed();
}
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms)
+gTicks gfxMillisecondsToTicks(gDelay ms)
{
return ms;
}
@@ -153,7 +153,7 @@ void gfxMutexExit(gfxMutex *pmutex)
static_cast<QMutex*>(*pmutex)->unlock();
}
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit)
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{
*psem = new QSemaphore(limit);
@@ -165,7 +165,7 @@ void gfxSemDestroy(gfxSem *psem)
delete static_cast<QSemaphore*>(*psem);
}
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem *psem, gDelay ms)
{
return static_cast<QSemaphore*>(*psem)->tryAcquire(1, ms);
}
@@ -185,7 +185,7 @@ void gfxSemSignalI(gfxSem *psem)
static_cast<QSemaphore*>(*psem)->release(1);
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{
Q_UNUSED(stackarea)
@@ -199,11 +199,11 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return static_cast<gfxThreadHandle>(thread);
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread)
+gThreadreturn gfxThreadWait(gfxThreadHandle thread)
{
Thread* t = static_cast<Thread*>(thread);
- threadreturn_t returnValue = t->returnValue();
+ gThreadreturn returnValue = t->returnValue();
t->wait();
t->exit();
diff --git a/src/gos/gos_qt.h b/src/gos/gos_qt.h
index 367e2a87..fe9c5e34 100644
--- a/src/gos/gos_qt.h
+++ b/src/gos/gos_qt.h
@@ -10,24 +10,24 @@
#if GFX_USE_OS_QT
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0]
#define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0
-#define TIME_INFINITE ((delaytime_t)-1)
-#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define TIME_INFINITE ((gDelay)-1)
+#define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 2
#define NORMAL_PRIORITY 3
#define HIGH_PRIORITY 4
-typedef int systemticks_t;
-typedef int delaytime_t;
+typedef int gTicks;
+typedef int gDelay;
typedef void* gfxMutex;
typedef void* gfxSem;
-typedef int semcount_t;
-typedef int threadreturn_t;
-typedef int threadpriority_t;
+typedef int gSemcount;
+typedef int gThreadreturn;
+typedef int gThreadpriority;
typedef void* gfxThreadHandle;
void _gosInit();
@@ -39,24 +39,24 @@ void* gfxAlloc(size_t sz);
void* gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
void gfxFree(void* ptr);
void gfxYield(void);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t us);
-systemticks_t gfxSystemTicks(void);
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay us);
+gTicks gfxSystemTicks(void);
+gTicks gfxMillisecondsToTicks(gDelay ms);
void gfxSystemLock(void);
void gfxSystemUnlock(void);
void gfxMutexInit(gfxMutex *pmutex);
void gfxMutexDestroy(gfxMutex *pmutex);
void gfxMutexEnter(gfxMutex *pmutex);
void gfxMutexExit(gfxMutex *pmutex);
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
-threadreturn_t gfxThreadWait(gfxThreadHandle thread);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+gThreadreturn gfxThreadWait(gfxThreadHandle thread);
gfxThreadHandle gfxThreadMe(void);
void gfxThreadClose(gfxThreadHandle thread);
diff --git a/src/gos/gos_raw32.c b/src/gos/gos_raw32.c
index 63769d65..cfaac53f 100644
--- a/src/gos/gos_raw32.c
+++ b/src/gos/gos_raw32.c
@@ -74,8 +74,8 @@ void _gosDeinit(void)
#endif
#include <stdio.h>
- systemticks_t gfxSystemTicks(void) { return GetTickCount(); }
- systemticks_t gfxMillisecondsToTicks(delaytime_t ms) { return ms; }
+ gTicks gfxSystemTicks(void) { return GetTickCount(); }
+ gTicks gfxMillisecondsToTicks(gDelay ms) { return ms; }
#endif
/*********************************************************
diff --git a/src/gos/gos_raw32.h b/src/gos/gos_raw32.h
index 6b6bce93..7a936afe 100644
--- a/src/gos/gos_raw32.h
+++ b/src/gos/gos_raw32.h
@@ -17,8 +17,8 @@
* malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0
*
* You must also define the following routines in your own code so that timing functions will work...
- * systemticks_t gfxSystemTicks(void);
- * systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+ * gTicks gfxSystemTicks(void);
+ * gTicks gfxMillisecondsToTicks(gDelay ms);
*/
#ifndef _GOS_RAW32_H
#define _GOS_RAW32_H
diff --git a/src/gos/gos_rawrtos.c b/src/gos/gos_rawrtos.c
index fd50a3f7..b39b0701 100644
--- a/src/gos/gos_rawrtos.c
+++ b/src/gos/gos_rawrtos.c
@@ -45,23 +45,23 @@ void _gosDeinit(void)
}
-void gfxSleepMilliseconds(delaytime_t ms)
+void gfxSleepMilliseconds(gDelay ms)
{
- systemticks_t ticks = ms*RAW_TICKS_PER_SECOND/1000;
+ gTicks ticks = ms*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks = 1;
raw_sleep(ticks);
}
-void gfxSleepMicroseconds(delaytime_t us)
+void gfxSleepMicroseconds(gDelay us)
{
- systemticks_t ticks = (us/1000)*RAW_TICKS_PER_SECOND/1000;
+ gTicks ticks = (us/1000)*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks = 1;
raw_sleep(ticks);
}
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms)
+gBool gfxSemWait(gfxSem* psem, gDelay ms)
{
- systemticks_t ticks = ms*RAW_TICKS_PER_SECOND/1000;
+ gTicks ticks = ms*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks=1;
if(raw_semaphore_get((psem), ticks)==RAW_SUCCESS)
return gTrue;
@@ -75,7 +75,7 @@ gBool gfxSemWaitI(gfxSem* psem)
return gFalse;
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{
RAW_U16 ret;
gfxThreadHandle taskobj;
diff --git a/src/gos/gos_rawrtos.h b/src/gos/gos_rawrtos.h
index 8dc5549e..355c766f 100644
--- a/src/gos/gos_rawrtos.h
+++ b/src/gos/gos_rawrtos.h
@@ -7,11 +7,11 @@
#define TIME_IMMEDIATE (RAW_NO_WAIT)
#define TIME_INFINITE (RAW_WAIT_FOREVER)
-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 gDelay;
+typedef RAW_TICK_TYPE gTicks;
+typedef int32_t gSemcount;
+typedef uint32_t gThreadreturn;
+typedef RAW_U8 gThreadpriority;
#define MAX_SEMAPHORE_COUNT RAW_SEMAPHORE_COUNT
#define LOW_PRIORITY (CONFIG_RAW_PRIO_MAX-2)
@@ -22,7 +22,7 @@ typedef RAW_SEMAPHORE gfxSem;
typedef RAW_MUTEX gfxMutex;
typedef RAW_TASK_OBJ* gfxThreadHandle;
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) PORT_STACK name[(sz) & ~3];
#define THREAD_RETURN(retval) return retval
@@ -63,11 +63,11 @@ extern RAW_U16 raw_semaphore_delete(RAW_SEMAPHORE *semaphore_ptr);
extern RAW_U16 raw_semaphore_get(RAW_SEMAPHORE *semaphore_ptr, RAW_TICK_TYPE wait_option);
extern RAW_U16 raw_semaphore_put(RAW_SEMAPHORE *semaphore_ptr);
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t us);
-gBool gfxSemWait(gfxSem* psem, delaytime_t ms);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay us);
+gBool gfxSemWait(gfxSem* psem, gDelay ms);
gBool gfxSemWaitI(gfxSem* psem);
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#endif
diff --git a/src/gos/gos_win32.c b/src/gos/gos_win32.c
index 11b2e0aa..c2511dfa 100644
--- a/src/gos/gos_win32.c
+++ b/src/gos/gos_win32.c
@@ -37,7 +37,7 @@ void gfxHalt(const char *msg) {
ExitProcess(1);
}
-void gfxSleepMicroseconds(delaytime_t ms) {
+void gfxSleepMicroseconds(gDelay ms) {
static LARGE_INTEGER pcfreq;
static int initflag;
LARGE_INTEGER t1, t2, tdiff;
@@ -74,7 +74,7 @@ void gfxSystemUnlock(void) {
ReleaseMutex(SystemMutex);
}
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms) {
+gBool gfxSemWait(gfxSem *psem, gDelay ms) {
return WaitForSingleObject(*psem, ms) == WAIT_OBJECT_0;
}
@@ -87,7 +87,7 @@ typedef LONG (__stdcall *_NtQuerySemaphore)(
);
/* - Left here simply because of its undocumented cleverness...
-semcount_t gfxSemCounter(gfxSem *pSem) {
+gSemcount gfxSemCounter(gfxSem *pSem) {
static _NtQuerySemaphore NtQuerySemaphore;
struct _SEMAPHORE_BASIC_INFORMATION {
ULONG CurrentCount;
@@ -103,7 +103,7 @@ semcount_t gfxSemCounter(gfxSem *pSem) {
}
*/
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param) {
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param) {
(void) stackarea;
HANDLE thd;
@@ -116,7 +116,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return thd;
}
-threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
+gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
DWORD ret;
WaitForSingleObject(thread, INFINITE);
diff --git a/src/gos/gos_win32.h b/src/gos/gos_win32.h
index 3cdd5214..10412119 100644
--- a/src/gos/gos_win32.h
+++ b/src/gos/gos_win32.h
@@ -25,19 +25,19 @@
#include <malloc.h>
-typedef DWORD delaytime_t;
-typedef DWORD systemticks_t;
-typedef LONG semcount_t;
-typedef DWORD threadreturn_t;
-typedef int threadpriority_t;
+typedef DWORD gDelay;
+typedef DWORD gTicks;
+typedef LONG gSemcount;
+typedef DWORD gThreadreturn;
+typedef int gThreadpriority;
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t (WINAPI fnName)(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn (WINAPI fnName)(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1];
#define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0
#define TIME_INFINITE INFINITE
-#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY THREAD_PRIORITY_BELOW_NORMAL
#define NORMAL_PRIORITY THREAD_PRIORITY_NORMAL
#define HIGH_PRIORITY THREAD_PRIORITY_ABOVE_NORMAL
@@ -71,12 +71,12 @@ typedef HANDLE gfxThreadHandle;
/*===========================================================================*/
void gfxHalt(const char *msg);
-void gfxSleepMicroseconds(delaytime_t ms);
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+void gfxSleepMicroseconds(gDelay ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param);
+gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_WIN32 */
#endif /* _GOS_WIN32_H */
diff --git a/src/gos/gos_x_threads.c b/src/gos/gos_x_threads.c
index efff9f20..a4a3eb31 100644
--- a/src/gos/gos_x_threads.c
+++ b/src/gos/gos_x_threads.c
@@ -45,13 +45,13 @@ void gfxMutexExit(gfxMutex *pmutex) {
pmutex[0] = 0;
}
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) {
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit) {
psem->cnt = val;
psem->limit = limit;
}
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms) {
- systemticks_t starttm, delay;
+gBool gfxSemWait(gfxSem *psem, gDelay ms) {
+ gTicks starttm, delay;
// Convert our delay to ticks
starttm = 0;
@@ -112,8 +112,8 @@ void gfxSemSignalI(gfxSem *psem) {
* Sleep functions
*********************************************************/
-void gfxSleepMilliseconds(delaytime_t ms) {
- systemticks_t starttm, delay;
+void gfxSleepMilliseconds(gDelay ms) {
+ gTicks starttm, delay;
// Safety first
switch (ms) {
@@ -134,8 +134,8 @@ void gfxSleepMilliseconds(delaytime_t ms) {
} while (gfxSystemTicks() - starttm < delay);
}
-void gfxSleepMicroseconds(delaytime_t ms) {
- systemticks_t starttm, delay;
+void gfxSleepMicroseconds(gDelay ms) {
+ gTicks starttm, delay;
// Safety first
switch (ms) {
@@ -176,7 +176,7 @@ typedef struct thread {
#define FLG_THD_DEAD 0x0004
#define FLG_THD_WAIT 0x0008
size_t size; // Size of the thread stack (including this structure)
- threadreturn_t (*fn)(void *param); // Thread function
+ gThreadreturn (*fn)(void *param); // Thread function
void * param; // Parameter for the thread function
void * cxt; // The current thread context.
} thread;
@@ -485,7 +485,7 @@ void gfxYield(void) {
}
// This routine is not currently public - but it could be.
-void gfxThreadExit(threadreturn_t ret) {
+void gfxThreadExit(gThreadreturn ret) {
thread *me;
// Save the results in case someone is waiting
@@ -508,7 +508,7 @@ void gfxThreadExit(threadreturn_t ret) {
// We never get back here as we didn't re-queue ourselves
}
-gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
thread * t;
thread * me;
(void) prio;
@@ -543,7 +543,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return t;
}
-threadreturn_t gfxThreadWait(gfxThreadHandle th) {
+gThreadreturn gfxThreadWait(gfxThreadHandle th) {
thread * t;
t = th;
@@ -565,7 +565,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle th) {
gfxFree(t);
// Return the status left by the dead process
- return (threadreturn_t)t->param;
+ return (gThreadreturn)t->param;
}
#endif /* GFX_USE_OS_RAW32 */
diff --git a/src/gos/gos_x_threads.h b/src/gos/gos_x_threads.h
index 7f7b57e7..69b586c6 100644
--- a/src/gos/gos_x_threads.h
+++ b/src/gos/gos_x_threads.h
@@ -16,46 +16,46 @@
* memcpy() - for heap and threading
*
* You must also define the following routines in your own code so that timing functions will work...
- * systemticks_t gfxSystemTicks(void);
- * systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+ * gTicks gfxSystemTicks(void);
+ * gTicks gfxMillisecondsToTicks(gDelay ms);
*/
#ifndef _GOS_X_THREADS_H
#define _GOS_X_THREADS_H
#if GOS_NEED_X_THREADS
-typedef uint32_t delaytime_t;
-typedef uint32_t systemticks_t;
-typedef short semcount_t;
-typedef int threadreturn_t;
-typedef int threadpriority_t;
+typedef uint32_t gDelay;
+typedef uint32_t gTicks;
+typedef short gSemcount;
+typedef int gThreadreturn;
+typedef int gThreadpriority;
-#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param)
+#define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[(sz) & ~3];
#define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0
-#define TIME_INFINITE ((delaytime_t)-1)
+#define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT 0x7FFF
#define LOW_PRIORITY 0
#define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 2
typedef struct {
- semcount_t cnt;
- semcount_t limit;
+ gSemcount cnt;
+ gSemcount limit;
} gfxSem;
typedef uint32_t gfxMutex;
typedef void * gfxThreadHandle;
// Required timing functions - supplied by the user or the operating system
-systemticks_t gfxSystemTicks(void);
-systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
+gTicks gfxSystemTicks(void);
+gTicks gfxMillisecondsToTicks(gDelay ms);
// Sleep Functions
-void gfxSleepMilliseconds(delaytime_t ms);
-void gfxSleepMicroseconds(delaytime_t ms);
+void gfxSleepMilliseconds(gDelay ms);
+void gfxSleepMicroseconds(gDelay ms);
void gfxYield(void);
// System Locking
@@ -69,24 +69,24 @@ void gfxMutexEnter(gfxMutex *pmutex);
void gfxMutexExit(gfxMutex *pmutex);
// Semaphores
-void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
+void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem)
-gBool gfxSemWait(gfxSem *psem, delaytime_t ms);
+gBool gfxSemWait(gfxSem *psem, gDelay 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);
+gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadClose(thread)
-threadreturn_t gfxThreadWait(gfxThreadHandle thread);
+gThreadreturn 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);
+void gfxThreadExit(gThreadreturn ret);
#endif /* GOS_NEED_X_THREADS */
#endif /* _GOS_X_THREADS_H */
diff --git a/src/gos/gos_zephyr.c b/src/gos/gos_zephyr.c
index 401d9f6a..82660c46 100644
--- a/src/gos/gos_zephyr.c
+++ b/src/gos/gos_zephyr.c
@@ -9,7 +9,7 @@
#if GFX_USE_OS_ZEPHYR
-systemticks_t gfxSystemTicks(void)
+gTicks gfxSystemTicks(void)
{
s32_t ms = k_uptime_get_32();
return CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000;
diff --git a/src/gos/gos_zephyr.h b/src/gos/gos_zephyr.h
index 07f9107b..1bfccf8b 100644
--- a/src/gos/gos_zephyr.h
+++ b/src/gos/gos_zephyr.h
@@ -16,14 +16,14 @@
/* 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;
+typedef s32_t gDelay;
+typedef u32_t gTicks;
+typedef u32_t gSemcount;
+typedef void gThreadreturn;
+typedef int gThreadpriority;
#define DECLARE_THREAD_FUNCTION(fnName, param)\
- threadreturn_t fnName(void* param, void* p2, void* p3)
+ gThreadreturn fnName(void* param, void* p2, void* p3)
#define DECLARE_THREAD_STACK(name, sz)\
K_THREAD_STACK_DEFINE(name, sz)
@@ -32,7 +32,7 @@ typedef int threadpriority_t;
#define TIME_IMMEDIATE K_NO_WAIT
#define TIME_INFINITE K_FOREVER
-#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
+#define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY CONFIG_NUM_PREEMPT_PRIORITIES-1
#define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 0
@@ -59,7 +59,7 @@ typedef k_tid_t gfxThreadHandle;
#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();
+gTicks gfxSystemTicks();
#define gfxSystemLock() k_sched_lock()
#define gfxSystemUnlock() k_sched_unlock()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-02 13:14:29 +0000