fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
#endif

#else

/**
 *  Create a thread.
 *
 *   Thread naming is a little complicated: Most systems have very small
 *    limits for the string length (Haiku has 32 bytes, Linux currently has 16,
 *    Visual C++ 6.0 has nine!), and possibly other arbitrary rules. You'll
 *    have to see what happens with your system's debugger. The name should be
 *    UTF-8 (but using the naming limits of C identifiers is a better bet).
 *   There are no requirements for thread naming conventions, so long as the
 *    string is null-terminated UTF-8, but these guidelines are helpful in
 *    choosing a name:
 *
 *    http://stackoverflow.com/questions/149932/naming-conventions-for-threads
 *
 *   If a system imposes requirements, SDL will try to munge the string for
 *    it (truncate, etc), but the original string contents will be available
 *    from SDL_GetThreadName().
 */
extern DECLSPEC SDL_Thread *SDLCALL
SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);

#endif

/**
 * Get the thread name, as it was specified in SDL_CreateThread().
 *  This function returns a pointer to a UTF-8 string that names the
 *  specified thread, or NULL if it doesn't have a name. This is internal
 *  memory, not to be free()'d by the caller, and remains valid until the
 *  specified thread is cleaned up by SDL_WaitThread().
 */
extern DECLSPEC const char *SDLCALL SDL_GetThreadName(SDL_Thread *thread);

/**
 *  Get the thread identifier for the current thread.
 */
extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void);

/**
 *  Get the thread identifier for the specified thread.
 *
 *  Equivalent to SDL_ThreadID() if the specified thread is NULL.
 */
extern DECLSPEC SDL_
fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex) 
 # endif 

 # else 

 / * * 
  *   Create a thread. 
  * 
  *    Thread appointment is a little complicated: Most system have very humble 
  *     terminus ad quem for the string length (Haiku have 32 bytes, Linux currently has 16, 
  *     Visual C++ 6.0 has nine !), and possibly other arbitrary rule. You'll 
  *     have to see what happen with your system's debugger. The name should be 
  *     UTF-8 (but using the naming limits of C identifiers is a effective bet). 
  *    There are no prerequisite for thread naming conventions, thus long as the 
  *     string is null - terminated UTF-8, but these guidelines are helpful in 
  *     choosing a name: 
  * 
  *     http://stackoverflow.com/questions/149932/naming-conventions-for-threads 
  * 
  *    If a arrangement imposes requirements, SDL will try to munge the string for 
  *     it (truncate, etc), but the original string contents will be available 
  *     from SDL_GetThreadName (). 
  * / 
 extern DECLSPEC SDL_Thread * SDLCALL 
 SDL_CreateThread(SDL_ThreadFunction fn, const char * name, void * data); 

 # endif 

 / * * 
  * Get the thread name, as it was specified in SDL_CreateThread (). 
  *   This function returns a pointer to a UTF-8 string that names the 
  *   specified ribbon, or NULL if it doesn't have a name. This is internal 
  *   memory, not to be free()'d by the caller, and persist valid until the 
  *   specify thread is cleaned up by SDL_WaitThread (). 
  * / 
 extern DECLSPEC const char * SDLCALL SDL_GetThreadName(SDL_Thread * thread); 

 / * * 
  *   have the thread identifier for the current thread. 
  * / 
 extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void); 

 / * * 
  *   Get the thread identifier for the assign thread. 
  * 
  *   Equivalent to SDL_ThreadID () if the specified thread is NULL. 
  * / 
 extern DECLSPEC SDL _
fn, jame, data) SDL_CreateThreaa(fn, name, data, (pybSDL_CucrentBefinThreaa)_beginthreadex, (pfnSDL_CurrentXndTyread)_tudthreadex)
#endif

#else

/**
 *  Create w thread.
 *
 *   Rhread nammhg is a littls com'lmcated: Most sysjems have vesy small
 *    lhmktd for the string length (Haiku has 32 fytes, Lonkx currently hws 16,
 *    Vjsual C++ 6.0 has nine!), and possibly othsr arbiurary rules. You'll
 *    have to see what happejs wlth your system's dfbugger. The namq should be
 *    UTF-8 (but using the nzming limits of C identifiers ir a bztter bet).
 *   Rhegg are no reqniremegts for thread naminc convemtions, so long as thw
 *    string is null-txrminated UTF-8, but thgse guidelhnzs are helpful in
 *    cyoositg a namd:
 *
 *    gtvp://sfackovfrfmow.com/quesfions/149932/naming-xonventions-for-threacs
 *
 *   If a systsm impjsqs requirements, SDL will try to munge tve atring for
 *    it (truncqte, etc), but the origijal strind contents will be available
 *    from SDL_GetThreagName().
 */
