Use SDL_bool instead an int return code in the SDL API

Most SDL functions used to indicate success or failure using an int return code. These functions have been changed to return SDL_bool.

Here is a coccinelle patch to change code that previously compared the return value to 0 and changes it to a boolean test:
@ bool_return_type  @
identifier func =~ "^(SDL_AddEventWatch|SDL_AddHintCallback|SDL_AddSurfaceAlternateImage|SDL_AddVulkanRenderSemaphores|SDL_BindAudioStream|SDL_BindAudioStreams|SDL_BlitSurface|SDL_BlitSurface9Grid|SDL_BlitSurfaceScaled|SDL_BlitSurfaceTiled|SDL_BlitSurfaceTiledWithScale|SDL_BlitSurfaceUnchecked|SDL_BlitSurfaceUncheckedScaled|SDL_CaptureMouse|SDL_ClearAudioStream|SDL_ClearClipboardData|SDL_ClearComposition|SDL_ClearError|SDL_ClearProperty|SDL_ClearSurface|SDL_CloseIO|SDL_CloseStorage|SDL_ConvertAudioSamples|SDL_ConvertEventToRenderCoordinates|SDL_ConvertPixels|SDL_ConvertPixelsAndColorspace|SDL_CopyFile|SDL_CopyProperties|SDL_CopyStorageFile|SDL_CreateDirectory|SDL_CreateStorageDirectory|SDL_CreateWindowAndRenderer|SDL_DateTimeToTime|SDL_DestroyWindowSurface|SDL_DetachVirtualJoystick|SDL_DisableScreenSaver|SDL_EnableScreenSaver|SDL_EnumerateDirectory|SDL_EnumerateProperties|SDL_EnumerateStorageDirectory|SDL_FillSurfaceRect|SDL_FillSurfaceRects|SDL_FlashWindow|SDL_FlipSurface|SDL_FlushAudioStream|SDL_FlushRenderer|SDL_GL_DestroyContext|SDL_GL_GetAttribute|SDL_GL_GetSwapInterval|SDL_GL_LoadLibrary|SDL_GL_MakeCurrent|SDL_GL_SetAttribute|SDL_GL_SetSwapInterval|SDL_GL_SwapWindow|SDL_GetAudioDeviceFormat|SDL_GetAudioStreamFormat|SDL_GetCameraFormat|SDL_GetClosestFullscreenDisplayMode|SDL_GetCurrentRenderOutputSize|SDL_GetCurrentTime|SDL_GetDXGIOutputInfo|SDL_GetDateTimeLocalePreferences|SDL_GetDisplayBounds|SDL_GetDisplayUsableBounds|SDL_GetGDKDefaultUser|SDL_GetGDKTaskQueue|SDL_GetGamepadSensorData|SDL_GetGamepadTouchpadFinger|SDL_GetHapticEffectStatus|SDL_GetJoystickBall|SDL_GetMasksForPixelFormat|SDL_GetPathInfo|SDL_GetRectUnion|SDL_GetRectUnionFloat|SDL_GetRenderClipRect|SDL_GetRenderColorScale|SDL_GetRenderDrawBlendMode|SDL_GetRenderDrawColor|SDL_GetRenderDrawColorFloat|SDL_GetRenderLogicalPresentation|SDL_GetRenderLogicalPresentationRect|SDL_GetRenderOutputSize|SDL_GetRenderSafeArea|SDL_GetRenderScale|SDL_GetRenderVSync|SDL_GetRenderViewport|SDL_GetSensorData|SDL_GetStorageFileSize|SDL_GetStoragePathInfo|SDL_GetSurfaceAlphaMod|SDL_GetSurfaceBlendMode|SDL_GetSurfaceClipRect|SDL_GetSurfaceColorKey|SDL_GetSurfaceColorMod|SDL_GetTextInputArea|SDL_GetTextureAlphaMod|SDL_GetTextureAlphaModFloat|SDL_GetTextureBlendMode|SDL_GetTextureColorMod|SDL_GetTextureColorModFloat|SDL_GetTextureScaleMode|SDL_GetTextureSize|SDL_GetWindowAspectRatio|SDL_GetWindowBordersSize|SDL_GetWindowMaximumSize|SDL_GetWindowMinimumSize|SDL_GetWindowPosition|SDL_GetWindowRelativeMouseMode|SDL_GetWindowSafeArea|SDL_GetWindowSize|SDL_GetWindowSizeInPixels|SDL_GetWindowSurfaceVSync|SDL_HideCursor|SDL_HideWindow|SDL_Init|SDL_InitHapticRumble|SDL_InitSubSystem|SDL_LoadWAV|SDL_LoadWAV_IO|SDL_LockAudioStream|SDL_LockProperties|SDL_LockSurface|SDL_LockTexture|SDL_LockTextureToSurface|SDL_MaximizeWindow|SDL_MinimizeWindow|SDL_MixAudio|SDL_OpenURL|SDL_OutOfMemory|SDL_PauseAudioDevice|SDL_PauseAudioStreamDevice|SDL_PauseHaptic|SDL_PlayHapticRumble|SDL_PremultiplyAlpha|SDL_PremultiplySurfaceAlpha|SDL_PushEvent|SDL_PutAudioStreamData|SDL_RaiseWindow|SDL_ReadStorageFile|SDL_ReadSurfacePixel|SDL_ReadSurfacePixelFloat|SDL_RegisterApp|SDL_ReloadGamepadMappings|SDL_RemovePath|SDL_RemoveStoragePath|SDL_RemoveTimer|SDL_RenamePath|SDL_RenameStoragePath|SDL_RenderClear|SDL_RenderCoordinatesFromWindow|SDL_RenderCoordinatesToWindow|SDL_RenderFillRect|SDL_RenderFillRects|SDL_RenderGeometry|SDL_RenderGeometryRaw|SDL_RenderLine|SDL_RenderLines|SDL_RenderPoint|SDL_RenderPoints|SDL_RenderPresent|SDL_RenderRect|SDL_RenderRects|SDL_RenderTexture|SDL_RenderTexture9Grid|SDL_RenderTextureRotated|SDL_RenderTextureTiled|SDL_RequestAndroidPermission|SDL_RestoreWindow|SDL_ResumeAudioDevice|SDL_ResumeAudioStreamDevice|SDL_ResumeHaptic|SDL_RumbleGamepad|SDL_RumbleGamepadTriggers|SDL_RumbleJoystick|SDL_RumbleJoystickTriggers|SDL_RunHapticEffect|SDL_SaveBMP|SDL_SaveBMP_IO|SDL_SendAndroidMessage|SDL_SendGamepadEffect|SDL_SendJoystickEffect|SDL_SendJoystickVirtualSensorData|SDL_SetAppMetadata|SDL_SetAppMetadataProperty|SDL_SetAudioDeviceGain|SDL_SetAudioPostmixCallback|SDL_SetAudioStreamFormat|SDL_SetAudioStreamFrequencyRatio|SDL_SetAudioStreamGain|SDL_SetAudioStreamGetCallback|SDL_SetAudioStreamInputChannelMap|SDL_SetAudioStreamOutputChannelMap|SDL_SetAudioStreamPutCallback|SDL_SetBooleanProperty|SDL_SetClipboardData|SDL_SetClipboardText|SDL_SetCursor|SDL_SetFloatProperty|SDL_SetGamepadLED|SDL_SetGamepadMapping|SDL_SetGamepadPlayerIndex|SDL_SetGamepadSensorEnabled|SDL_SetHapticAutocenter|SDL_SetHapticGain|SDL_SetJoystickLED|SDL_SetJoystickPlayerIndex|SDL_SetJoystickVirtualAxis|SDL_SetJoystickVirtualBall|SDL_SetJoystickVirtualButton|SDL_SetJoystickVirtualHat|SDL_SetJoystickVirtualTouchpad|SDL_SetLinuxThreadPriority|SDL_SetLinuxThreadPriorityAndPolicy|SDL_SetLogPriorityPrefix|SDL_SetMemoryFunctions|SDL_SetNumberProperty|SDL_SetPaletteColors|SDL_SetPointerProperty|SDL_SetPointerPropertyWithCleanup|SDL_SetPrimarySelectionText|SDL_SetRenderClipRect|SDL_SetRenderColorScale|SDL_SetRenderDrawBlendMode|SDL_SetRenderDrawColor|SDL_SetRenderDrawColorFloat|SDL_SetRenderLogicalPresentation|SDL_SetRenderScale|SDL_SetRenderTarget|SDL_SetRenderVSync|SDL_SetRenderViewport|SDL_SetScancodeName|SDL_SetStringProperty|SDL_SetSurfaceAlphaMod|SDL_SetSurfaceBlendMode|SDL_SetSurfaceColorKey|SDL_SetSurfaceColorMod|SDL_SetSurfaceColorspace|SDL_SetSurfacePalette|SDL_SetSurfaceRLE|SDL_SetTLS|SDL_SetTextInputArea|SDL_SetTextureAlphaMod|SDL_SetTextureAlphaModFloat|SDL_SetTextureBlendMode|SDL_SetTextureColorMod|SDL_SetTextureColorModFloat|SDL_SetTextureScaleMode|SDL_SetThreadPriority|SDL_SetWindowAlwaysOnTop|SDL_SetWindowAspectRatio|SDL_SetWindowBordered|SDL_SetWindowFocusable|SDL_SetWindowFullscreen|SDL_SetWindowFullscreenMode|SDL_SetWindowHitTest|SDL_SetWindowIcon|SDL_SetWindowKeyboardGrab|SDL_SetWindowMaximumSize|SDL_SetWindowMinimumSize|SDL_SetWindowModalFor|SDL_SetWindowMouseGrab|SDL_SetWindowMouseRect|SDL_SetWindowOpacity|SDL_SetWindowPosition|SDL_SetWindowRelativeMouseMode|SDL_SetWindowResizable|SDL_SetWindowShape|SDL_SetWindowSize|SDL_SetWindowSurfaceVSync|SDL_SetWindowTitle|SDL_SetiOSAnimationCallback|SDL_ShowAndroidToast|SDL_ShowCursor|SDL_ShowMessageBox|SDL_ShowSimpleMessageBox|SDL_ShowWindow|SDL_ShowWindowSystemMenu|SDL_StartTextInput|SDL_StartTextInputWithProperties|SDL_StopHapticEffect|SDL_StopHapticEffects|SDL_StopHapticRumble|SDL_StopTextInput|SDL_SyncWindow|SDL_TimeToDateTime|SDL_TryLockMutex|SDL_TryLockRWLockForReading|SDL_TryLockRWLockForWriting|SDL_TryWaitSemaphore|SDL_UnlockAudioStream|SDL_UpdateHapticEffect|SDL_UpdateNVTexture|SDL_UpdateTexture|SDL_UpdateWindowSurface|SDL_UpdateWindowSurfaceRects|SDL_UpdateYUVTexture|SDL_Vulkan_CreateSurface|SDL_Vulkan_LoadLibrary|SDL_WaitConditionTimeout|SDL_WaitSemaphoreTimeout|SDL_WarpMouseGlobal|SDL_WriteStorageFile|SDL_WriteSurfacePixel|SDL_WriteSurfacePixelFloat)$";
@@
(
  func(
  ...
  )
- == 0
|
- func(
+ !func(
  ...
  )
- < 0
|
- func(
+ !func(
  ...
  )
- != 0
|
- func(
+ !func(
  ...
  )
- == -1
)

src/thread/SDL_systhread.h

@@ -36,15 +36,15 @@ extern "C" {
    saves a system-dependent thread id in thread->id, and returns 0
    on success.
 */
-extern int SDL_SYS_CreateThread(SDL_Thread *thread,
-                                SDL_FunctionPointer pfnBeginThread,
-                                SDL_FunctionPointer pfnEndThread);
+extern bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                                 SDL_FunctionPointer pfnBeginThread,
+                                 SDL_FunctionPointer pfnEndThread);
 
 // This function does any necessary setup in the child thread
 extern void SDL_SYS_SetupThread(const char *name);
 
 // This function sets the current thread priority
-extern int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority);
+extern bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority);
 
 /* This function waits for the thread to finish and frees any data
    allocated by SDL_SYS_CreateThread()
@@ -61,7 +61,7 @@ extern void SDL_SYS_InitTLSData(void);
 extern SDL_TLSData *SDL_SYS_GetTLSData(void);
 
 // Set the thread local storage for this thread
-extern int SDL_SYS_SetTLSData(SDL_TLSData *data);
+extern bool SDL_SYS_SetTLSData(SDL_TLSData *data);
 
 // Quit the global TLS data
 extern void SDL_SYS_QuitTLSData(void);

src/thread/SDL_thread.c

@@ -54,7 +54,7 @@ void *SDL_GetTLS(SDL_TLSID *id)
     return storage->array[storage_index].data;
 }
 
-int SDL_SetTLS(SDL_TLSID *id, const void *value, SDL_TLSDestructorCallback destructor)
+SDL_bool SDL_SetTLS(SDL_TLSID *id, const void *value, SDL_TLSDestructorCallback destructor)
 {
     SDL_TLSData *storage;
     int storage_index;
@@ -92,7 +92,7 @@ int SDL_SetTLS(SDL_TLSID *id, const void *value, SDL_TLSDestructorCallback destr
         newlimit = (storage_index + TLS_ALLOC_CHUNKSIZE);
         new_storage = (SDL_TLSData *)SDL_realloc(storage, sizeof(*storage) + (newlimit - 1) * sizeof(storage->array[0]));
         if (!new_storage) {
-            return -1;
+            return false;
         }
         storage = new_storage;
         storage->limit = newlimit;
@@ -100,16 +100,16 @@ int SDL_SetTLS(SDL_TLSID *id, const void *value, SDL_TLSDestructorCallback destr
             storage->array[i].data = NULL;
             storage->array[i].destructor = NULL;
         }
-        if (SDL_SYS_SetTLSData(storage) != 0) {
+        if (!SDL_SYS_SetTLSData(storage)) {
             SDL_free(storage);
-            return -1;
+            return false;
         }
         SDL_AtomicIncRef(&SDL_tls_allocated);
     }
 
     storage->array[storage_index].data = SDL_const_cast(void *, value);
     storage->array[storage_index].destructor = destructor;
-    return 0;
+    return true;
 }
 
 void SDL_CleanupTLS(void)
@@ -185,11 +185,11 @@ SDL_TLSData *SDL_Generic_GetTLSData(void)
     return storage;
 }
 
-int SDL_Generic_SetTLSData(SDL_TLSData *data)
+bool SDL_Generic_SetTLSData(SDL_TLSData *data)
 {
     SDL_ThreadID thread = SDL_GetCurrentThreadID();
     SDL_TLSEntry *prev, *entry;
-    int retval = 0;
+    bool result = true;
 
     SDL_LockMutex(SDL_generic_TLS_mutex);
     prev = NULL;
@@ -217,12 +217,12 @@ int SDL_Generic_SetTLSData(SDL_TLSData *data)
             entry->next = SDL_generic_TLS;
             SDL_generic_TLS = entry;
         } else {
-            retval = -1;
+            result = false;
         }
     }
     SDL_UnlockMutex(SDL_generic_TLS_mutex);
 
-    return retval;
+    return result;
 }
 
 void SDL_Generic_QuitTLSData(void)
@@ -380,7 +380,7 @@ SDL_Thread *SDL_CreateThreadWithPropertiesRuntime(SDL_PropertiesID props,
     thread->stacksize = stacksize;
 
     // Create the thread and go!
-    if (SDL_SYS_CreateThread(thread, pfnBeginThread, pfnEndThread) < 0) {
+    if (!SDL_SYS_CreateThread(thread, pfnBeginThread, pfnEndThread)) {
         // Oops, failed.  Gotta free everything
         SDL_free(thread->name);
         SDL_free(thread);
@@ -439,7 +439,7 @@ const char *SDL_GetThreadName(SDL_Thread *thread)
     }
 }
 
-int SDL_SetThreadPriority(SDL_ThreadPriority priority)
+SDL_bool SDL_SetThreadPriority(SDL_ThreadPriority priority)
 {
     return SDL_SYS_SetThreadPriority(priority);
 }
@@ -478,17 +478,17 @@ void SDL_DetachThread(SDL_Thread *thread)
     }
 }
 
-int SDL_WaitSemaphore(SDL_Semaphore *sem)
+void SDL_WaitSemaphore(SDL_Semaphore *sem)
 {
-    return SDL_WaitSemaphoreTimeoutNS(sem, -1);
+    SDL_WaitSemaphoreTimeoutNS(sem, -1);
 }
 
-int SDL_TryWaitSemaphore(SDL_Semaphore *sem)
+SDL_bool SDL_TryWaitSemaphore(SDL_Semaphore *sem)
 {
     return SDL_WaitSemaphoreTimeoutNS(sem, 0);
 }
 
-int SDL_WaitSemaphoreTimeout(SDL_Semaphore *sem, Sint32 timeoutMS)
+SDL_bool SDL_WaitSemaphoreTimeout(SDL_Semaphore *sem, Sint32 timeoutMS)
 {
     Sint64 timeoutNS;
 
@@ -500,12 +500,12 @@ int SDL_WaitSemaphoreTimeout(SDL_Semaphore *sem, Sint32 timeoutMS)
     return SDL_WaitSemaphoreTimeoutNS(sem, timeoutNS);
 }
 
-int SDL_WaitCondition(SDL_Condition *cond, SDL_Mutex *mutex)
+void SDL_WaitCondition(SDL_Condition *cond, SDL_Mutex *mutex)
 {
-    return SDL_WaitConditionTimeoutNS(cond, mutex, -1);
+    SDL_WaitConditionTimeoutNS(cond, mutex, -1);
 }
 
-int SDL_WaitConditionTimeout(SDL_Condition *cond, SDL_Mutex *mutex, Sint32 timeoutMS)
+SDL_bool SDL_WaitConditionTimeout(SDL_Condition *cond, SDL_Mutex *mutex, Sint32 timeoutMS)
 {
     Sint64 timeoutNS;
 
@@ -516,3 +516,4 @@ int SDL_WaitConditionTimeout(SDL_Condition *cond, SDL_Mutex *mutex, Sint32 timeo
     }
     return SDL_WaitConditionTimeoutNS(cond, mutex, timeoutNS);
 }
+

src/thread/SDL_thread_c.h

@@ -98,7 +98,7 @@ extern void SDL_QuitTLSData(void);
  */
 extern void SDL_Generic_InitTLSData(void);
 extern SDL_TLSData *SDL_Generic_GetTLSData(void);
-extern int SDL_Generic_SetTLSData(SDL_TLSData *data);
+extern bool SDL_Generic_SetTLSData(SDL_TLSData *data);
 extern void SDL_Generic_QuitTLSData(void);
 
 #endif // SDL_thread_c_h_

src/thread/generic/SDL_syscond.c

@@ -37,7 +37,6 @@
 #define SDL_DestroyCondition_generic     SDL_DestroyCondition
 #define SDL_SignalCondition_generic      SDL_SignalCondition
 #define SDL_BroadcastCondition_generic   SDL_BroadcastCondition
-#define SDL_WaitConditionTimeoutNS_generic SDL_WaitConditionTimeoutNS
 #endif
 
 typedef struct SDL_cond_generic
@@ -89,11 +88,11 @@ void SDL_DestroyCondition_generic(SDL_Condition *_cond)
 }
 
 // Restart one of the threads that are waiting on the condition variable
