More GOS module changes

GQUEUE as a seperate module
GOS changes including basic Win32 O/S support

1 files changed, 67 insertions, 160 deletions

diff --git a/include/gos/gos.h b/include/gos/gos.h
index 04799540..d979cd27 100644
--- a/include/gos/gos.h
+++ b/include/gos/gos.h
@@ -37,11 +37,6 @@
 	/*===========================================================================*/
 
 	/**
-	 * @brief	A function for a new thread to execute.
-	 */
-	typedef threadreturn_t (*gfxThreadFunction)(void *param);
-
-	/**
 	 * @brief	Various integer sizes
 	 * @note	Your platform may use slightly different definitions to these
 	 * @{
@@ -67,6 +62,10 @@
 	typedef int				threadreturn_t;
 	typedef int				threadpriority_t;
 	/**
+	 * @brief	A function for a new thread to execute.
+	 */
+	typedef threadreturn_t (*gfxThreadFunction)(void *param);
+	/**
 	 * @}
 	 *
 	 * @brief	Various platform (and operating system) constants
@@ -77,7 +76,7 @@
 	#define TRUE						1
 	#define TIME_IMMEDIATE				0
 	#define TIME_INFINITE				((delaytime_t)-1)
-	#define MAX_SEMAPHORE_COUNT			((semcount_t)-1)
+	#define MAX_SEMAPHORE_COUNT			((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1))
 	#define LOW_PRIORITY				0
 	#define NORMAL_PRIORITY				1
 	#define HIGH_PRIORITY				2
@@ -96,18 +95,6 @@
 	 */
 	typedef struct {} gfxMutex;
 
-	/**
-	 * @brief	A queue
-	 * @note	Your operating system will have a proper definition for this structure
-	 */
-	typedef struct {} gfxQueue;
-
-	/**
-	 * @brief	A queue item
-	 * @note	Your operating system will have a proper definition for this structure
-	 */
-	typedef struct {} gfxQueueItem;
-
 	/*===========================================================================*/
 	/* Function declarations.                                                    */
 	/*===========================================================================*/
@@ -152,6 +139,15 @@
 	void gfxFree(void *ptr);
 
 	/**
+	 * @brief	Yield the current thread
+	 * @details	Give up the rest of the current time slice for this thread in order to give other threads
+	 * 			a chance to run.
+	 *
+	 * @api
+	 */
+	void gfxYield(void);
+
+	/**
 	 * @brief	Put the current thread to sleep for the specified period in milliseconds
 	 *
 	 * @param[in] ms	The number milliseconds to sleep
@@ -177,83 +173,6 @@
 	void gfxSleepMicroseconds(delaytime_t ms);
 
 	/**
-	 * @brief	Initialise a Counted Semaphore
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 * @param[in] val		The initial value of the semaphore
-	 * @param[in] limit		The maxmimum value of the semaphore
-	 *
-	 * @note	Operations defined for counted semaphores:
-	 * 				Signal: The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 * 				Wait: The semaphore counter is decreased and if the result becomes negative the thread is queued
-	 * 						in the semaphore and suspended.
-	 *
-	 * @api
-	 */
-	void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
-
-	/**
-	 * @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
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 * @param[in] ms		The maxmimum time to wait for the semaphore
-	 *
-	 * @api
-	 */
-	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
-
-	/**
-	 * @brief	Signal a semaphore
-	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @api
-	 */
-	void gfxSemSignal(gfxSem *psem);
-
-	/**
-	 * @brief	Signal a semaphore
-	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
-	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
-	 * 						 ignored.
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @iclass
-	 * @api
-	 */
-	void gfxSemSignalI(gfxSem *psem);
-
-	/**
-	 * @brief	Get the current semaphore count
-	 * @return	The current semaphore count
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @api
-	 */
-	semcount_t gfxSemCounter(gfxSem *pSem);
-
-	/**
-	 * @brief	Get the current semaphore count
-	 * @return	The current semaphore count
-	 *
-	 * @param[in] psem		A pointer to the semaphore
-	 *
-	 * @iclass
-	 * @api
-	 */
-	semcount_t gfxSemCounterI(gfxSem *pSem);
-
-	/**
 	 * @brief	Get the current operating system tick time
 	 * @return	The current tick time
 	 *
@@ -283,15 +202,6 @@
 	systemticks_t gfxMillisecondsToTicks(delaytime_t ms);
 
 	/**
-	 * @brief	Yield the current thread
-	 * @details	Give up the rest of the current time slice for this thread in order to give other threads
-	 * 			a chance to run.
-	 *
-	 * @api
-	 */
-	void gfxYield(void);
-
-	/**
 	 * @brief	Lock the operating system to protect a sequence of code
 	 *
 	 * @note	Calling this will lock out all other threads from executing even at interrupt level
@@ -327,6 +237,15 @@
 	void gfxMutexInit(gfxMutex *pmutex);
 
 	/**
+	 * @brief	Destroy a Mutex.
+	 *
+	 * @param[in]	pmutex	A pointer to the mutex
+	 *
+	 * @api
+	 */
+	void gfxMutexDestroy(gfxMutex *pmutex);
+
+	/**
 	 * @brief	Enter the critical code region protected by the mutex.
 	 * @details	Blocks until there is no other thread in the critical region.
 	 *
@@ -347,104 +266,92 @@
 	void gfxMutexExit(gfxMutex *pmutex);
 
 	/**
-	 * @brief	Initialise a queue.
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 *
-	 * @note	Whilst queues are normally FIFO, a GFX queue also supports push and pop operations.
-	 * 			A pop operation is the same as normal get from the queue but a push places the item
-	 * 			at the head of the queue instead of the tail (as a put would).
+	 * @brief	Initialise a Counted Semaphore
 	 *
-	 * @api
-	 */
-	void gfxQueueInit(gfxQueue *pqueue);
-
-	/**
-	 * @brief	Get an item from the head of the queue.
-	 * @return	NULL if the timeout expires before an item is available
+	 * @param[in] psem		A pointer to the semaphore
+	 * @param[in] val		The initial value of the semaphore
+	 * @param[in] limit		The maxmimum value of the semaphore
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	ms		The maxmimum time to wait for an item
+	 * @note	Operations defined for counted semaphores:
+	 * 				Signal: The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
+	 * 				Wait: The semaphore counter is decreased and if the result becomes negative the thread is queued
+	 * 						in the semaphore and suspended.
 	 *
 	 * @api
 	 */
