From a10ba5bcb9f7df8ff9caea246f9c813bc231fb15 Mon Sep 17 00:00:00 2001 From: David Ludwig Date: Thu, 22 Nov 2012 23:03:56 -0500 Subject: [PATCH] WinRT: added a skeleton SDL backend for C++11-based threads --- VisualC/SDL/SDL_VS2012_WinRT.vcxproj | 10 +- .../tests/testthread/WinRT/Assets/Logo.png | Bin 0 -> 801 bytes .../testthread/WinRT/Assets/SmallLogo.png | Bin 0 -> 329 bytes .../testthread/WinRT/Assets/SplashScreen.png | Bin 0 -> 2146 bytes .../testthread/WinRT/Assets/StoreLogo.png | Bin 0 -> 429 bytes .../testthread/WinRT/Package.appxmanifest | 42 ++++ .../WinRT/testthread_VS2012_WinRT.vcxproj | 159 +++++++++++++ .../testthread_VS2012_WinRT_TemporaryKey.pfx | Bin 0 -> 2504 bytes include/SDL_config_windowsrt.h | 4 +- src/thread/SDL_thread_c.h | 2 + src/thread/stdcpp/SDL_syscond.c | 223 ++++++++++++++++++ src/thread/stdcpp/SDL_sysmutex.c | 135 +++++++++++ src/thread/stdcpp/SDL_sysmutex_c.h | 22 ++ src/thread/stdcpp/SDL_systhread.c | 59 +++++ src/thread/stdcpp/SDL_systhread_c.h | 26 ++ 15 files changed, 675 insertions(+), 7 deletions(-) create mode 100644 VisualC/tests/testthread/WinRT/Assets/Logo.png create mode 100644 VisualC/tests/testthread/WinRT/Assets/SmallLogo.png create mode 100644 VisualC/tests/testthread/WinRT/Assets/SplashScreen.png create mode 100644 VisualC/tests/testthread/WinRT/Assets/StoreLogo.png create mode 100644 VisualC/tests/testthread/WinRT/Package.appxmanifest create mode 100644 VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT.vcxproj create mode 100644 VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT_TemporaryKey.pfx create mode 100644 src/thread/stdcpp/SDL_syscond.c create mode 100644 src/thread/stdcpp/SDL_sysmutex.c create mode 100644 src/thread/stdcpp/SDL_sysmutex_c.h create mode 100644 src/thread/stdcpp/SDL_systhread.c create mode 100644 src/thread/stdcpp/SDL_systhread_c.h diff --git a/VisualC/SDL/SDL_VS2012_WinRT.vcxproj b/VisualC/SDL/SDL_VS2012_WinRT.vcxproj index 73d04e207..3bb971a7b 100644 --- a/VisualC/SDL/SDL_VS2012_WinRT.vcxproj +++ b/VisualC/SDL/SDL_VS2012_WinRT.vcxproj @@ -89,11 +89,11 @@ - - - + + + @@ -253,10 +253,10 @@ - - + + diff --git a/VisualC/tests/testthread/WinRT/Assets/Logo.png b/VisualC/tests/testthread/WinRT/Assets/Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..e26771cb33a49bbef824aa333737181b0a5b09a3 GIT binary patch literal 801 zcmeAS@N?(olHy`uVBq!ia0vp^(?FPm4M^HB7Cr(}k|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*9U+m=1foIEGZ*dUJQLud<^=L*gE#63Ho!PGzwUb%GPK6&5iF zt!p@aGNX}6(PVh|N)M-?0RNcTbjaWgEU8noxUax-n>&3Ay)#!y&O11y2sKEF zt72@XC1)RvT6Xw=y_`Ce)`nGULLL^lI$kwi^E+dQT7YeXY4GvlRR%kj1x$VZi%Bdd zz}2Giy=-_$h+v#(S+};)DuE4EM?_^qB_eDeo@&q%StD1F>L|*0ZC2sb-}llSMTM?O z6{b3iid~yk@VE7q7Wb+P8?H5IYp?pSVcLE~18m#ygK20HL@6W5woI~Fjlw$fX1U{xQA5a+t0 zH$WNIb=fNpWHo}M9#;K6eszDZKty_|-?j4iocj5#zotrWc;@;w`H@=mjsvS2wXX0_ zY}l$4@^sE?UcC)ji*L=Z&}P!xaL&2((OQlj2dv~pV-ifAS;ZsH1{`D!GY%yys5WH)f>ZLo5m%6XjuXdbKMR7MEHSyb{m!_{Afji&MT$_sz7 z>1{~MlIFe28FRN(GC_~;#Jp4ADipP+9hh|P#-&`vO-Upt3jE0@YLh(^55uYWl9g)Z RA3>Rb!PC{xWt~$(69A&hN*MqE literal 0 HcmV?d00001 diff --git a/VisualC/tests/testthread/WinRT/Assets/SmallLogo.png b/VisualC/tests/testthread/WinRT/Assets/SmallLogo.png new file mode 100644 index 0000000000000000000000000000000000000000..1eb0d9d528c42f132872e8af4dc563081b0b9aff GIT binary patch literal 329 zcmV-P0k-~$P)q$gGRCwC#*X;?zAP@%N+|i#I!$mrh zlQ>KU$Rdu>|JH&931_?y6Djl{gb>4nCV5pzDJ?S!mq|4ZejKj%i@j$H{#ML~2Y{DF z$=}bKPaz+UGt{v(4CTQQXym}&iW8{s!ew~XIE7NLjQpy#I2S$rous$~?f%DHT#B*+ zq=#!zc5=0FEqWFpB%UE(L807on!pidHPLgYO}XEgorrg;PB=8ipgQ5u5`&g_MQaRd zaU7Ao8XQMuuN21-s0PPTs1%38x_Yl3Fs-|Y4!C-;M-8g@n*v@1|s#GQ665=9@Rxy?u0YW0&WN+~=RXpPbVXXL4m7Aq=E6I0%{06TwRn=U9d8>exk> zD-Z%M3DNQ`bTLSEF=%NFyoHcAkD*CiXqljo*0E?o$GiDC4q}}|%*0WghLlK#npw?hecrM}Mw?`E(z5C8< z8&*b^!{>5?4aT89vdrgBgSc-x6JZD3F^l#*G(@OO*^1D%Eu7?HAy<3kTLqW9N{^#6vso zVQwY48q7)m{~xQ64RV7{E7Y=&T~?^05Ky`5oNQ8bLgFCPq9co^R09BVRS1OAmH;hU zC#q(N!gNqm!zU#%sv{r5mm-Uv8b-~a1F-;p^>)pnXfKge4s9?;;MFIr*fixPG}NBA z6_G5BEmeO6XXh(emkciB{7tA;iwC2^s^VzyU_h0@ae84ACMY`cIDEju=<`q|2QAEv zW_)W|i|9aknqdmS=#w73eW_csQ$8IhT^vY1^1;X3&J0{%*tcQq!gJpr3w?TJc~@5= zKV5sM{$3k>b#S$@CTkhIF*{v*u(F&$&Yq1naHxt8Mz2N%7aQ3(^VNRZahk1||7?Bl z*idzO_u)FhRj4cPzDO>YA>>lxAGaciEiX8Xzp1SVPv91};$OG3cC&8!v3{Jq^kH@8 UTIccK;hzT5*3#}uZuEx!0OwrBv;Y7A literal 0 HcmV?d00001 diff --git a/VisualC/tests/testthread/WinRT/Assets/StoreLogo.png b/VisualC/tests/testthread/WinRT/Assets/StoreLogo.png new file mode 100644 index 0000000000000000000000000000000000000000..dcb672712c6823a0c91548ded70a8acb85536b4d GIT binary patch literal 429 zcmV;e0aE^nP)NtYJa1l)bQ5qwGXpZbs7%2oRMd4y35$s&66(fxhNg8W02!vSn zdlrL2h^Fx+3=$z;kK{0D#MyeJ8WRWZcLSf(PcQ_mLOhrmC}O-tX^0c>5`YvCUZVsc zG-6#78ubjJ5nA;OX&^K(q=i6ZNE3m?kTwE^AqxZoLskfB3|S&1F=UO9!cY$g2@Lgu z;9{sJ1P9|X2L`r1#Gs8R{E^$PRrMaC86q| + + + + + + testthread_VS2012_WinRT + David + Assets\StoreLogo.png + + + + 6.2.1 + 6.2.1 + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT.vcxproj b/VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT.vcxproj new file mode 100644 index 000000000..0f522e147 --- /dev/null +++ b/VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT.vcxproj @@ -0,0 +1,159 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + Debug + ARM + + + Release + ARM + + + + {a8705bee-d01d-46a4-b2ab-feedfb5fdd11} + testthread_VS2012_WinRT + en-US + 11.0 + true + + + + Application + true + v110 + + + Application + true + v110 + + + Application + true + v110 + + + Application + false + true + v110 + + + Application + false + true + v110 + + + Application + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + + testthread_VS2012_WinRT_TemporaryKey.pfx + + + + d2d1.lib; d3d11.lib; dxgi.lib; ole32.lib; windowscodecs.lib; dwrite.lib; %(AdditionalDependencies) + + + pch.h + $(IntDir)pch.pch + $(ProjectDir);$(IntermediateOutputPath);$(ProjectDir)..\..\..\..\include;%(AdditionalIncludeDirectories) + 4453 + + + + + NDEBUG;%(PreprocessorDefinitions) + NotUsing + NotUsing + NotUsing + false + false + false + + + + + _DEBUG;%(PreprocessorDefinitions) + NotUsing + NotUsing + NotUsing + false + false + false + + + + + + + + + + + Designer + + + + + + true + true + true + true + true + true + + + + + + {aeaea3a2-d4e6-45b1-8ec6-53d84287fc14} + + + + + + \ No newline at end of file diff --git a/VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT_TemporaryKey.pfx b/VisualC/tests/testthread/WinRT/testthread_VS2012_WinRT_TemporaryKey.pfx new file mode 100644 index 0000000000000000000000000000000000000000..97fd1e190077fd22da37b95fd53038fdd2ab7917 GIT binary patch literal 2504 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 S`-p?_$L3!@7-%tneg6fLkX32` literal 0 HcmV?d00001 diff --git a/include/SDL_config_windowsrt.h b/include/SDL_config_windowsrt.h index fb7fdb3b9..759dcb866 100644 --- a/include/SDL_config_windowsrt.h +++ b/include/SDL_config_windowsrt.h @@ -158,9 +158,9 @@ typedef unsigned int uintptr_t; #define SDL_LOADSO_WINDOWS 1 /* Enable various threading systems */ -// TODO, WinRT: get threads working on WinRT -#define SDL_THREADS_DISABLED 1 +//#define SDL_THREADS_DISABLED 1 //#define SDL_THREAD_WINDOWS 1 +#define SDL_THREAD_STDCPP 1 /* Enable various timer systems */ // TODO, WinRT: look into getting SDL's pre-WinRT timers working. diff --git a/src/thread/SDL_thread_c.h b/src/thread/SDL_thread_c.h index 565eb3d0e..eb2d6f68e 100644 --- a/src/thread/SDL_thread_c.h +++ b/src/thread/SDL_thread_c.h @@ -36,6 +36,8 @@ #include "windows/SDL_systhread_c.h" #elif SDL_THREAD_NDS #include "nds/SDL_systhread_c.h" +#elif SDL_THREAD_STDCPP +#include "stdcpp/SDL_systhread_c.h" #else #error Need thread implementation for this platform #include "generic/SDL_systhread_c.h" diff --git a/src/thread/stdcpp/SDL_syscond.c b/src/thread/stdcpp/SDL_syscond.c new file mode 100644 index 000000000..7304badc1 --- /dev/null +++ b/src/thread/stdcpp/SDL_syscond.c @@ -0,0 +1,223 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +/* An implementation of condition variables using semaphores and mutexes */ +/* + This implementation borrows heavily from the BeOS condition variable + implementation, written by Christopher Tate and Owen Smith. Thanks! + */ + +#include "SDL_thread.h" + +struct SDL_cond +{ + SDL_mutex *lock; + int waiting; + int signals; + SDL_sem *wait_sem; + SDL_sem *wait_done; +}; + +/* Create a condition variable */ +SDL_cond * +SDL_CreateCond(void) +{ + SDL_cond *cond; + + cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond)); + if (cond) { + cond->lock = SDL_CreateMutex(); + cond->wait_sem = SDL_CreateSemaphore(0); + cond->wait_done = SDL_CreateSemaphore(0); + cond->waiting = cond->signals = 0; + if (!cond->lock || !cond->wait_sem || !cond->wait_done) { + SDL_DestroyCond(cond); + cond = NULL; + } + } else { + SDL_OutOfMemory(); + } + return (cond); +} + +/* Destroy a condition variable */ +void +SDL_DestroyCond(SDL_cond * cond) +{ + if (cond) { + if (cond->wait_sem) { + SDL_DestroySemaphore(cond->wait_sem); + } + if (cond->wait_done) { + SDL_DestroySemaphore(cond->wait_done); + } + if (cond->lock) { + SDL_DestroyMutex(cond->lock); + } + SDL_free(cond); + } +} + +/* Restart one of the threads that are waiting on the condition variable */ +int +SDL_CondSignal(SDL_cond * cond) +{ + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } + + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_LockMutex(cond->lock); + if (cond->waiting > cond->signals) { + ++cond->signals; + SDL_SemPost(cond->wait_sem); + SDL_UnlockMutex(cond->lock); + SDL_SemWait(cond->wait_done); + } else { + SDL_UnlockMutex(cond->lock); + } + + return 0; +} + +/* Restart all threads that are waiting on the condition variable */ +int +SDL_CondBroadcast(SDL_cond * cond) +{ + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } + + /* If there are waiting threads not already signalled, then + signal the condition and wait for the thread to respond. + */ + SDL_LockMutex(cond->lock); + if (cond->waiting > cond->signals) { + int i, num_waiting; + + num_waiting = (cond->waiting - cond->signals); + cond->signals = cond->waiting; + for (i = 0; i < num_waiting; ++i) { + SDL_SemPost(cond->wait_sem); + } + /* Now all released threads are blocked here, waiting for us. + Collect them all (and win fabulous prizes!) :-) + */ + SDL_UnlockMutex(cond->lock); + for (i = 0; i < num_waiting; ++i) { + SDL_SemWait(cond->wait_done); + } + } else { + SDL_UnlockMutex(cond->lock); + } + + return 0; +} + +/* Wait on the condition variable for at most 'ms' milliseconds. + 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_CondWait(cond, lock); + } + SDL_UnlockMutex(lock); + +Thread B: + SDL_LockMutex(lock); + ... + condition = true; + ... + SDL_CondSignal(cond); + SDL_UnlockMutex(lock); + */ +int +SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms) +{ + int retval; + + if (!cond) { + SDL_SetError("Passed a NULL condition variable"); + return -1; + } + + /* Obtain the protection mutex, and increment the number of waiters. + This allows the signal mechanism to only perform a signal if there + are waiting threads. + */ + SDL_LockMutex(cond->lock); + ++cond->waiting; + SDL_UnlockMutex(cond->lock); + + /* Unlock the mutex, as is required by condition variable semantics */ + SDL_UnlockMutex(mutex); + + /* Wait for a signal */ + if (ms == SDL_MUTEX_MAXWAIT) { + retval = SDL_SemWait(cond->wait_sem); + } else { + retval = SDL_SemWaitTimeout(cond->wait_sem, ms); + } + + /* Let the signaler know we have completed the wait, otherwise + the signaler can race ahead and get the condition semaphore + if we are stopped between the mutex unlock and semaphore wait, + giving a deadlock. See the following URL for details: + http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html + */ + SDL_LockMutex(cond->lock); + if (cond->signals > 0) { + /* If we timed out, we need to eat a condition signal */ + if (retval > 0) { + SDL_SemWait(cond->wait_sem); + } + /* We always notify the signal thread that we are done */ + SDL_SemPost(cond->wait_done); + + /* Signal handshake complete */ + --cond->signals; + } + --cond->waiting; + SDL_UnlockMutex(cond->lock); + + /* Lock the mutex, as is required by condition variable semantics */ + SDL_LockMutex(mutex); + + return retval; +} + +/* Wait on the condition variable forever */ +int +SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex) +{ + return SDL_CondWaitTimeout(cond, mutex, SDL_MUTEX_MAXWAIT); +} + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/thread/stdcpp/SDL_sysmutex.c b/src/thread/stdcpp/SDL_sysmutex.c new file mode 100644 index 000000000..1a6b2715c --- /dev/null +++ b/src/thread/stdcpp/SDL_sysmutex.c @@ -0,0 +1,135 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +/* An implementation of mutexes using semaphores */ + +#include "SDL_thread.h" +#include "SDL_systhread_c.h" + + +struct SDL_mutex +{ + int recursive; + SDL_threadID owner; + SDL_sem *sem; +}; + +/* Create a mutex */ +SDL_mutex * +SDL_CreateMutex(void) +{ + SDL_mutex *mutex; + + /* Allocate mutex memory */ + mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex)); + if (mutex) { + /* Create the mutex semaphore, with initial value 1 */ + mutex->sem = SDL_CreateSemaphore(1); + mutex->recursive = 0; + mutex->owner = 0; + if (!mutex->sem) { + SDL_free(mutex); + mutex = NULL; + } + } else { + SDL_OutOfMemory(); + } + return mutex; +} + +/* Free the mutex */ +void +SDL_DestroyMutex(SDL_mutex * mutex) +{ + if (mutex) { + if (mutex->sem) { + SDL_DestroySemaphore(mutex->sem); + } + SDL_free(mutex); + } +} + +/* Lock the semaphore */ +int +SDL_mutexP(SDL_mutex * mutex) +{ +#if SDL_THREADS_DISABLED + return 0; +#else + SDL_threadID this_thread; + + if (mutex == NULL) { + SDL_SetError("Passed a NULL mutex"); + return -1; + } + + this_thread = SDL_ThreadID(); + if (mutex->owner == this_thread) { + ++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. + */ + SDL_SemWait(mutex->sem); + mutex->owner = this_thread; + mutex->recursive = 0; + } + + return 0; +#endif /* SDL_THREADS_DISABLED */ +} + +/* Unlock the mutex */ +int +SDL_mutexV(SDL_mutex * mutex) +{ +#if SDL_THREADS_DISABLED + return 0; +#else + if (mutex == NULL) { + SDL_SetError("Passed a NULL mutex"); + return -1; + } + + /* If we don't own the mutex, we can't unlock it */ + if (SDL_ThreadID() != mutex->owner) { + SDL_SetError("mutex not owned by this thread"); + return -1; + } + + if (mutex->recursive) { + --mutex->recursive; + } else { + /* The order of operations is important. + First reset the owner so another thread doesn't lock + the mutex and set the ownership before we reset it, + then release the lock semaphore. + */ + mutex->owner = 0; + SDL_SemPost(mutex->sem); + } + return 0; +#endif /* SDL_THREADS_DISABLED */ +} + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/thread/stdcpp/SDL_sysmutex_c.h b/src/thread/stdcpp/SDL_sysmutex_c.h new file mode 100644 index 000000000..ed546b689 --- /dev/null +++ b/src/thread/stdcpp/SDL_sysmutex_c.h @@ -0,0 +1,22 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/thread/stdcpp/SDL_systhread.c b/src/thread/stdcpp/SDL_systhread.c new file mode 100644 index 000000000..ed557a461 --- /dev/null +++ b/src/thread/stdcpp/SDL_systhread.c @@ -0,0 +1,59 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +/* Thread management routines for SDL */ + +#include "SDL_thread.h" +#include "../SDL_systhread.h" + +int +SDL_SYS_CreateThread(SDL_Thread * thread, void *args) +{ + SDL_SetError("Threads are not supported on this platform"); + return (-1); +} + +void +SDL_SYS_SetupThread(const char *name) +{ + return; +} + +SDL_threadID +SDL_ThreadID(void) +{ + return (0); +} + +int +SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority) +{ + return (0); +} + +void +SDL_SYS_WaitThread(SDL_Thread * thread) +{ + return; +} + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/thread/stdcpp/SDL_systhread_c.h b/src/thread/stdcpp/SDL_systhread_c.h new file mode 100644 index 000000000..4a060c98a --- /dev/null +++ b/src/thread/stdcpp/SDL_systhread_c.h @@ -0,0 +1,26 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_config.h" + +/* For a thread handle, use a void pointer to a std::thread */ +typedef void * SYS_ThreadHandle; + +/* vi: set ts=4 sw=4 expandtab: */