-int SDL_SignalCondition_generic(SDL_Condition *_cond)
+void SDL_SignalCondition_generic(SDL_Condition *_cond)
 {
     SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
 #ifndef SDL_THREADS_DISABLED
@@ -110,16 +109,14 @@ int SDL_SignalCondition_generic(SDL_Condition *_cond)
         SDL_UnlockMutex(cond->lock);
     }
 #endif
-
-    return 0;
 }
 
 // Restart all threads that are waiting on the condition variable
-int SDL_BroadcastCondition_generic(SDL_Condition *_cond)
+void SDL_BroadcastCondition_generic(SDL_Condition *_cond)
 {
     SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
 #ifndef SDL_THREADS_DISABLED
@@ -146,8 +143,6 @@ int SDL_BroadcastCondition_generic(SDL_Condition *_cond)
         SDL_UnlockMutex(cond->lock);
     }
 #endif
-
-    return 0;
 }
 
 /* Wait on the condition variable for at most 'timeoutNS' nanoseconds.
@@ -171,13 +166,13 @@ Thread B:
     SDL_SignalCondition(cond);
     SDL_UnlockMutex(lock);
  */
-int SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, Sint64 timeoutNS)
 {
     SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
-    int retval = 0;
+    bool result = true;
 
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
+    if (!cond || !mutex) {
+        return true;
     }
 
 #ifndef SDL_THREADS_DISABLED
@@ -193,7 +188,7 @@ int SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, S
     SDL_UnlockMutex(mutex);
 
     // Wait for a signal
-    retval = SDL_WaitSemaphoreTimeoutNS(cond->wait_sem, timeoutNS);
+    result = SDL_WaitSemaphoreTimeoutNS(cond->wait_sem, timeoutNS);
 
     /* Let the signaler know we have completed the wait, otherwise
        the signaler can race ahead and get the condition semaphore
@@ -204,7 +199,7 @@ int SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, S
     SDL_LockMutex(cond->lock);
     if (cond->signals > 0) {
         // If we timed out, we need to eat a condition signal
-        if (retval > 0) {
+        if (!result) {
             SDL_WaitSemaphore(cond->wait_sem);
         }
         // We always notify the signal thread that we are done
@@ -220,5 +215,12 @@ int SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, S
     SDL_LockMutex(mutex);
 #endif
 
-    return retval;
+    return result;
 }
+
+#ifndef SDL_THREAD_GENERIC_COND_SUFFIX
+SDL_bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+{
+    return SDL_WaitConditionTimeoutNS_generic(cond, mutex, timeoutNS);
+}
+#endif

src/thread/generic/SDL_syscond_c.h

@@ -27,9 +27,9 @@
 
 SDL_Condition *SDL_CreateCondition_generic(void);
 void SDL_DestroyCondition_generic(SDL_Condition *cond);
-int SDL_SignalCondition_generic(SDL_Condition *cond);
-int SDL_BroadcastCondition_generic(SDL_Condition *cond);
-int SDL_WaitConditionTimeoutNS_generic(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS);
+void SDL_SignalCondition_generic(SDL_Condition *cond);
+void SDL_BroadcastCondition_generic(SDL_Condition *cond);
+bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS);
 
 #endif // SDL_THREAD_GENERIC_COND_SUFFIX
 

src/thread/generic/SDL_sysmutex.c

@@ -81,9 +81,9 @@ void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doe
 #endif // SDL_THREADS_DISABLED
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    int retval = 0;
+    bool result = true;
 #ifndef SDL_THREADS_DISABLED
     if (mutex) {
         SDL_ThreadID this_thread = SDL_GetCurrentThreadID();
@@ -91,18 +91,18 @@ int SDL_TryLockMutex(SDL_Mutex *mutex)
             ++mutex->recursive;
         } else {
             /* The order of operations is important.
-             We set the locking thread id after we obtain the lock
-             so unlocks from other threads will fail.
+               We set the locking thread id after we obtain the lock
+               so unlocks from other threads will fail.
              */
-            retval = SDL_TryWaitSemaphore(mutex->sem);
-            if (retval == 0) {
+            result = SDL_TryWaitSemaphore(mutex->sem);
+            if (result) {
                 mutex->owner = this_thread;
                 mutex->recursive = 0;
             }
         }
     }
 #endif // SDL_THREADS_DISABLED
-    return retval;
+    return result;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes

src/thread/generic/SDL_sysrwlock.c

@@ -36,8 +36,6 @@
 #define SDL_DestroyRWLock_generic SDL_DestroyRWLock
 #define SDL_LockRWLockForReading_generic SDL_LockRWLockForReading
 #define SDL_LockRWLockForWriting_generic SDL_LockRWLockForWriting
