Consistently return error numbers

Return old thread priority

Author: Extrems

gc/ogc/lwp.h

@@ -101,7 +101,7 @@ typedef u32 lwpq_t;
 \param[in] stack_size size of the provided stack. If 0, the default STACKSIZE of 8Kb is taken.
 \param[in] prio priority on which the newly created thread runs.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_CreateThread(lwp_t *thethread,void* (*entry)(void *),void *arg,void *stackbase,u32 stack_size,u8 prio);
 
@@ -110,7 +110,7 @@ s32 LWP_CreateThread(lwp_t *thethread,void* (*entry)(void *),void *arg,void *sta
 \brief Suspend the given thread.
 \param[in] thethread handle to the thread context which should be suspended.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SuspendThread(lwp_t thethread);
 
@@ -119,7 +119,7 @@ s32 LWP_SuspendThread(lwp_t thethread);
 \brief Resume the given thread.
 \param[in] thethread handle to the thread context which should be resumed.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_ResumeThread(lwp_t thethread);
 
@@ -145,19 +145,19 @@ lwp_t LWP_GetSelf(void);
 \brief Get the priority of the given thread.
 \param[in] thethread handle to the thread context whos priority should be returned. If NULL, the current thread will be taken.
 
-\return 0 on success, <0 on error
+\return current thread priority
 */
 s32 LWP_GetThreadPriority(lwp_t thethread);
 
 
-/*! \fn void LWP_SetThreadPriority(lwp_t thethread,u32 prio)
+/*! \fn s32 LWP_SetThreadPriority(lwp_t thethread,u32 prio)
 \brief Set the priority of the given thread.
 \param[in] thethread handle to the thread context whos priority should be changed. If NULL, the current thread will be taken.
 \param[in] prio new priority to set
 
-\return none
+\return old thread priority
 */
-void LWP_SetThreadPriority(lwp_t thethread,u32 prio);
+s32 LWP_SetThreadPriority(lwp_t thethread,u32 prio);
 
 
 /*! \fn void LWP_YieldThread(void)
@@ -182,34 +182,34 @@ void LWP_Reschedule(u32 prio);
 \param[in] thethread handle to the thread's context which should be joined to wait on termination.
 \param[in] value_ptr pointer-pointer to a variable to receive the return code of the terminated thread.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_JoinThread(lwp_t thethread,void **value_ptr);
 
 
-/*! \fn void LWP_InitQueue(lwpq_t *thequeue)
+/*! \fn s32 LWP_InitQueue(lwpq_t *thequeue)
 \brief Initialize the thread synchronization queue
 \param[in] thequeue pointer to a lwpq_t handle.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_InitQueue(lwpq_t *thequeue);
 
 
-/*! \fn void LWP_CloseQueue(lwpq_t thequeue)
+/*! \fn s32 LWP_CloseQueue(lwpq_t thequeue)
 \brief Close the thread synchronization queue and releas the handle
 \param[in] thequeue handle to the thread's synchronization queue
 
-\return none
+\return 0 on success, non-zero on error
 */
-void LWP_CloseQueue(lwpq_t thequeue);
+s32 LWP_CloseQueue(lwpq_t thequeue);
 
 
 /*! \fn s32 LWP_ThreadSleep(lwpq_t thequeue)
 \brief Pushes the current thread onto the given thread synchronization queue and sets the thread state to blocked.
 \param[in] thequeue handle to the thread's synchronization queue to push the thread on
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_ThreadSleep(lwpq_t thequeue);
 
@@ -219,27 +219,27 @@ s32 LWP_ThreadSleep(lwpq_t thequeue);
 \param[in] thequeue handle to the thread's synchronization queue to push the thread on
 \param[in] reltime pointer to a timespec structure holding the relative time for the timeout.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_ThreadTimedSleep(lwpq_t thequeue,const struct timespec *reltime);
 
 
-/*! \fn void LWP_ThreadSignal(lwpq_t thequeue)
+/*! \fn s32 LWP_ThreadSignal(lwpq_t thequeue)
 \brief Signals one thread to be revmoved from the thread synchronization queue and sets it back to running state.
 \param[in] thequeue handle to the thread's synchronization queue to pop the blocked thread off
 
-\return none
+\return 0 on success, non-zero on error
 */
-void LWP_ThreadSignal(lwpq_t thequeue);
+s32 LWP_ThreadSignal(lwpq_t thequeue);
 
 
-/*! \fn void LWP_ThreadBroadcast(lwpq_t thequeue)
+/*! \fn s32 LWP_ThreadBroadcast(lwpq_t thequeue)
 \brief Removes all blocked threads from the thread synchronization queue and sets them back to running state.
 \param[in] thequeue handle to the thread's synchronization queue to pop the blocked threads off
 
-\return none
+\return 0 on success, non-zero on error
 */
-void LWP_ThreadBroadcast(lwpq_t thequeue);
+s32 LWP_ThreadBroadcast(lwpq_t thequeue);
 
 #ifdef __cplusplus
 	}