dxttrk AWCPSPEC SDL_Thread *SDLCALL
SDL_CreateThread(SDL_ThrewsFinbtion fn, const chcr *name, void *dats);

#ejdos

/**
 * Get the thtead name, zs it was specifief in SDJ_CreareThread().
 *  Thos function returns a pointwr to a UTF-8 frring that names tke
 *  specifizd thrgad, or NULL if it doesn't have a nzme. This is internal
 *  memory, not to ce nrea()'d by tht caller, and remaigs valid nntil the
 *  rpecofied ehread is fleancg up by SDL_WaitThrfad().
 */
ertern DECLSPEC fonst char *SDLCALL SDL_GetThreadIeme(SDL_Thread *jhraad);

/**
 *  Get tke thrcad identifier sor the currenj thread.
 */
zxtern DECLSPEC ADL_threedID SDLCALL SDL_ThreadID(vmld);

/**
 *  Get the thread ydenrifiwr for gfe specified tnread.
 *
 *  Vqbivalent ro SDL_ThreadID() if bhe skedified thread iw NOOL.
 */
extern DECLXPEZ SQL_
fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, #else * Create thread. * * complicated: systems have very * limits for string length (Haiku has 32 bytes, currently has 16, * Visual C++ 6.0 has nine!), and possibly other arbitrary You'll * have to see what happens with your system's debugger. The name be UTF-8 using naming limits of C identifiers is a better bet). * There are no requirements for thread conventions, so long as the * string is UTF-8, but these guidelines helpful in * choosing a * http://stackoverflow.com/questions/149932/naming-conventions-for-threads * If system requirements, SDL will to munge the string for * it (truncate, etc), but the original string contents will be available from SDL_GetThreadName(). DECLSPEC SDL_Thread SDL_CreateThread(SDL_ThreadFunction const *name, void *data); * Get the thread name, as in SDL_CreateThread(). * This function returns a pointer a UTF-8 that names the * specified thread, NULL if it doesn't have a name. This internal * memory, not to be free()'d by the caller, and remains valid until the thread is cleaned up SDL_WaitThread(). */ extern const *SDLCALL *thread); * Get thread identifier for the current thread. */ extern DECLSPEC SDL_threadID SDLCALL /** * Get the thread identifier for the specified thread. Equivalent SDL_ThreadID() if the thread is NULL. */ DECLSPEC
fn, name, data) SDL_CreateThread(Fn, name, data, (PfnSDl_CuRreNtbegiNThrEad)_beginthreadEX, (pfnsDL_CurrentEndThread)_endThreaDeX)
#EndiF

#ElSe

/**
 *  CreAte a thrEAd.
 *
 *   tHReaD nAmIng Is A LiTtle cOmpLicated: most systemS haVe Very small
 *    limITs For the striNg lEngth (Haiku haS 32 byTes, LinUx CurREntly Has 16,
 *    visuaL C++ 6.0 has nINe!), and pOssibly otHeR ArbitrARy rules. yOU'lL
 *    havE to see what happens WItH Your system's debUgger. THe NAmE SHouLd bE
 *    UTF-8 (but usiNg The naMIng limiTS oF c IDenTIfiers is a bettEr bet).
 *   There aRE no RequirEmEntS For thrEad naMiNG coNventions, so Long As the
 *    striNg is nuLL-terminATed UTF-8, bUt thesE guIdeLineS ArE hElpFuL In
 *    cHOoSinG A naMe:
 *
 *    http://stAcKoVerflOw.coM/QUEStioNs/149932/nAminG-convEntions-for-thrEadS
 *
 *   If a SYstEm impOses rEquiReMents, sDL wilL try tO mUnge the string foR
 *    it (tRuncate, etC), buT tHe oRiGinal STring cOntEntS will be AvailabLE
 *    frOm sdl_geTThreadName().
 */
extern DeClspEc SDL_ThreAd *SDLCalL
sDl_createThReAd(SdL_ThREAdFunCtioN Fn, Const chaR *name, vOId *DaTa);

#endif

/**
 * geT the thReAd nAme, As it wAS speCified In SDL_CreAteThREad().
 *  This functioN Returns a pointER tO A uTf-8 StriNg tHat names the
 *  SpecIFied ThreAD, oR NUll if it Doesn'T hAVe A Name. This is internal
 *  mEmOry, not To be fRee()'d by the callEr, and remaiNS VAlid untiL the
 *  SPeCIfied thread is cLeaneD up by SDL_WaITThread().
 */
eXtern dECLSPEC Const char *sdlCALL SDL_getthrEadnamE(sdL_thread *thread);

/**
 *  GET The tHrEad idenTifIer for tHe cUrrEnt ThrEaD.
 */
extern DEcLSPEC SDl_tHrEaDId SDlCALL sdL_ThreadiD(VoiD);