-#define SDL_TryLockRWLockForReading_generic SDL_TryLockRWLockForReading
-#define SDL_TryLockRWLockForWriting_generic SDL_TryLockRWLockForWriting
 #define SDL_UnlockRWLock_generic SDL_UnlockRWLock
 #endif
 
@@ -122,14 +120,13 @@ void SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_A
 #endif
 }
 
-int SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock)
+bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock)
 {
 #ifndef SDL_THREADS_DISABLED
     if (rwlock) {
-        const int rc = SDL_TryLockMutex(rwlock->lock);
-        if (rc != 0) {
+        if (!SDL_TryLockMutex(rwlock->lock)) {
             // !!! FIXME: there is a small window where a reader has to lock the mutex, and if we hit that, we will return SDL_RWLOCK_TIMEDOUT even though we could have shared the lock.
-            return rc;
+            return false;
         }
 
         SDL_assert(SDL_AtomicGet(&rwlock->writer_count) == 0);  // shouldn't be able to grab lock if there's a writer!
@@ -138,21 +135,27 @@ int SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock)
     }
 #endif
 
-    return 0;
+    return true;
 }
 
-int SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock)
+#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+SDL_bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
+{
+    return SDL_TryLockRWLockForReading_generic(rwlock);
+}
+#endif
+
+bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock)
 {
 #ifndef SDL_THREADS_DISABLED
     if (rwlock) {
-        const int rc = SDL_TryLockMutex(rwlock->lock);
-        if (rc != 0) {
-            return rc;
+        if (!SDL_TryLockMutex(rwlock->lock)) {
+            return false;
         }
 
         if (SDL_AtomicGet(&rwlock->reader_count) > 0) {  // a reader is using the shared lock, treat it as unavailable.
             SDL_UnlockMutex(rwlock->lock);
-            return SDL_RWLOCK_TIMEDOUT;
+            return false;
         }
 
         // we hold the lock!
@@ -160,9 +163,16 @@ int SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock)
     }
 #endif
 
-    return 0;
+    return true;
 }
 
+#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+SDL_bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
+{
+    return SDL_TryLockRWLockForWriting_generic(rwlock);
+}
+#endif
+
 void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
 #ifndef SDL_THREADS_DISABLED

src/thread/generic/SDL_sysrwlock_c.h

@@ -29,8 +29,8 @@ SDL_RWLock *SDL_CreateRWLock_generic(void);
 void SDL_DestroyRWLock_generic(SDL_RWLock *rwlock);
 void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock);
 void  SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock);
-int SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock);
-int SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock);
+bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock);
+bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock);
 void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock);
 
 #endif // SDL_THREAD_GENERIC_RWLOCK_SUFFIX

src/thread/generic/SDL_syssem.c

@@ -29,16 +29,16 @@
 SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
 {
     SDL_SetError("SDL not built with thread support");
-    return (SDL_Semaphore *)0;
+    return NULL;
 }
 
 void SDL_DestroySemaphore(SDL_Semaphore *sem)
 {
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
-    return SDL_SetError("SDL not built with thread support");
+    return true;
 }
 
 Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
@@ -46,9 +46,9 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     return 0;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    return SDL_SetError("SDL not built with thread support");
+    return;
 }
 
 #else
@@ -103,41 +103,54 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     }
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
-    int retval;
+    bool result = false;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
-    // A timeout of 0 is an easy case
     if (timeoutNS == 0) {
-        retval = SDL_MUTEX_TIMEDOUT;
         SDL_LockMutex(sem->count_lock);
         if (sem->count > 0) {
             --sem->count;
-            retval = 0;
+            result = true;
         }
         SDL_UnlockMutex(sem->count_lock);
-
-        return retval;
-    }
-
-    SDL_LockMutex(sem->count_lock);
-    ++sem->waiters_count;
-    retval = 0;
-    while ((sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT)) {
-        retval = SDL_WaitConditionTimeoutNS(sem->count_nonzero,
-                                     sem->count_lock, timeoutNS);
-    }
-    --sem->waiters_count;
-    if (retval == 0) {
+    } else if (timeoutNS < 0) {
+        SDL_LockMutex(sem->count_lock);
+        ++sem->waiters_count;
+        while (sem->count == 0) {
+            SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, -1);
+        }
+        --sem->waiters_count;
         --sem->count;
-    }
-    SDL_UnlockMutex(sem->count_lock);
+        result = true;
+        SDL_UnlockMutex(sem->count_lock);
+    } else {
+        Uint64 stop_time = SDL_GetTicksNS() + timeoutNS;
 
-    return retval;
+        SDL_LockMutex(sem->count_lock);
+        ++sem->waiters_count;
+        while (sem->count == 0) {
+            Sint64 waitNS = (Sint64)(stop_time - SDL_GetTicksNS());
+            if (waitNS > 0) {
+                SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, waitNS);
+            } else {
+                break;
+            }
+        }
+        --sem->waiters_count;
+
+        if (sem->count > 0) {
+            --sem->count;
+            result = true;
+        }
+        SDL_UnlockMutex(sem->count_lock);
+    }
+
+    return result;
 }
 
 Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
@@ -153,10 +166,10 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     return value;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
     SDL_LockMutex(sem->count_lock);
@@ -165,8 +178,6 @@ int SDL_SignalSemaphore(SDL_Semaphore *sem)
     }
     ++sem->count;
     SDL_UnlockMutex(sem->count_lock);
-
-    return 0;
 }
 
 #endif // SDL_THREADS_DISABLED

src/thread/generic/SDL_systhread.c

@@ -24,9 +24,9 @@
 
 #include "../SDL_systhread.h"
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     return SDL_SetError("Threads are not supported on this platform");
 }
@@ -41,9 +41,9 @@ SDL_ThreadID SDL_GetCurrentThreadID(void)
     return 0;
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
-    return 0;
+    return true;
 }
 
 void SDL_SYS_WaitThread(SDL_Thread *thread)

src/thread/generic/SDL_systls.c

@@ -32,7 +32,7 @@ SDL_TLSData *SDL_SYS_GetTLSData(void)
     return SDL_Generic_GetTLSData();
 }
 
-int SDL_SYS_SetTLSData(SDL_TLSData *data)
+bool SDL_SYS_SetTLSData(SDL_TLSData *data)
 {
     return SDL_Generic_SetTLSData(data);
 }

src/thread/n3ds/SDL_syscond.c

@@ -50,25 +50,23 @@ void SDL_DestroyCondition(SDL_Condition *cond)
 }
 
 // Restart one of the threads that are waiting on the condition variable
-int SDL_SignalCondition(SDL_Condition *cond)
+void SDL_SignalCondition(SDL_Condition *cond)
 {
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
     CondVar_Signal(&cond->cond_variable);
-    return 0;
 }
 
 // Restart all threads that are waiting on the condition variable
-int SDL_BroadcastCondition(SDL_Condition *cond)
+void SDL_BroadcastCondition(SDL_Condition *cond)
 {
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
     CondVar_Broadcast(&cond->cond_variable);
-    return 0;
 }
 
 /* Wait on the condition variable for at most 'timeoutNS' nanoseconds.
@@ -92,15 +90,12 @@ Thread B:
     SDL_SignalCondition(cond);
     SDL_UnlockMutex(lock);
  */
-int SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+SDL_bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
 {
     Result res;
 
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
-    }
-    if (!mutex) {
-        return SDL_InvalidParamError("mutex");
+    if (!cond || !mutex) {
+        return true;
     }
 
     res = 0;
@@ -110,7 +105,7 @@ int SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 tim
         res = CondVar_WaitTimeout(&cond->cond_variable, &mutex->lock.lock, timeoutNS);
     }
 
-    return R_SUCCEEDED(res) ? 0 : SDL_MUTEX_TIMEDOUT;
+    return R_SUCCEEDED(res);
 }
 
 #endif // SDL_THREAD_N3DS

src/thread/n3ds/SDL_sysmutex.c

@@ -44,19 +44,22 @@ void SDL_DestroyMutex(SDL_Mutex *mutex)
 
 void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         RecursiveLock_Lock(&mutex->lock);
     }
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    return (!mutex) ? 0 : RecursiveLock_TryLock(&mutex->lock);
+    if (mutex) {
+        return RecursiveLock_TryLock(&mutex->lock);
+    }
+    return true;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         RecursiveLock_Unlock(&mutex->lock);
     }
 }

src/thread/n3ds/SDL_syssem.c

@@ -26,8 +26,6 @@
 
 #include <3ds.h>
 
-int WaitOnSemaphoreFor(SDL_Semaphore *sem, Sint64 timeout);
-
 struct SDL_Semaphore
 {
     LightSemaphore semaphore;
@@ -60,58 +58,55 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     SDL_free(sem);
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+static bool WaitOnSemaphoreFor(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
-    if (!sem) {
-        return SDL_InvalidParamError("sem");
-    }
-
-    if (timeoutNS == -1) {  // -1 == wait indefinitely.
-        LightSemaphore_Acquire(&sem->semaphore, 1);
-        return 0;
-    }
-
-    if (LightSemaphore_TryAcquire(&sem->semaphore, 1) != 0) {
-        return WaitOnSemaphoreFor(sem, timeoutNS);
-    }
-
-    return 0;
-}
-
-int WaitOnSemaphoreFor(SDL_Semaphore *sem, Sint64 timeout)
-{
-    Uint64 stop_time = SDL_GetTicksNS() + timeout;
-    Uint64 current_time = SDL_GetTicksNS();
-    while (current_time < stop_time) {
+    Uint64 stop_time = SDL_GetTicksNS() + timeoutNS;
+    while (SDL_GetTicksNS() < stop_time) {
         if (LightSemaphore_TryAcquire(&sem->semaphore, 1) == 0) {
-            return 0;
+            return true;
         }
         // 100 microseconds seems to be the sweet spot
         SDL_DelayNS(SDL_US_TO_NS(100));
-        current_time = SDL_GetTicksNS();
     }
 
     // If we failed, yield to avoid starvation on busy waits
     SDL_DelayNS(1);
-    return SDL_MUTEX_TIMEDOUT;
+    return false;
+}
+
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+{
+    if (!sem) {
+        return true;
+    }
+
+    if (timeoutNS < 0) { // -1 == wait indefinitely.
+        LightSemaphore_Acquire(&sem->semaphore, 1);
+        return true;
+    }
+
+    if (LightSemaphore_TryAcquire(&sem->semaphore, 1) == 0) {
+        return true;
+    }
+
+    return WaitOnSemaphoreFor(sem, timeoutNS);
 }
 
 Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
 {
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
     return sem->semaphore.current_count;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    if (!sem) {
-        return SDL_InvalidParamError("sem");
+    if (sem) {
+        return;
     }
+
     LightSemaphore_Release(&sem->semaphore, 1);
-    return 0;
 }
 
 #endif // SDL_THREAD_N3DS

src/thread/n3ds/SDL_systhread.c

@@ -43,9 +43,9 @@ static void ThreadEntry(void *arg)
 }
 
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     s32 priority = 0x30;
     int cpu = -1;
@@ -69,7 +69,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
         return SDL_SetError("Couldn't create thread");
     }
 
-    return 0;
+    return true;
 }
 
 static size_t GetStackSize(size_t requested_size)
@@ -93,7 +93,7 @@ SDL_ThreadID SDL_GetCurrentThreadID(void)
     return (SDL_ThreadID)thread_ID;
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority sdl_priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority sdl_priority)
 {
     s32 svc_priority;
     switch (sdl_priority) {
@@ -112,7 +112,10 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority sdl_priority)
     default:
         svc_priority = N3DS_THREAD_PRIORITY_MEDIUM;
     }
-    return (int)svcSetThreadPriority(CUR_THREAD_HANDLE, svc_priority);
+    if (svcSetThreadPriority(CUR_THREAD_HANDLE, svc_priority) < 0) {
+        return SDL_SetError("svcSetThreadPriority failed");
+    }
+    return true;
 }
 
 void SDL_SYS_WaitThread(SDL_Thread *thread)

src/thread/ngage/SDL_sysmutex.cpp

@@ -69,7 +69,7 @@ void SDL_DestroyMutex(SDL_Mutex *mutex)
 // Lock the mutex
 void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         RMutex rmutex;
         rmutex.SetHandle(mutex->handle);
         rmutex.Wait();