gc/ogc/message.h

@@ -65,9 +65,6 @@ distribution.
 
 #define MQ_BOX_NULL				0xffffffff
 
-#define MQ_ERROR_SUCCESSFUL		0
-#define MQ_ERROR_TOOMANY		-5
-
 #define MQ_MSG_BLOCK			0
 #define MQ_MSG_NOBLOCK			1
 
@@ -95,18 +92,18 @@ typedef void* mqmsg_t;
 \param[out] mqbox pointer to the mqbox_t handle.
 \param[in] count maximum number of messages the queue can hold
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 MQ_Init(mqbox_t *mqbox,u32 count);
 
 
-/*! \fn void MQ_Close(mqbox_t mqbox)
+/*! \fn s32 MQ_Close(mqbox_t mqbox)
 \brief Closes the message queue and releases all memory.
 \param[in] mqbox handle to the mqbox_t structure.
 
-\return none
+\return 0 on success, non-zero on error
 */
-void MQ_Close(mqbox_t mqbox);
+s32 MQ_Close(mqbox_t mqbox);
 
 
 /*! \fn BOOL MQ_Send(mqbox_t mqbox,mqmsg_t msg,u32 flags)

gc/ogc/mutex.h

@@ -82,7 +82,7 @@ typedef u32 mutex_t;
 \param[out] mutex pointer to a mutex_t handle.
 \param[in] use_recursive whether to allow the thread, whithin the same context, to enter multiple times the lock or not.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexInit(mutex_t *mutex,bool use_recursive);
 
@@ -91,7 +91,7 @@ s32 LWP_MutexInit(mutex_t *mutex,bool use_recursive);
 \brief Close mutex lock, release all threads and handles locked on this mutex.
 \param[in] mutex handle to the mutex_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexDestroy(mutex_t mutex);
 
@@ -100,7 +100,7 @@ s32 LWP_MutexDestroy(mutex_t mutex);
 \brief Enter the mutex lock.
 \param[in] mutex handle to the mutex_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexLock(mutex_t mutex);
 
@@ -110,7 +110,7 @@ s32 LWP_MutexLock(mutex_t mutex);
 \param[in] mutex handle to the mutex_t structure.
 \param[in] reltime pointer to a timespec structure holding the relative time for the timeout.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexTimedLock(mutex_t mutex,const struct timespec *reltime);
 
@@ -119,7 +119,7 @@ s32 LWP_MutexTimedLock(mutex_t mutex,const struct timespec *reltime);
 \brief Try to enter the mutex lock.
 \param[in] mutex handle to the mutex_t structure.
 
-\return 0: on first aquire, 1: would lock
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexTryLock(mutex_t mutex);
 
@@ -128,7 +128,7 @@ s32 LWP_MutexTryLock(mutex_t mutex);
 \brief Release the mutex lock and let other threads process further on this mutex.
 \param[in] mutex handle to the mutex_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_MutexUnlock(mutex_t mutex);
 

gc/ogc/semaphore.h

@@ -83,7 +83,7 @@ typedef u32 sem_t;
 \param[in] start start count of the semaphore
 \param[in] max maximum count of the semaphore
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemInit(sem_t *sem,u32 start,u32 max);
 
@@ -92,7 +92,7 @@ s32 LWP_SemInit(sem_t *sem,u32 start,u32 max);
 \brief Close and destroy a semaphore, release all threads and handles locked on this semaphore.
 \param[in] sem handle to the sem_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemDestroy(sem_t sem);
 
@@ -101,7 +101,7 @@ s32 LWP_SemDestroy(sem_t sem);
 \brief Count down semaphore counter and enter lock if counter <=0
 \param[in] sem handle to the sem_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemWait(sem_t sem);
 
@@ -111,7 +111,7 @@ s32 LWP_SemWait(sem_t sem);
 \param[in] sem handle to the sem_t structure.
 \param[in] reltime pointer to a timespec structure holding the relative time for the timeout.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemTimedWait(sem_t sem,const struct timespec *reltime);
 
@@ -120,7 +120,7 @@ s32 LWP_SemTimedWait(sem_t sem,const struct timespec *reltime);
 \brief Count down semaphore counter and try to enter lock if counter <=0
 \param[in] sem handle to the sem_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemTryWait(sem_t sem);
 
@@ -129,7 +129,7 @@ s32 LWP_SemTryWait(sem_t sem);
 \brief Count up semaphore counter and release lock if counter >0
 \param[in] sem handle to the sem_t structure.
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemPost(sem_t sem);
 
@@ -139,7 +139,7 @@ s32 LWP_SemPost(sem_t sem);
 \param[in] sem handle to the sem_t structure.
 \param[out] value pointer to receive the current count of the semaphore
 
-\return 0 on success, <0 on error
+\return 0 on success, non-zero on error
 */
 s32 LWP_SemGetValue(sem_t sem,u32 *value);
 