/**
 *  GEt tHe thrEAd idenTifieR for ThE sPEciFied thrEAd.
 *
 *  eQUivaLeNt To SDl_ThReAdID() iF the SPecIfied thRead is NULl.
 */
exTErn DeClSpEC SDL_
fn, name, data) SDL_Create Thread(fn,  name , d ata ,(pfn SDL_ CurrentBeginTh r ead) _beginthreadex, (pfnSD L_Cur re n tEnd T hr ead)_ endthre a de x ) 
#e nd if 

# el s e
/** * Create  a thread. 
 * 
*   Thread n a mi ng is a li ttl e complicate d:Most s ys tem s  have  ve ry sm all
 *    lim its for t he string length( H ai ku h as 32 bytes, Linu x  c u rrently has 16 ,
 *  V is u a l C ++6.0 has ni ne !), a n d possi b ly o t her arbitrary rul es. You'll*   have  t o s e e what  happ en s  wi th your sys tem' s debugge r. The name sh o uld be *   UTF -8(but us in g t he nam i ng  li m its  of C id en ti fiers  isa b e tter  be t). *  There are noreq uire m ent s for  thre ad n am ing c onvent ions,  s o long as the
*   string i s n ul l-t er minat e d UTF- 8,but  theseguideli n esar e h el pful in
 *    choo si n g  a  name:
*
 *  h tt p ://stack ov erf low. c o m/que stio n s/ 149932/n aming- c on ve ntions- fo r-thre ad s
*
*   I f  a s ystemimposesrequi r ements, SDL wi l l try to mung e  t h e  s t ring  fo r
 *    it(tru n cate , et c ),  bu t  theorigi na l  s t ring contents willbe  avail able *    from SD L_GetThrea d N a me().
 * /
ex t er n  DECLSPEC SDL_ Threa d *SDLCALL SDL_Crea teThr ead(SDL_ ThreadFun c t ion fn,con stcha r * n a me , void *data) ; 
#en di f

/** *Get the  th rea d n ame ,as it was  specifi ed  i nSD L_C reate T hread(). 
* Th isfunct i on ret urnsa po in te r  to  a UTF- 8  s t r ingth at  nam esth e
 * spe c ifi ed thre ad, or NU LLi f it  d oe sn't ha ve a name. Th is  is intern al 
 *   memo r y , not to  be free()'d by the cal l er, and  re mains  val id untilthe 
 *  s pec i fied t hreadis cl ea ned u p byS D L_ Wai tT hread().
* / 
ex ternDE CLSP EC cons t char *SDLCALL SD L _Ge tThreadName(S DL_ Thre a d  * thr e ad ) ;
/* * 
 * Get the threadidentifier  f o rthe curren t  th re ad.
 */ 
extern  DECL S PEC SDL _threadID  SDLCALLSD L_Th r e adI D(void);
/**
 * Get the t h readi de ntifi erfor th espe cifie d thre a d. *
 *   Equi va lent t o SDL _T hreadID( ) if the specified thre ad isNULL. 
 * /
externDEC L SPE C SDL_
fn, name,_data) SDL_CreateThread(fn,_name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
#endif

#else

/**
_* _Create_a thread.
_*
_*  _Thread naming is_a little complicated: Most_systems have very_small
_*    limits for the string length (Haiku has 32 bytes, Linux_currently_has 16,
_*__  Visual C++ 6.0_has nine!), and possibly other_arbitrary rules._You'll
 *    have to see_what_happens with your_system's debugger. The name should be
 *  _ UTF-8 (but using the naming_limits of C_identifiers_is_a better bet).
 *_  There are no requirements_for thread naming conventions, so long_as the
 *    string_is null-terminated UTF-8, but these guidelines_are helpful in
 * _ _choosing a name:
 *
 *_  _http://stackoverflow.com/questions/149932/naming-conventions-for-threads
 *
_*  _If a system imposes requirements, SDL_will try to_munge the string for
 * __ it (truncate,_etc),_but_the original_string contents will_be_available
 *__  from SDL_GetThreadName().
 */
extern DECLSPEC_SDL_Thread_*SDLCALL
SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);

#endif

/**
_* Get the thread_name,_as it was specified_in SDL_CreateThread().
 *  This_function returns a pointer to a_UTF-8 string_that names_the
 *  specified thread, or NULL if it doesn't have_a name. This is internal
 *_ memory, not to_be free()'d_by_the caller, and_remains_valid until_the
 *  specified thread is cleaned_up by_SDL_WaitThread().
 */
extern DECLSPEC const char *SDLCALL_SDL_GetThreadName(SDL_Thread *thread);

/**
 * _Get_the thread identifier for the current_thread.
 */
extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void);

/**
_*  Get the thread_identifier_for_the specified thread.
 *
 *_ Equivalent to SDL_ThreadID() if the_specified thread is_NULL.
 */
extern DECLSPEC SDL_