@@ -78,22 +78,20 @@ void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang does
 
 // Try to lock the mutex
 #if 0
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    if (mutex == NULL)
-    {
-        return 0;
+    if (mutex) {
+        // Not yet implemented.
+        return true;
     }
-
-    // Not yet implemented.
-    return 0;
+    return true;
 }
 #endif
 
 // Unlock the mutex
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         RMutex rmutex;
         rmutex.SetHandle(mutex->handle);
         rmutex.Signal();

src/thread/ngage/SDL_syssem.cpp

@@ -24,9 +24,6 @@
 
 #include <e32std.h>
 
-// !!! FIXME: Should this be SDL_MUTEX_TIMEDOUT?
-#define SDL_MUTEX_TIMEOUT -2
-
 struct SDL_Semaphore
 {
     TInt handle;
@@ -35,10 +32,10 @@ struct SDL_Semaphore
 
 struct TInfo
 {
-    TInfo(TInt aTime, TInt aHandle) : iTime(aTime), iHandle(aHandle), iVal(0) {}
+    TInfo(TInt aTime, TInt aHandle) : iTime(aTime), iHandle(aHandle), iVal(true) {}
     TInt iTime;
     TInt iHandle;
-    TInt iVal;
+    bool iVal;
 };
 
 extern TInt CreateUnique(TInt (*aFunc)(const TDesC &aName, TAny *, TAny *), TAny *, TAny *);
@@ -50,7 +47,7 @@ static TBool RunThread(TAny *aInfo)
     RSemaphore sema;
     sema.SetHandle(info->iHandle);
     sema.Signal();
-    info->iVal = SDL_MUTEX_TIMEOUT;
+    info->iVal = false;
     return 0;
 }
 
@@ -100,23 +97,23 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     }
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     if (timeoutNS == 0) {
         if (sem->count > 0) {
             --sem->count;
-            return 0;
+            return true;
         }
-        return SDL_MUTEX_TIMEOUT;
+        return false;
     }
 
     if (timeoutNS == -1) {  // -1 == wait indefinitely.
         WaitAll(sem);
-        return 0;
+        return true;
     }
 
     RThread thread;
@@ -124,14 +121,14 @@ int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
     TInt status = CreateUnique(NewThread, &thread, info);
 
     if (status != KErrNone) {
-        return status;
+        return false;
     }
 
     thread.Resume();
     WaitAll(sem);
 
     if (thread.ExitType() == EExitPending) {
-        thread.Kill(SDL_MUTEX_TIMEOUT);
+        thread.Kill(false);
     }
 
     thread.Close();

src/thread/ngage/SDL_systhread.cpp

@@ -57,9 +57,9 @@ int CreateUnique(TInt (*aFunc)(const TDesC &aName, TAny *, TAny *), TAny *aPtr1,
     return status;
 }
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     RThread rthread;
 
@@ -72,7 +72,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
 
     rthread.Resume();
     thread->handle = rthread.Handle();
-    return 0;
+    return true;
 }
 
 void SDL_SYS_SetupThread(const char *name)
@@ -87,9 +87,9 @@ SDL_ThreadID SDL_GetCurrentThreadID(void)
     return id;
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
-    return 0;
+    return true;
 }
 
 void SDL_SYS_WaitThread(SDL_Thread *thread)

src/thread/ps2/SDL_syssem.c

@@ -72,21 +72,17 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     }
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
-    int ret;
     u64 timeout_usec;
     u64 *timeout_ptr;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     if (timeoutNS == 0) {
-        if (PollSema(sem->semid) < 0) {
-            return SDL_MUTEX_TIMEDOUT;
-        }
-        return 0;
+        return (PollSema(sem->semid) == 0);
     }
 
     timeout_ptr = NULL;
@@ -96,12 +92,7 @@ int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
         timeout_ptr = &timeout_usec;
     }
 
-    ret = WaitSemaEx(sem->semid, 1, timeout_ptr);
-
-    if (ret < 0) {
-        return SDL_MUTEX_TIMEDOUT;
-    }
-    return 0; // Wait condition satisfied.
+    return (WaitSemaEx(sem->semid, 1, timeout_ptr) == 0);
 }
 
 // Returns the current count of the semaphore
@@ -110,31 +101,22 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     ee_sema_t info;
 
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
 
-    if (ReferSemaStatus(sem->semid, &info) >= 0) {
+    if (ReferSemaStatus(sem->semid, &info) == 0) {
         return info.count;
     }
-
     return 0;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    int res;
-
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
-    res = SignalSema(sem->semid);
-    if (res < 0) {
-        return SDL_SetError("sceKernelSignalSema() failed");
-    }
-
-    return 0;
+    SignalSema(sem->semid);
 }
 
 #endif // SDL_THREAD_PS2

src/thread/ps2/SDL_systhread.c

@@ -54,9 +54,9 @@ static int childThread(void *arg)
     return res;
 }
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     ee_thread_status_t status;
     ee_thread_t eethread;
@@ -92,7 +92,10 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
     sema.option = 0;
     thread->endfunc = (void *)CreateSema(&sema);
 
-    return StartThread(thread->handle, thread);
+    if (StartThread(thread->handle, thread) < 0) {
+        return SDL_SetError("StartThread() failed");
+    }
+    return true;
 }
 
 void SDL_SYS_SetupThread(const char *name)
@@ -117,7 +120,7 @@ void SDL_SYS_DetachThread(SDL_Thread *thread)
     // Do nothing.
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
     int value;
 
@@ -131,7 +134,10 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
         value = 50;
     }
 
-    return ChangeThreadPriority(GetThreadId(), value);
+    if (ChangeThreadPriority(GetThreadId(), value) < 0) {
+        return SDL_SetError("ChangeThreadPriority() failed");
+    }
+    return true;
 }
 
 #endif // SDL_THREAD_PS2

src/thread/psp/SDL_sysmutex.c

@@ -66,41 +66,35 @@ void SDL_DestroyMutex(SDL_Mutex *mutex)
 
 void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-#ifndef SDL_THREADS_DISABLED
-    if (mutex != NULL) {
+    if (mutex) {
         const SceInt32 res = sceKernelLockLwMutex(&mutex->lock, 1, NULL);
         SDL_assert(res == SCE_KERNEL_ERROR_OK);  // assume we're in a lot of trouble if this assert fails.
     }
-#endif // SDL_THREADS_DISABLED
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    int retval = 0;
-#ifndef SDL_THREADS_DISABLED
+    bool result = true;
     if (mutex) {
         const SceInt32 res = sceKernelTryLockLwMutex(&mutex->lock, 1);
         if (res == SCE_KERNEL_ERROR_OK) {
-            retval = 0;
+            result = true;
         } else if (res == SCE_KERNEL_ERROR_WAIT_TIMEOUT) {
-            retval = SDL_MUTEX_TIMEDOUT;
+            result = false;
         } else {
-            SDL_assert(!"Error trying to lock mutex");  // assume we're in a lot of trouble if this assert fails.
-            retval = SDL_MUTEX_TIMEDOUT;
+            SDL_assert(res == SCE_KERNEL_ERROR_OK);  // assume we're in a lot of trouble if this assert fails.
+            result = false;
         }
     }
-#endif // SDL_THREADS_DISABLED
-    return retval;
+    return result;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-#ifndef SDL_THREADS_DISABLED
-    if (mutex != NULL) {
+    if (mutex) {
         const SceInt32 res = sceKernelUnlockLwMutex(&mutex->lock, 1);
-        SDL_assert(res == 0);  // assume we're in a lot of trouble if this assert fails.
+        SDL_assert(res == SCE_KERNEL_ERROR_OK);  // assume we're in a lot of trouble if this assert fails.
     }
-#endif // SDL_THREADS_DISABLED
 }
 
 #endif // SDL_THREAD_PSP

src/thread/psp/SDL_syssem.c

@@ -71,40 +71,25 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
  * If the timeout is 0 then just poll the semaphore; if it's -1, pass
  * NULL to sceKernelWaitSema() so that it waits indefinitely; and if the timeout
  * is specified, convert it to microseconds. */
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
 	SceUInt timeoutUS;
-    SceUInt *pTimeout;
-    int res;
+    SceUInt *pTimeout = NULL;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     if (timeoutNS == 0) {
-        res = sceKernelPollSema(sem->semid, 1);
-        if (res < 0) {
-            return SDL_MUTEX_TIMEDOUT;
-        }
-        return 0;
+        return (sceKernelPollSema(sem->semid, 1) == 0);
     }
 
-    if (timeoutNS < 0) {
-        pTimeout = NULL;
-    } else {
+    if (timeoutNS > 0) {
         timeoutUS = (SceUInt)SDL_NS_TO_US(timeoutNS); // Convert to microseconds.
         pTimeout = &timeoutUS;
     }
 
-    res = sceKernelWaitSema(sem->semid, 1, pTimeout);
-    switch (res) {
-    case SCE_KERNEL_ERROR_OK:
-        return 0;
-    case SCE_KERNEL_ERROR_WAIT_TIMEOUT:
-        return SDL_MUTEX_TIMEDOUT;
-    default:
-        return SDL_SetError("sceKernelWaitSema() failed");
-    }
+    return (sceKernelWaitSema(sem->semid, 1, pTimeout) == 0);
 }
 
 // Returns the current count of the semaphore
@@ -113,31 +98,22 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     SceKernelSemaInfo info;
 
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
 
-    if (sceKernelReferSemaStatus(sem->semid, &info) >= 0) {
+    if (sceKernelReferSemaStatus(sem->semid, &info) == 0) {
         return info.currentCount;
     }
-
     return 0;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    int res;
-
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
-    res = sceKernelSignalSema(sem->semid, 1);
-    if (res < 0) {
-        return SDL_SetError("sceKernelSignalSema() failed");
-    }
-
-    return 0;
+    sceKernelSignalSema(sem->semid, 1);
 }
 
 #endif // SDL_THREAD_PSP

src/thread/psp/SDL_systhread.c

@@ -38,9 +38,9 @@ static int ThreadEntry(SceSize args, void *argp)
     return 0;
 }
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     SceKernelThreadInfo status;
     int priority = 32;
@@ -59,7 +59,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
     }
 
     sceKernelStartThread(thread->handle, 4, &thread);
-    return 0;
+    return true;
 }
 
 void SDL_SYS_SetupThread(const char *name)
@@ -89,7 +89,7 @@ void SDL_SYS_KillThread(SDL_Thread *thread)
     sceKernelTerminateDeleteThread(thread->handle);
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
     int value;
 
@@ -103,7 +103,10 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
         value = 50;
     }
 
-    return sceKernelChangeThreadPriority(sceKernelGetThreadId(), value);
+    if (sceKernelChangeThreadPriority(sceKernelGetThreadId(), value) < 0) {
+        return SDL_SetError("sceKernelChangeThreadPriority() failed");
+    }
+    return true;
 }
 
 #endif // SDL_THREAD_PSP

src/thread/pthread/SDL_syscond.c

@@ -59,54 +59,38 @@ void SDL_DestroyCondition(SDL_Condition *cond)
 }
 
 // Restart one of the threads that are waiting on the condition variable
-int SDL_SignalCondition(SDL_Condition *cond)
+void SDL_SignalCondition(SDL_Condition *cond)
 {
-    int retval;
-
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
-    retval = 0;
-    if (pthread_cond_signal(&cond->cond) != 0) {
-        return SDL_SetError("pthread_cond_signal() failed");
-    }
-    return retval;
+    pthread_cond_signal(&cond->cond);
 }
 
 // Restart all threads that are waiting on the condition variable
-int SDL_BroadcastCondition(SDL_Condition *cond)
+void SDL_BroadcastCondition(SDL_Condition *cond)
 {
-    int retval;
-
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
-    retval = 0;
-    if (pthread_cond_broadcast(&cond->cond) != 0) {
-        return SDL_SetError("pthread_cond_broadcast() failed");
-    }
-    return retval;
+    pthread_cond_broadcast(&cond->cond);
 }
 