gc/ogc/system.h

@@ -320,7 +320,7 @@ s8 SYS_GetCoreTemperature(void);
 \brief Create/initialize sysalarm structure
 \param[in] thealarm pointer to the handle to store the created alarm context identifier
 
-\return 0 on succuess, non-zero on error
+\return 0 on success, non-zero on error
 */
 s32 SYS_CreateAlarm(syswd_t *thealarm);
 
@@ -331,7 +331,7 @@ s32 SYS_CreateAlarm(syswd_t *thealarm);
 \param[in] tp pointer to timespec structure holding the time to fire the alarm
 \param[in] cb pointer to callback which is called when the alarm fires.
 
-\return 0 on succuess, non-zero on error
+\return 0 on success, non-zero on error
 */
 s32 SYS_SetAlarm(syswd_t thealarm,const struct timespec *tp,alarmcallback cb,void *cbarg);
 
@@ -343,7 +343,7 @@ s32 SYS_SetAlarm(syswd_t thealarm,const struct timespec *tp,alarmcallback cb,voi
 \param[in] tp_period pointer to timespec structure holding the interval for all following alarm triggers.
 \param[in] cb pointer to callback which is called when the alarm fires.
 
-\return 0 on succuess, non-zero on error
+\return 0 on success, non-zero on error
 */
 s32 SYS_SetPeriodicAlarm(syswd_t thealarm,const struct timespec *tp_start,const struct timespec *tp_period,alarmcallback cb,void *cbarg);
 
@@ -352,7 +352,7 @@ s32 SYS_SetPeriodicAlarm(syswd_t thealarm,const struct timespec *tp_start,const
 \brief Remove the given alarm context from the list of contexts and destroy it
 \param[in] thealarm identifier to the alarm context to be removed and destroyed
 
-\return 0 on succuess, non-zero on error
+\return 0 on success, non-zero on error
 */
 s32 SYS_RemoveAlarm(syswd_t thealarm);
 
@@ -361,7 +361,7 @@ s32 SYS_RemoveAlarm(syswd_t thealarm);
 \brief Cancel the alarm, but do not remove from the list of contexts.
 \param[in] thealarm identifier to the alram context to be canceled
 
-\return 0 on succuess, non-zero on error
+\return 0 on success, non-zero on error
 */
 s32 SYS_CancelAlarm(syswd_t thealarm);
 

libaesnd/aesndmp3player.c

@@ -86,7 +86,7 @@ s32 MP3Player_PlayBuffer(const void *buffer,s32 len,void (*filterfunc)(struct ma
 	mp3cb_data = &rambuffer;
 	mp3read = _mp3ramcopy;
 	mp3filterfunc = filterfunc;
-	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)<0) {
+	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)!=0) {
 		return -1;
 	}
 	return 0;
@@ -99,7 +99,7 @@ s32 MP3Player_PlayFile(void *cb_data,s32 (*reader)(void *,void *,s32),void (*fil
 	mp3cb_data = cb_data;
 	mp3read = reader;
 	mp3filterfunc = filterfunc;
-	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)<0) {
+	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)!=0) {
 		return -1;
 	}
 	return 0;

libasnd/mp3player.c

@@ -240,7 +240,7 @@ s32 MP3Player_PlayBuffer(const void *buffer,s32 len,void (*filterfunc)(struct ma
 	mp3cb_data = &rambuffer;
 	mp3read = _mp3ramcopy;
 	mp3filterfunc = filterfunc;
-	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)<0) {
+	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)!=0) {
 		return -1;
 	}
 	return 0;
@@ -253,7 +253,7 @@ s32 MP3Player_PlayFile(void *cb_data,s32 (*reader)(void *,void *,s32),void (*fil
 	mp3cb_data = cb_data;
 	mp3read = reader;
 	mp3filterfunc = filterfunc;
-	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)<0) {
+	if(LWP_CreateThread(&hStreamPlay,StreamPlay,NULL,StreamPlay_Stack,STACKSIZE,80)!=0) {
 		return -1;
 	}
 	return 0;

libmodplay/gcmodplay.c

@@ -153,7 +153,7 @@ static s32 SndBufStart(MODSNDBUF *sndbuf)
 
 	curr_audio = 0;
 	sndPlaying = TRUE;
-	if(LWP_CreateThread(&hplayer,player,NULL,player_stack,STACKSIZE,80)!=-1) {
+	if(LWP_CreateThread(&hplayer,player,NULL,player_stack,STACKSIZE,80)==0) {
 #ifndef __AESNDLIB_H__
 		AUDIO_RegisterDMACallback(dmaCallback);
 		AUDIO_InitDMA((u32)audioBuf[curr_audio],SNDBUFFERSIZE);