-	gfxQueueItem * gfxQueueGet(gfxQueue *pqueue, delaytime_t ms);
+	void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit);
 
 	/**
-	 * @brief	Put an item on the end of the queue.
-	 * @return	FALSE on timeout, otherwise TRUE
+	 * @brief	Destroy a Counted Semaphore
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
-	 * @param[in]	ms		The maxmimum time to wait for an item to be removed from the queue
+	 * @param[in] psem		A pointer to the semaphore
 	 *
-	 * @note		Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
-	 * 				item is removed from the queue
+	 * @note	Any threads waiting on the semaphore will be released
 	 *
 	 * @api
 	 */
-	bool_t gfxQueuePut(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
+	void gfxSemDestroy(gfxSem *psem);
 
 	/**
-	 * @brief	Pop an item from the head of the queue.
-	 * @return	NULL if there are no more items on the queue
+	 * @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
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
+	 * @param[in] psem		A pointer to the semaphore
+	 * @param[in] ms		The maxmimum time to wait for the semaphore
 	 *
 	 * @api
 	 */
-	#define gfxQueuePop(pqueue, ms)		gfxQueueGet(pqueue, ms)
+	bool_t gfxSemWait(gfxSem *psem, delaytime_t ms);
 
 	/**
-	 * @brief	Push an item into the start of the queue.
-	 * @return	FALSE on timeout, otherwise TRUE
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
-	 * @param[in]	ms		The maxmimum time to wait for an item to be popped
+	 * @brief	Signal a semaphore
+	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
 	 *
-	 * @note		Use a delay time of TIME_IMMEDIATE if you don't want to wait until the
-	 * 				item is removed from the queue
+	 * @param[in] psem		A pointer to the semaphore
 	 *
 	 * @api
 	 */
-	bool_t gfxQueuePush(gfxQueue *pqueue, gfxQueueItem *pitem, delaytime_t ms);
+	void gfxSemSignal(gfxSem *psem);
 
 	/**
-	 * @brief	Remove an item from the queue.
-	 * @note	Removes the specified item from the queue whereever it is in the queue
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
+	 * @brief	Signal a semaphore
+	 * @details	The semaphore counter is increased and if the result is non-positive then a waiting thread
+	 * 						 is queued for execution. Note that once the thread reaches "limit", further signals are
+	 * 						 ignored.
 	 *
-	 * @note	If the item isn't in the queue the routine just returns.
+	 * @param[in] psem		A pointer to the semaphore
 	 *
+	 * @iclass
 	 * @api
 	 */
-	void gfxQueueRemove(gfxQueue *pqueue, gfxQueueItem *pitem);
+	void gfxSemSignalI(gfxSem *psem);
 
 	/**
-	 * @brief	Is the queue empty?
-	 * @return	TRUE if the queue is empty
+	 * @brief	Get the current semaphore count
+	 * @return	The current semaphore count
 	 *
-	 * @param[in]	pqueue	A pointer to the queue
+	 * @param[in] psem		A pointer to the semaphore
 	 *
 	 * @api
 	 */
-	bool_t gfxQueueIsEmpty(gfxQueue *pqueue);
+	semcount_t gfxSemCounter(gfxSem *pSem);
 
 	/**
-	 * @brief	Is an item in the queue?
-	 * @return	TRUE if the item is in the queue?
-	 *
-	 * @param[in]	pqueue	A pointer to the queue
-	 * @param[in]	pitem	A pointer to the queue item
+	 * @brief	Get the current semaphore count
+	 * @return	The current semaphore count
 	 *
-	 * @note	This operation may be expensive.
+	 * @param[in] psem		A pointer to the semaphore
 	 *
+	 * @iclass
 	 * @api
 	 */
-	bool_t gfxQueueIsIn(gfxQueue *pqueue, gfxQueueItem *pitem);
+	semcount_t gfxSemCounterI(gfxSem *pSem);
 
 	/**
 	 * @brief	Start a new thread.