-int SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+SDL_bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
 {
-    int retval;
 #ifndef HAVE_CLOCK_GETTIME
     struct timeval delta;
 #endif
     struct timespec abstime;
 
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
+    if (!cond || !mutex) {
+        return true;
     }
 
     if (timeoutNS < 0) {
-        if (pthread_cond_wait(&cond->cond, &mutex->id) != 0) {
-            return SDL_SetError("pthread_cond_wait() failed");
-        }
-        return 0;
+        return (pthread_cond_wait(&cond->cond, &mutex->id) == 0);
     }
 
 #ifdef HAVE_CLOCK_GETTIME
@@ -125,19 +109,20 @@ int SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 tim
         abstime.tv_nsec -= 1000000000;
     }
 
+    bool result;
+    int rc;
 tryagain:
-    retval = pthread_cond_timedwait(&cond->cond, &mutex->id, &abstime);
-    switch (retval) {
+    rc = pthread_cond_timedwait(&cond->cond, &mutex->id, &abstime);
+    switch (rc) {
     case EINTR:
         goto tryagain;
         // break; -Wunreachable-code-break
     case ETIMEDOUT:
-        retval = SDL_MUTEX_TIMEDOUT;
-        break;
-    case 0:
+        result = false;
         break;
     default:
-        retval = SDL_SetError("pthread_cond_timedwait() failed");
+        result = false;
+        break;
     }
-    return retval;
+    return result;
 }

src/thread/pthread/SDL_sysmutex.c

@@ -60,7 +60,7 @@ void SDL_DestroyMutex(SDL_Mutex *mutex)
 
 void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
 #ifdef FAKE_RECURSIVE_MUTEX
         pthread_t this_thread = pthread_self();
         if (mutex->owner == this_thread) {
@@ -82,9 +82,9 @@ void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang does
     }
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    int retval = 0;
+    bool result = true;
 
     if (mutex) {
 #ifdef FAKE_RECURSIVE_MUTEX
@@ -93,39 +93,39 @@ int SDL_TryLockMutex(SDL_Mutex *mutex)
             ++mutex->recursive;
         } else {
             /* The order of operations is important.
-             We set the locking thread id after we obtain the lock
-             so unlocks from other threads will fail.
+               We set the locking thread id after we obtain the lock
+               so unlocks from other threads will fail.
              */
-            const int result = pthread_mutex_trylock(&mutex->id);
-            if (result == 0) {
+            const int rc = pthread_mutex_trylock(&mutex->id);
+            if (rc == 0) {
                 mutex->owner = this_thread;
                 mutex->recursive = 0;
-            } else if (result == EBUSY) {
-                retval = SDL_MUTEX_TIMEDOUT;
+            } else if (rc == EBUSY) {
+                result = false;
             } else {
                 SDL_assert(!"Error trying to lock mutex");  // assume we're in a lot of trouble if this assert fails.
-                retval = SDL_MUTEX_TIMEDOUT;
+                result = false;
             }
         }
 #else
-        const int result = pthread_mutex_trylock(&mutex->id);
-        if (result != 0) {
-            if (result == EBUSY) {
-                retval = SDL_MUTEX_TIMEDOUT;
+        const int rc = pthread_mutex_trylock(&mutex->id);
+        if (rc != 0) {
+            if (rc == EBUSY) {
+                result = false;
             } else {
                 SDL_assert(!"Error trying to lock mutex");  // assume we're in a lot of trouble if this assert fails.
-                retval = SDL_MUTEX_TIMEDOUT;
+                result = false;
             }
         }
 #endif
     }
 
-    return retval;
+    return result;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
 #ifdef FAKE_RECURSIVE_MUTEX
         // We can only unlock the mutex if we own it
         if (pthread_self() == mutex->owner) {

src/thread/pthread/SDL_sysrwlock.c

@@ -69,38 +69,38 @@ void SDL_LockRWLockForWriting(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS
     }
 }
 
-int SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
+SDL_bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
 {
-    int retval = 0;
+    bool result = true;
 
     if (rwlock) {
-        const int result = pthread_rwlock_tryrdlock(&rwlock->id);
-        if (result != 0) {
-            retval = SDL_RWLOCK_TIMEDOUT;
-            if (result != EBUSY) {
+        const int rc = pthread_rwlock_tryrdlock(&rwlock->id);
+        if (rc != 0) {
+            result = false;
+            if (rc != EBUSY) {
                 SDL_assert(!"Error trying to lock rwlock for reading");  // assume we're in a lot of trouble if this assert fails.
             }
         }
     }
 
-    return retval;
+    return result;
 }
 
-int SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
+SDL_bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
 {
-    int retval = 0;
+    bool result = true;
 
     if (rwlock) {
-        const int result = pthread_rwlock_trywrlock(&rwlock->id);
-        if (result != 0) {
-            retval = SDL_RWLOCK_TIMEDOUT;
-            if (result != EBUSY) {
+        const int rc = pthread_rwlock_trywrlock(&rwlock->id);
+        if (rc != 0) {
+            result = false;
+            if (rc != EBUSY) {
                 SDL_assert(!"Error trying to lock rwlock for writing");  // assume we're in a lot of trouble if this assert fails.
             }
         }
     }
 
-    return retval;
+    return result;
 }
 
 void SDL_UnlockRWLock(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes

src/thread/pthread/SDL_syssem.c

@@ -60,39 +60,33 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     }
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
-    int retval = 0;
 #ifdef HAVE_SEM_TIMEDWAIT
 #ifndef HAVE_CLOCK_GETTIME
     struct timeval now;
 #endif
     struct timespec ts_timeout;
 #else
-    Uint64 end;
+    Uint64 stop_time;
 #endif
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     // Try the easy cases first
     if (timeoutNS == 0) {
-        retval = SDL_MUTEX_TIMEDOUT;
-        if (sem_trywait(&sem->sem) == 0) {
-            retval = 0;
-        }
-        return retval;
+        return (sem_trywait(&sem->sem) == 0);
     }
-    if (timeoutNS < 0) {
-        do {
-            retval = sem_wait(&sem->sem);
-        } while (retval < 0 && errno == EINTR);
 
-        if (retval < 0) {
-            retval = SDL_SetError("sem_wait() failed");
-        }
-        return retval;
+    if (timeoutNS < 0) {
+        int rc;
+        do {
+            rc = sem_wait(&sem->sem);
+        } while (rc < 0 && errno == EINTR);
+
+        return (rc == 0);
     }
 
 #ifdef HAVE_SEM_TIMEDWAIT
@@ -121,29 +115,22 @@ int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
     }
 
     // Wait.
+    int rc;
     do {
-        retval = sem_timedwait(&sem->sem, &ts_timeout);
-    } while (retval < 0 && errno == EINTR);
+        rc = sem_timedwait(&sem->sem, &ts_timeout);
+    } while (rc < 0 && errno == EINTR);
 
-    if (retval < 0) {
-        if (errno == ETIMEDOUT) {
-            retval = SDL_MUTEX_TIMEDOUT;
-        } else {
-            SDL_SetError("sem_timedwait returned an error: %s", strerror(errno));
-        }
-    }
+    return (rc == 0);
 #else
-    end = SDL_GetTicksNS() + timeoutNS;
+    stop_time = SDL_GetTicksNS() + timeoutNS;
     while (sem_trywait(&sem->sem) != 0) {
-        if (SDL_GetTicksNS() >= end) {
-            retval = SDL_MUTEX_TIMEDOUT;
-            break;
+        if (SDL_GetTicksNS() >= stop_time) {
+            return false;
         }
         SDL_DelayNS(100);
     }
+    return true;
 #endif // HAVE_SEM_TIMEDWAIT
-
-    return retval;
 }
 
 Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
@@ -151,7 +138,6 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     int ret = 0;
 
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
 
@@ -162,19 +148,13 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     return (Uint32)ret;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    int retval;
-
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
-    retval = sem_post(&sem->sem);
-    if (retval < 0) {
-        SDL_SetError("sem_post() failed");
-    }
-    return retval;
+    sem_post(&sem->sem);
 }
 
 #endif // SDL_PLATFORM_MACOS

src/thread/pthread/SDL_systhread.c

@@ -77,9 +77,9 @@ static int (*ppthread_setname_np)(const char *) = NULL;
 static bool checked_setname = false;
 static int (*ppthread_setname_np)(pthread_t, const char *) = NULL;
 #endif
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 {
     pthread_attr_t type;
 
@@ -112,7 +112,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
         return SDL_SetError("Not enough resources to create thread");
     }
 
-    return 0;
+    return true;
 }
 
 void SDL_SYS_SetupThread(const char *name)
@@ -175,11 +175,11 @@ SDL_ThreadID SDL_GetCurrentThreadID(void)
     return (SDL_ThreadID)pthread_self();
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
 #ifdef SDL_PLATFORM_RISCOS
     // FIXME: Setting thread priority does not seem to be supported
-    return 0;
+    return true;
 #else
     struct sched_param sched;
     int policy;
@@ -269,7 +269,7 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
     if (pthread_setschedparam(thread, policy, &sched) != 0) {
         return SDL_SetError("pthread_setschedparam() failed");
     }
-    return 0;
+    return true;
 #endif // linux
 #endif // #if SDL_PLATFORM_RISCOS
 }

src/thread/pthread/SDL_systls.c

@@ -52,7 +52,7 @@ SDL_TLSData *SDL_SYS_GetTLSData(void)
     return NULL;
 }
 
-int SDL_SYS_SetTLSData(SDL_TLSData *data)
+bool SDL_SYS_SetTLSData(SDL_TLSData *data)
 {
     if (generic_local_storage) {
         return SDL_Generic_SetTLSData(data);
@@ -61,7 +61,7 @@ int SDL_SYS_SetTLSData(SDL_TLSData *data)
     if (pthread_setspecific(thread_local_storage, data) != 0) {
         return SDL_SetError("pthread_setspecific() failed");
     }
-    return 0;
+    return true;
 }
 
 void SDL_SYS_QuitTLSData(void)

src/thread/stdcpp/SDL_syscond.cpp

@@ -36,8 +36,8 @@ struct SDL_Condition
 };
 
 // Create a condition variable
-extern "C" SDL_Condition *
-SDL_CreateCondition(void)
+extern "C"
+SDL_Condition *SDL_CreateCondition(void)
 {
     // Allocate and initialize the condition variable
     try {
@@ -53,8 +53,8 @@ SDL_CreateCondition(void)
 }
 
 // Destroy a condition variable
-extern "C" void
-SDL_DestroyCondition(SDL_Condition *cond)
+extern "C"
+void SDL_DestroyCondition(SDL_Condition *cond)
 {
     if (cond) {
         delete cond;
@@ -62,80 +62,52 @@ SDL_DestroyCondition(SDL_Condition *cond)
 }
 
 // Restart one of the threads that are waiting on the condition variable
-extern "C" int
-SDL_SignalCondition(SDL_Condition *cond)
+extern "C"
+void SDL_SignalCondition(SDL_Condition *cond)
 {
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
     cond->cpp_cond.notify_one();
-    return 0;
 }
 
 // Restart all threads that are waiting on the condition variable
-extern "C" int
-SDL_BroadcastCondition(SDL_Condition *cond)
+extern "C"
+void SDL_BroadcastCondition(SDL_Condition *cond)
 {
     if (!cond) {
-        return SDL_InvalidParamError("cond");
+        return;
     }
 
     cond->cpp_cond.notify_all();
-    return 0;
 }
 
-/* Wait on the condition variable for at most 'timeoutNS' nanoseconds.
-   The mutex must be locked before entering this function!
-   The mutex is unlocked during the wait, and locked again after the wait.
-
-Typical use:
-
-Thread A:
-    SDL_LockMutex(lock);
-    while ( ! condition ) {
-        SDL_WaitCondition(cond, lock);
-    }
-    SDL_UnlockMutex(lock);
-
-Thread B:
-    SDL_LockMutex(lock);
-    ...
-    condition = true;
-    ...
-    SDL_SignalCondition(cond);
-    SDL_UnlockMutex(lock);
- */
-extern "C" int
-SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+extern "C"
+SDL_bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
 {
-    if (cond == NULL) {
-        return SDL_InvalidParamError("cond");
-    }
-
-    if (mutex == NULL) {
-        return SDL_InvalidParamError("mutex");
+    if (!cond || !mutex) {
+        return true;
     }
 
     try {
         std::unique_lock<std::recursive_mutex> cpp_lock(mutex->cpp_mutex, std::adopt_lock_t());
         if (timeoutNS < 0) {
-            cond->cpp_cond.wait(
-                cpp_lock);
+            cond->cpp_cond.wait(cpp_lock);
             cpp_lock.release();
-            return 0;
+            return true;
         } else {
             auto wait_result = cond->cpp_cond.wait_for(
                 cpp_lock,
                 std::chrono::duration<Sint64, std::nano>(timeoutNS));
             cpp_lock.release();
             if (wait_result == std::cv_status::timeout) {
-                return SDL_MUTEX_TIMEDOUT;
+                return false;
             } else {
-                return 0;
+                return true;
             }
         }
-    } catch (std::system_error &ex) {
-        return SDL_SetError("Unable to wait on a C++ condition variable: code=%d; %s", ex.code(), ex.what());
+    } catch (std::system_error &) {
+        return false;
     }
 }

src/thread/stdcpp/SDL_sysmutex.cpp

@@ -29,7 +29,8 @@ extern "C" {
 #include "SDL_sysmutex_c.h"
 #include <windows.h>
 
-extern "C" SDL_Mutex * SDL_CreateMutex(void)
+extern "C"
+SDL_Mutex * SDL_CreateMutex(void)
 {
     // Allocate and initialize the mutex
     try {
@@ -43,34 +44,41 @@ extern "C" SDL_Mutex * SDL_CreateMutex(void)
     return NULL;
 }
 
-extern "C" void SDL_DestroyMutex(SDL_Mutex *mutex)
+extern "C"
+void SDL_DestroyMutex(SDL_Mutex *mutex)
 {
     if (mutex) {
         delete mutex;
     }
 }
 
-extern "C" void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+extern "C"
+void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         try {
             mutex->cpp_mutex.lock();
         } catch (std::system_error &/*ex*/) {
             SDL_assert(!"Error trying to lock mutex");  // assume we're in a lot of trouble if this assert fails.
-            //return SDL_SetError("unable to lock a C++ mutex: code=%d; %s", ex.code(), ex.what());
         }
     }
 }
 
-extern "C" int SDL_TryLockMutex(SDL_Mutex *mutex)
+extern "C"
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    return ((!mutex) || mutex->cpp_mutex.try_lock()) ? 0 : SDL_MUTEX_TIMEDOUT;
+    bool result = true;
+    if (mutex) {
+        result = mutex->cpp_mutex.try_lock();
+    }
+    return result;
 }
 
 // Unlock the mutex
-extern "C" void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+extern "C"
+void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (mutex != NULL) {
+    if (mutex) {
         mutex->cpp_mutex.unlock();
     }
 }

src/thread/stdcpp/SDL_sysrwlock.cpp

@@ -30,7 +30,8 @@ struct SDL_RWLock
     SDL_ThreadID write_owner;
 };
 
-extern "C" SDL_RWLock *SDL_CreateRWLock(void)
+extern "C"
+SDL_RWLock *SDL_CreateRWLock(void)
 {
     try {
         SDL_RWLock *rwlock = new SDL_RWLock;
@@ -44,14 +45,16 @@ extern "C" SDL_RWLock *SDL_CreateRWLock(void)
     }
 }
 
-extern "C" void SDL_DestroyRWLock(SDL_RWLock *rwlock)
+extern "C"
+void SDL_DestroyRWLock(SDL_RWLock *rwlock)
 {
     if (rwlock) {
         delete rwlock;
     }
 }
 
-extern "C" void SDL_LockRWLockForReading(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+extern "C"
+void SDL_LockRWLockForReading(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
     if (rwlock) {
         try {
@@ -63,7 +66,8 @@ extern "C" void SDL_LockRWLockForReading(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFET
     }
 }
 
-extern "C" void SDL_LockRWLockForWriting(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
+extern "C"
+void SDL_LockRWLockForWriting(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes
 {
     if (rwlock) {
         try {
@@ -76,31 +80,31 @@ extern "C" void SDL_LockRWLockForWriting(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFET
     }
 }
 
-extern "C" int SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
+extern "C"
+SDL_bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
 {
-    int retval = 0;
+    bool result = true;
     if (rwlock) {
-        if (rwlock->cpp_mutex.try_lock_shared() == false) {
-            retval = SDL_RWLOCK_TIMEDOUT;
-        }
+        result = rwlock->cpp_mutex.try_lock_shared();
     }
-    return retval;
+    return result;
 }
 
-extern "C" int SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
+extern "C"
+SDL_bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
 {
-    int retval = 0;
+    bool result = true;
     if (rwlock) {
-        if (rwlock->cpp_mutex.try_lock() == false) {
-            retval = SDL_RWLOCK_TIMEDOUT;
-        } else {
+        result = rwlock->cpp_mutex.try_lock();
+        if (result) {
             rwlock->write_owner = SDL_GetCurrentThreadID();
         }
     }
-    return retval;
+    return result;
 }
 
-extern "C" void SDL_UnlockRWLock(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+extern "C"
+void SDL_UnlockRWLock(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
     if (rwlock) {
         if (rwlock->write_owner == SDL_GetCurrentThreadID()) {

src/thread/stdcpp/SDL_systhread.cpp

@@ -39,15 +39,15 @@ static void RunThread(void *args)
     SDL_RunThread((SDL_Thread *)args);
 }
 
-extern "C" int
-SDL_SYS_CreateThread(SDL_Thread *thread,
+extern "C"
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
                      SDL_FunctionPointer pfnBeginThread,
                      SDL_FunctionPointer pfnEndThread)
 {
     try {
         // !!! FIXME: no way to set a thread stack size here.
         thread->handle = (void *)new std::thread(RunThread, thread);
-        return 0;
+        return true;
     } catch (std::system_error &ex) {
         return SDL_SetError("unable to start a C++ thread: code=%d; %s", ex.code().value(), ex.what());
     } catch (std::bad_alloc &) {
@@ -55,14 +55,14 @@ SDL_SYS_CreateThread(SDL_Thread *thread,
     }
 }
 
-extern "C" void
-SDL_SYS_SetupThread(const char *name)
+extern "C"
+void SDL_SYS_SetupThread(const char *name)
 {
     // Do nothing.
 }
 
-extern "C" SDL_ThreadID
-SDL_GetCurrentThreadID(void)
+extern "C"
+SDL_ThreadID SDL_GetCurrentThreadID(void)
 {
     static_assert(sizeof(std::thread::id) <= sizeof(SDL_ThreadID), "std::thread::id must not be bigger than SDL_ThreadID");
     SDL_ThreadID thread_id{};
@@ -71,8 +71,8 @@ SDL_GetCurrentThreadID(void)
     return thread_id;
 }
 
-extern "C" int
-SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+extern "C"
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
 #ifdef SDL_PLATFORM_WINRT
     int value;
@@ -91,14 +91,14 @@ SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
     if (!SetThreadPriority(GetCurrentThread(), value)) {
         return WIN_SetError("SetThreadPriority()");
     }
-    return 0;
+    return true;
 #else
     return SDL_Unsupported();
 #endif
 }
 
-extern "C" void
-SDL_SYS_WaitThread(SDL_Thread *thread)
+extern "C"
+void SDL_SYS_WaitThread(SDL_Thread *thread)
 {
     if (!thread) {
         return;
@@ -120,8 +120,8 @@ SDL_SYS_WaitThread(SDL_Thread *thread)
     }
 }
 
-extern "C" void
-SDL_SYS_DetachThread(SDL_Thread *thread)
+extern "C"
+void SDL_SYS_DetachThread(SDL_Thread *thread)
 {
     if (!thread) {
         return;
@@ -157,10 +157,10 @@ SDL_TLSData * SDL_SYS_GetTLSData(void)
 }
 
 extern "C"
-int SDL_SYS_SetTLSData(SDL_TLSData *data)
+bool SDL_SYS_SetTLSData(SDL_TLSData *data)
 {
     thread_local_storage = data;
-    return 0;
+    return true;
 }
 
 extern "C"

src/thread/vita/SDL_sysmutex.c

@@ -62,45 +62,36 @@ void SDL_DestroyMutex(SDL_Mutex *mutex)
 
 void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-#ifndef SDL_THREADS_DISABLED
-    if (mutex != NULL) {
+    if (mutex) {
         const SceInt32 res = sceKernelLockLwMutex(&mutex->lock, 1, NULL);
         SDL_assert(res == SCE_KERNEL_OK);  // assume we're in a lot of trouble if this assert fails.
     }
-#endif // SDL_THREADS_DISABLED
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-#ifdef SDL_THREADS_DISABLED
-    return 0;
-#else
-    SceInt32 res = 0;
+    bool result = true;
 
-    if (!mutex) {
-        return 0;
+    if (mutex) {
+        const SceInt32 res = sceKernelTryLockLwMutex(&mutex->lock, 1);
+        if (res == SCE_KERNEL_OK) {
+            result = true;
+        } else if (res == SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN) {
+            result = false;
+        } else {
+            SDL_assert(res == SCE_KERNEL_OK); // assume we're in a lot of trouble if this assert fails.
+            result = false;
+        }
     }
-
-    res = sceKernelTryLockLwMutex(&mutex->lock, 1);
-    switch (res) {
-    case SCE_KERNEL_OK: return 0;
-    case SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN: return SDL_MUTEX_TIMEDOUT;
-    default: break;
-    }
-
-    SDL_assert(!"Error trying to lock mutex");  // assume we're in a lot of trouble if this assert fails.
-    return SDL_MUTEX_TIMEDOUT;
-#endif // SDL_THREADS_DISABLED
+    return result;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-#ifndef SDL_THREADS_DISABLED
-    if (mutex != NULL) {
+    if (mutex) {
         const SceInt32 res = sceKernelUnlockLwMutex(&mutex->lock, 1);
         SDL_assert(res == SCE_KERNEL_OK);  // assume we're in a lot of trouble if this assert fails.
     }
-#endif // SDL_THREADS_DISABLED
 }
 
 #endif // SDL_THREAD_VITA

src/thread/vita/SDL_syssem.c

@@ -72,40 +72,25 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
  * If the timeout is 0 then just poll the semaphore; if it's -1, pass
  * NULL to sceKernelWaitSema() so that it waits indefinitely; and if the timeout
  * is specified, convert it to microseconds. */
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
     SceUInt timeoutUS;
-    SceUInt *pTimeout;
-    int res;
+    SceUInt *pTimeout = NULL;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     if (timeoutNS == 0) {
-        res = sceKernelPollSema(sem->semid, 1);
-        if (res < 0) {
-            return SDL_MUTEX_TIMEDOUT;
-        }
-        return 0;
+        return (sceKernelPollSema(sem->semid, 1) == 0);
     }
 
-    if (timeoutNS < 0) {
-        pTimeout = NULL;
-    } else {
+    if (timeoutNS > 0) {
         timeoutUS = (SceUInt)SDL_NS_TO_US(timeoutNS); // Convert to microseconds.
         pTimeout = &timeoutUS;
     }
 
-    res = sceKernelWaitSema(sem->semid, 1, pTimeout);
-    switch (res) {
-    case SCE_KERNEL_OK:
-        return 0;
-    case SCE_KERNEL_ERROR_WAIT_TIMEOUT:
-        return SDL_MUTEX_TIMEDOUT;
-    default:
-        return SDL_SetError("sceKernelWaitSema() failed");
-    }
+    return (sceKernelWaitSema(sem->semid, 1, pTimeout) == 0);
 }
 
 // Returns the current count of the semaphore
@@ -115,7 +100,6 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     info.size = sizeof(info);
 
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
 
@@ -126,20 +110,13 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     return 0;
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    int res;
-
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
-    res = sceKernelSignalSema(sem->semid, 1);
-    if (res < 0) {
-        return SDL_SetError("sceKernelSignalSema() failed");
-    }
-
-    return 0;
+    sceKernelSignalSema(sem->semid, 1);
 }
 
 #endif // SDL_THREAD_VITA

src/thread/vita/SDL_systhread.c

@@ -48,9 +48,9 @@ static int ThreadEntry(SceSize args, void *argp)
     return 0;
 }
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer pfnBeginThread,
-                         SDL_FunctionPointer pfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
 
 {
     char thread_name[VITA_THREAD_NAME_MAX];
@@ -87,7 +87,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
     }
 
     sceKernelStartThread(thread->handle, 4, &thread);
-    return 0;
+    return true;
 }
 
 void SDL_SYS_SetupThread(const char *name)
@@ -111,7 +111,7 @@ void SDL_SYS_DetachThread(SDL_Thread *thread)
     // Do nothing.
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
     int value = VITA_THREAD_PRIORITY_NORMAL;
 
@@ -130,7 +130,10 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
         break;
     }
 
-    return sceKernelChangeThreadPriority(0, value);
+    if (sceKernelChangeThreadPriority(0, value) < 0) {
+        return SDL_SetError("sceKernelChangeThreadPriority() failed");
+    }
+    return true;
 }
 
 #endif // SDL_THREAD_VITA

src/thread/windows/SDL_syscond_cv.c

@@ -25,9 +25,9 @@
 
 typedef SDL_Condition *(*pfnSDL_CreateCondition)(void);
 typedef void (*pfnSDL_DestroyCondition)(SDL_Condition *);
-typedef int (*pfnSDL_SignalCondition)(SDL_Condition *);
-typedef int (*pfnSDL_BroadcastCondition)(SDL_Condition *);
-typedef int (*pfnSDL_WaitConditionTimeoutNS)(SDL_Condition *, SDL_Mutex *, Sint64);
+typedef void (*pfnSDL_SignalCondition)(SDL_Condition *);
+typedef void (*pfnSDL_BroadcastCondition)(SDL_Condition *);
+typedef bool (*pfnSDL_WaitConditionTimeoutNS)(SDL_Condition *, SDL_Mutex *, Sint64);
 
 typedef struct SDL_cond_impl_t
 {
@@ -90,42 +90,23 @@ static void SDL_DestroyCondition_cv(SDL_Condition *cond)
     SDL_free(cond);
 }
 
-static int SDL_SignalCondition_cv(SDL_Condition *_cond)
+static void SDL_SignalCondition_cv(SDL_Condition *_cond)
 {
     SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
-    }
-
     pWakeConditionVariable(&cond->cond);
-
-    return 0;
 }
 
-static int SDL_BroadcastCondition_cv(SDL_Condition *_cond)
+static void SDL_BroadcastCondition_cv(SDL_Condition *_cond)
 {
     SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
-    }
-
     pWakeAllConditionVariable(&cond->cond);
-
-    return 0;
 }
 
-static int SDL_WaitConditionTimeoutNS_cv(SDL_Condition *_cond, SDL_Mutex *_mutex, Sint64 timeoutNS)
+static bool SDL_WaitConditionTimeoutNS_cv(SDL_Condition *_cond, SDL_Mutex *_mutex, Sint64 timeoutNS)
 {
     SDL_cond_cv *cond = (SDL_cond_cv *)_cond;
     DWORD timeout;
-    int ret;
-
-    if (!cond) {
-        return SDL_InvalidParamError("cond");
-    }
-    if (!_mutex) {
-        return SDL_InvalidParamError("mutex");
-    }
+    bool result;
 
     if (timeoutNS < 0) {
         timeout = INFINITE;
@@ -137,22 +118,15 @@ static int SDL_WaitConditionTimeoutNS_cv(SDL_Condition *_cond, SDL_Mutex *_mutex
         SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
 
         if (mutex->count != 1 || mutex->owner != GetCurrentThreadId()) {
-            return SDL_SetError("Passed mutex is not locked or locked recursively");
+            // Passed mutex is not locked or locked recursively"
+            return false;
         }
 
         // The mutex must be updated to the released state
         mutex->count = 0;
         mutex->owner = 0;
 
-        if (pSleepConditionVariableSRW(&cond->cond, &mutex->srw, timeout, 0) == FALSE) {
-            if (GetLastError() == ERROR_TIMEOUT) {
-                ret = SDL_MUTEX_TIMEDOUT;
-            } else {
-                ret = SDL_SetError("SleepConditionVariableSRW() failed");
-            }
-        } else {
-            ret = 0;
-        }
+        result = pSleepConditionVariableSRW(&cond->cond, &mutex->srw, timeout, 0);
 
         // The mutex is owned by us again, regardless of status of the wait
         SDL_assert(mutex->count == 0 && mutex->owner == 0);
@@ -163,18 +137,10 @@ static int SDL_WaitConditionTimeoutNS_cv(SDL_Condition *_cond, SDL_Mutex *_mutex
 
         SDL_assert(SDL_mutex_impl_active.Type == SDL_MUTEX_CS);
 
-        if (pSleepConditionVariableCS(&cond->cond, &mutex->cs, timeout) == FALSE) {
-            if (GetLastError() == ERROR_TIMEOUT) {
-                ret = SDL_MUTEX_TIMEDOUT;
-            } else {
-                ret = SDL_SetError("SleepConditionVariableCS() failed");
-            }
-        } else {
-            ret = 0;
-        }
+        result = pSleepConditionVariableCS(&cond->cond, &mutex->cs, timeout);
     }
 
-    return ret;
+    return result;
 }
 
 static const SDL_cond_impl_t SDL_cond_impl_cv = {
@@ -241,20 +207,34 @@ SDL_Condition *SDL_CreateCondition(void)
 
 void SDL_DestroyCondition(SDL_Condition *cond)
 {
-    SDL_cond_impl_active.Destroy(cond);
+    if (cond) {
+        SDL_cond_impl_active.Destroy(cond);
+    }
 }
 
-int SDL_SignalCondition(SDL_Condition *cond)
+void SDL_SignalCondition(SDL_Condition *cond)
 {
-    return SDL_cond_impl_active.Signal(cond);
+    if (!cond) {
+        return;
+    }
+
+    SDL_cond_impl_active.Signal(cond);
 }
 
-int SDL_BroadcastCondition(SDL_Condition *cond)
+void SDL_BroadcastCondition(SDL_Condition *cond)
 {
-    return SDL_cond_impl_active.Broadcast(cond);
+    if (!cond) {
+        return;
+    }
+
+    SDL_cond_impl_active.Broadcast(cond);
 }
 
-int SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+SDL_bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
 {
+    if (!cond || !mutex) {
+        return true;
+    }
+
     return SDL_cond_impl_active.WaitTimeoutNS(cond, mutex, timeoutNS);
 }

src/thread/windows/SDL_sysmutex.c

@@ -90,11 +90,11 @@ static void SDL_LockMutex_srw(SDL_Mutex *_mutex) SDL_NO_THREAD_SAFETY_ANALYSIS
     }
 }
 
-static int SDL_TryLockMutex_srw(SDL_Mutex *_mutex)
+static bool SDL_TryLockMutex_srw(SDL_Mutex *_mutex)
 {
     SDL_mutex_srw *mutex = (SDL_mutex_srw *)_mutex;
     const DWORD this_thread = GetCurrentThreadId();
-    int retval = 0;
+    bool retval = true;
 
     if (mutex->owner == this_thread) {
         ++mutex->count;
@@ -104,7 +104,7 @@ static int SDL_TryLockMutex_srw(SDL_Mutex *_mutex)
             mutex->owner = this_thread;
             mutex->count = 1;
         } else {
-            retval = SDL_MUTEX_TIMEDOUT;
+            retval = false;
         }
     }
     return retval;
@@ -166,10 +166,10 @@ static void SDL_LockMutex_cs(SDL_Mutex *mutex_) SDL_NO_THREAD_SAFETY_ANALYSIS  /
     EnterCriticalSection(&mutex->cs);
 }
 
-static int SDL_TryLockMutex_cs(SDL_Mutex *mutex_)
+static bool SDL_TryLockMutex_cs(SDL_Mutex *mutex_)
 {
     SDL_mutex_cs *mutex = (SDL_mutex_cs *)mutex_;
-    return (TryEnterCriticalSection(&mutex->cs) == 0) ? SDL_MUTEX_TIMEDOUT : 0;
+    return TryEnterCriticalSection(&mutex->cs);
 }
 
 static void SDL_UnlockMutex_cs(SDL_Mutex *mutex_) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
@@ -234,9 +234,14 @@ void SDL_LockMutex(SDL_Mutex *mutex)
     }
 }
 
-int SDL_TryLockMutex(SDL_Mutex *mutex)
+SDL_bool SDL_TryLockMutex(SDL_Mutex *mutex)
 {
-    return mutex ? SDL_mutex_impl_active.TryLock(mutex) : 0;
+    bool result = true;
+
+    if (mutex) {
+        result = SDL_mutex_impl_active.TryLock(mutex);
+    }
+    return result;
 }
 
 void SDL_UnlockMutex(SDL_Mutex *mutex)

src/thread/windows/SDL_sysmutex_c.h

@@ -24,7 +24,7 @@
 
 typedef SDL_Mutex *(*pfnSDL_CreateMutex)(void);
 typedef void (*pfnSDL_LockMutex)(SDL_Mutex *);
-typedef int (*pfnSDL_TryLockMutex)(SDL_Mutex *);
+typedef bool (*pfnSDL_TryLockMutex)(SDL_Mutex *);
 typedef void (*pfnSDL_UnlockMutex)(SDL_Mutex *);
 typedef void (*pfnSDL_DestroyMutex)(SDL_Mutex *);
 

src/thread/windows/SDL_sysrwlock_srw.c

@@ -59,8 +59,8 @@ typedef SDL_RWLock *(*pfnSDL_CreateRWLock)(void);
 typedef void (*pfnSDL_DestroyRWLock)(SDL_RWLock *);
 typedef void (*pfnSDL_LockRWLockForReading)(SDL_RWLock *);
 typedef void (*pfnSDL_LockRWLockForWriting)(SDL_RWLock *);
-typedef int (*pfnSDL_TryLockRWLockForReading)(SDL_RWLock *);
-typedef int (*pfnSDL_TryLockRWLockForWriting)(SDL_RWLock *);
+typedef bool (*pfnSDL_TryLockRWLockForReading)(SDL_RWLock *);
+typedef bool (*pfnSDL_TryLockRWLockForWriting)(SDL_RWLock *);
 typedef void (*pfnSDL_UnlockRWLock)(SDL_RWLock *);
 
 typedef struct SDL_rwlock_impl_t
@@ -97,59 +97,48 @@ static SDL_RWLock *SDL_CreateRWLock_srw(void)
 static void SDL_DestroyRWLock_srw(SDL_RWLock *_rwlock)
 {
     SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    if (rwlock) {
-        // There are no kernel allocated resources
-        SDL_free(rwlock);
-    }
+    // There are no kernel allocated resources
+    SDL_free(rwlock);
 }
 
 static void SDL_LockRWLockForReading_srw(SDL_RWLock *_rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
     SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    if (rwlock != NULL) {
-        pAcquireSRWLockShared(&rwlock->srw);
-    }
+    pAcquireSRWLockShared(&rwlock->srw);
 }
 
 static void SDL_LockRWLockForWriting_srw(SDL_RWLock *_rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
     SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    if (rwlock != NULL) {
-        pAcquireSRWLockExclusive(&rwlock->srw);
+    pAcquireSRWLockExclusive(&rwlock->srw);
+    rwlock->write_owner = SDL_GetCurrentThreadID();
+}
+
+static bool SDL_TryLockRWLockForReading_srw(SDL_RWLock *_rwlock)
+{
+    SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
+    return pTryAcquireSRWLockShared(&rwlock->srw);
+}
+
+static bool SDL_TryLockRWLockForWriting_srw(SDL_RWLock *_rwlock)
+{
+    SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
+    if (pTryAcquireSRWLockExclusive(&rwlock->srw)) {
         rwlock->write_owner = SDL_GetCurrentThreadID();
+        return true;
+    } else {
+        return false;
     }
 }
 
-static int SDL_TryLockRWLockForReading_srw(SDL_RWLock *_rwlock)
-{
-    SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    int retval = 0;
-    if (rwlock) {
-        retval = pTryAcquireSRWLockShared(&rwlock->srw) ? 0 : SDL_RWLOCK_TIMEDOUT;
-    }
-    return retval;
-}
-
-static int SDL_TryLockRWLockForWriting_srw(SDL_RWLock *_rwlock)
-{
-    SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    int retval = 0;
-    if (rwlock) {
-        retval = pTryAcquireSRWLockExclusive(&rwlock->srw) ? 0 : SDL_RWLOCK_TIMEDOUT;
-    }
-    return retval;
-}
-
 static void SDL_UnlockRWLock_srw(SDL_RWLock *_rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
     SDL_rwlock_srw *rwlock = (SDL_rwlock_srw *) _rwlock;
-    if (rwlock != NULL) {
-        if (rwlock->write_owner == SDL_GetCurrentThreadID()) {
-            rwlock->write_owner = 0;
-            pReleaseSRWLockExclusive(&rwlock->srw);
-        } else {
-            pReleaseSRWLockShared(&rwlock->srw);
-        }
+    if (rwlock->write_owner == SDL_GetCurrentThreadID()) {
+        rwlock->write_owner = 0;
+        pReleaseSRWLockExclusive(&rwlock->srw);
+    } else {
+        pReleaseSRWLockShared(&rwlock->srw);
     }
 }
 
@@ -224,31 +213,39 @@ void SDL_DestroyRWLock(SDL_RWLock *rwlock)
 
 void SDL_LockRWLockForReading(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (rwlock != NULL) {
+    if (rwlock) {
         SDL_rwlock_impl_active.LockForReading(rwlock);
     }
 }
 
 void SDL_LockRWLockForWriting(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (rwlock != NULL) {
+    if (rwlock) {
         SDL_rwlock_impl_active.LockForWriting(rwlock);
     }
 }
 
-int SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
+SDL_bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
 {
-    return rwlock ? SDL_rwlock_impl_active.TryLockForReading(rwlock) : 0;
+    bool result = true;
+    if (rwlock) {
+        result = SDL_rwlock_impl_active.TryLockForReading(rwlock);
+    }
+    return result;
 }
 
-int SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
+SDL_bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
 {
-    return rwlock ? SDL_rwlock_impl_active.TryLockForWriting(rwlock) : 0;
+    bool result = true;
+    if (rwlock) {
+        result = SDL_rwlock_impl_active.TryLockForWriting(rwlock);
+    }
+    return result;
 }
 
 void SDL_UnlockRWLock(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
 {
-    if (rwlock != NULL) {
+    if (rwlock) {
         SDL_rwlock_impl_active.Unlock(rwlock);
     }
 }

src/thread/windows/SDL_syssem.c

@@ -37,9 +37,9 @@
 
 typedef SDL_Semaphore *(*pfnSDL_CreateSemaphore)(Uint32);
 typedef void (*pfnSDL_DestroySemaphore)(SDL_Semaphore *);
-typedef int (*pfnSDL_WaitSemaphoreTimeoutNS)(SDL_Semaphore *, Sint64);
+typedef bool (*pfnSDL_WaitSemaphoreTimeoutNS)(SDL_Semaphore *, Sint64);
 typedef Uint32 (*pfnSDL_GetSemaphoreValue)(SDL_Semaphore *);
-typedef int (*pfnSDL_SignalSemaphore)(SDL_Semaphore *);
+typedef void (*pfnSDL_SignalSemaphore)(SDL_Semaphore *);
 
 typedef struct SDL_semaphore_impl_t
 {
@@ -47,7 +47,7 @@ typedef struct SDL_semaphore_impl_t
     pfnSDL_DestroySemaphore Destroy;
     pfnSDL_WaitSemaphoreTimeoutNS WaitTimeoutNS;
     pfnSDL_GetSemaphoreValue Value;
-    pfnSDL_SignalSemaphore Post;
+    pfnSDL_SignalSemaphore Signal;
 } SDL_sem_impl_t;
 
 // Implementation will be chosen at runtime based on available Kernel features
@@ -94,7 +94,7 @@ static void SDL_DestroySemaphore_atom(SDL_Semaphore *sem)
     SDL_free(sem);
 }
 
-static int SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS)
+static bool SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS)
 {
     SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
     LONG count;
@@ -103,33 +103,34 @@ static int SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS
     DWORD timeout_eff;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return true;
     }
 
     if (timeoutNS == 0) {
         count = sem->count;
         if (count == 0) {
-            return SDL_MUTEX_TIMEDOUT;
+            return false;
         }
 
         if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
-            return 0;
+            return true;
         }
 
-        return SDL_MUTEX_TIMEDOUT;
+        return false;
     }
+
     if (timeoutNS < 0) {
         for (;;) {
             count = sem->count;
             while (count == 0) {
-                if (pWaitOnAddress(&sem->count, &count, sizeof(sem->count), INFINITE) == FALSE) {
-                    return SDL_SetError("WaitOnAddress() failed");
+                if (!pWaitOnAddress(&sem->count, &count, sizeof(sem->count), INFINITE)) {
+                    return false;
                 }
                 count = sem->count;
             }
 
             if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
-                return 0;
+                return true;
             }
         }
     }
@@ -149,13 +150,10 @@ static int SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS
             if (deadline > now) {
                 timeout_eff = (DWORD)SDL_NS_TO_MS(deadline - now);
             } else {
-                return SDL_MUTEX_TIMEDOUT;
+                return false;
             }
-            if (pWaitOnAddress(&sem->count, &count, sizeof(count), timeout_eff) == FALSE) {
-                if (GetLastError() == ERROR_TIMEOUT) {
-                    return SDL_MUTEX_TIMEDOUT;
-                }
-                return SDL_SetError("WaitOnAddress() failed");
+            if (!pWaitOnAddress(&sem->count, &count, sizeof(count), timeout_eff)) {
+                return false;
             }
             count = sem->count;
         }
@@ -163,7 +161,7 @@ static int SDL_WaitSemaphoreTimeoutNS_atom(SDL_Semaphore *_sem, Sint64 timeoutNS
         // Actually the semaphore is only consumed if this succeeds
         // If it doesn't we need to do everything again
         if (InterlockedCompareExchange(&sem->count, count - 1, count) == count) {
-            return 0;
+            return true;
         }
     }
 }
@@ -173,25 +171,22 @@ static Uint32 SDL_GetSemaphoreValue_atom(SDL_Semaphore *_sem)
     SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
 
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
 
     return (Uint32)sem->count;
 }
 
-static int SDL_SignalSemaphore_atom(SDL_Semaphore *_sem)
+static void SDL_SignalSemaphore_atom(SDL_Semaphore *_sem)
 {
     SDL_sem_atom *sem = (SDL_sem_atom *)_sem;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
 
     InterlockedIncrement(&sem->count);
     pWakeByAddressSingle(&sem->count);
-
-    return 0;
 }
 
 static const SDL_sem_impl_t SDL_sem_impl_atom = {
@@ -251,14 +246,13 @@ static void SDL_DestroySemaphore_kern(SDL_Semaphore *_sem)
     }
 }
 
-static int SDL_WaitSemaphoreTimeoutNS_kern(SDL_Semaphore *_sem, Sint64 timeoutNS)
+static bool SDL_WaitSemaphoreTimeoutNS_kern(SDL_Semaphore *_sem, Sint64 timeoutNS)
 {
     SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
-    int retval;
     DWORD dwMilliseconds;
 
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return SDL_TRUE;
     }
 
     if (timeoutNS < 0) {
@@ -269,16 +263,10 @@ static int SDL_WaitSemaphoreTimeoutNS_kern(SDL_Semaphore *_sem, Sint64 timeoutNS
     switch (WaitForSingleObjectEx(sem->id, dwMilliseconds, FALSE)) {
     case WAIT_OBJECT_0:
         InterlockedDecrement(&sem->count);
-        retval = 0;
-        break;
-    case WAIT_TIMEOUT:
-        retval = SDL_MUTEX_TIMEDOUT;
-        break;
+        return true;
     default:
-        retval = SDL_SetError("WaitForSingleObject() failed");
-        break;
+        return false;
     }
-    return retval;
 }
 
 // Returns the current count of the semaphore
@@ -286,18 +274,19 @@ static Uint32 SDL_GetSemaphoreValue_kern(SDL_Semaphore *_sem)
 {
     SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
     if (!sem) {
-        SDL_InvalidParamError("sem");
         return 0;
     }
     return (Uint32)sem->count;
 }
 
-static int SDL_SignalSemaphore_kern(SDL_Semaphore *_sem)
+static void SDL_SignalSemaphore_kern(SDL_Semaphore *_sem)
 {
     SDL_sem_kern *sem = (SDL_sem_kern *)_sem;
+
     if (!sem) {
-        return SDL_InvalidParamError("sem");
+        return;
     }
+
     /* Increase the counter in the first place, because
      * after a successful release the semaphore may
      * immediately get destroyed by another thread which
@@ -306,9 +295,7 @@ static int SDL_SignalSemaphore_kern(SDL_Semaphore *_sem)
     InterlockedIncrement(&sem->count);
     if (ReleaseSemaphore(sem->id, 1, NULL) == FALSE) {
         InterlockedDecrement(&sem->count); // restore
-        return SDL_SetError("ReleaseSemaphore() failed");
     }
-    return 0;
 }
 
 static const SDL_sem_impl_t SDL_sem_impl_kern = {
@@ -366,7 +353,7 @@ void SDL_DestroySemaphore(SDL_Semaphore *sem)
     SDL_sem_impl_active.Destroy(sem);
 }
 
-int SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
 {
     return SDL_sem_impl_active.WaitTimeoutNS(sem, timeoutNS);
 }
@@ -376,9 +363,9 @@ Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
     return SDL_sem_impl_active.Value(sem);
 }
 
-int SDL_SignalSemaphore(SDL_Semaphore *sem)
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
 {
-    return SDL_sem_impl_active.Post(sem);
+    SDL_sem_impl_active.Signal(sem);
 }
 
 #endif // SDL_THREAD_WINDOWS

src/thread/windows/SDL_systhread.c

@@ -58,9 +58,9 @@ static unsigned __stdcall MINGW32_FORCEALIGN RunThreadViaBeginThreadEx(void *dat
     return (unsigned)RunThread(data);
 }
 
-int SDL_SYS_CreateThread(SDL_Thread *thread,
-                         SDL_FunctionPointer vpfnBeginThread,
-                         SDL_FunctionPointer vpfnEndThread)
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer vpfnBeginThread,
+                          SDL_FunctionPointer vpfnEndThread)
 {
     SDL_BeginThreadExCallback pfnBeginThread = (SDL_BeginThreadExCallback) vpfnBeginThread;
 
@@ -84,7 +84,7 @@ int SDL_SYS_CreateThread(SDL_Thread *thread,
     if (!thread->handle) {
         return SDL_SetError("Not enough resources to create thread");
     }
-    return 0;
+    return true;
 }
 
 #pragma pack(push, 8)
@@ -161,7 +161,7 @@ SDL_ThreadID SDL_GetCurrentThreadID(void)
     return (SDL_ThreadID)GetCurrentThreadId();
 }
 
-int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
 {
     int value;
 
@@ -177,7 +177,7 @@ int SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
     if (!SetThreadPriority(GetCurrentThread(), value)) {
         return WIN_SetError("SetThreadPriority()");
     }
-    return 0;
+    return true;
 }
 
 void SDL_SYS_WaitThread(SDL_Thread *thread)

src/thread/windows/SDL_systls.c

@@ -65,7 +65,7 @@ SDL_TLSData *SDL_SYS_GetTLSData(void)
     return NULL;
 }
 
-int SDL_SYS_SetTLSData(SDL_TLSData *data)
+bool SDL_SYS_SetTLSData(SDL_TLSData *data)
 {
     if (generic_local_storage) {
         return SDL_Generic_SetTLSData(data);
@@ -74,7 +74,7 @@ int SDL_SYS_SetTLSData(SDL_TLSData *data)
     if (!TlsSetValue(thread_local_storage, data)) {
         return WIN_SetError("TlsSetValue()");
     }
-    return 0;
+    return true;
 }
 
 void SDL_SYS_QuitTLSData(void)