These are needed to make the gallium thread abstraction work. Signed-off-by: Dave Airlie <airlied@redhat.com>macos/master
parent
d1323fd44b
commit
fff55a104f
@ -0,0 +1,79 @@ |
||||
/*
|
||||
* C11 <threads.h> emulation library |
||||
* |
||||
* (C) Copyright yohhoy 2012. |
||||
* Distributed under the Boost Software License, Version 1.0. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person or organization |
||||
* obtaining a copy of the software and accompanying documentation covered by |
||||
* this license (the "Software") to use, reproduce, display, distribute, |
||||
* execute, and transmit the Software, and to prepare [[derivative work]]s of the |
||||
* Software, and to permit third-parties to whom the Software is furnished to |
||||
* do so, all subject to the following: |
||||
* |
||||
* The copyright notices in the Software and this entire statement, including |
||||
* the above license grant, this restriction and the following disclaimer, |
||||
* must be included in all copies of the Software, in whole or in part, and |
||||
* all derivative works of the Software, unless such copies or derivative |
||||
* works are solely in the form of machine-executable object code generated by |
||||
* a source language processor. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT |
||||
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE |
||||
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, |
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
* DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
#ifndef EMULATED_THREADS_H_INCLUDED_ |
||||
#define EMULATED_THREADS_H_INCLUDED_ |
||||
|
||||
#include <time.h> |
||||
|
||||
#ifndef TIME_UTC |
||||
#define TIME_UTC 1 |
||||
#endif |
||||
|
||||
#include "c99_compat.h" /* for `inline` */ |
||||
|
||||
/*---------------------------- types ----------------------------*/ |
||||
typedef void (*tss_dtor_t)(void*); |
||||
typedef int (*thrd_start_t)(void*); |
||||
|
||||
struct xtime { |
||||
time_t sec; |
||||
long nsec; |
||||
}; |
||||
typedef struct xtime xtime; |
||||
|
||||
|
||||
/*-------------------- enumeration constants --------------------*/ |
||||
enum { |
||||
mtx_plain = 0, |
||||
mtx_try = 1, |
||||
mtx_timed = 2, |
||||
mtx_recursive = 4 |
||||
}; |
||||
|
||||
enum { |
||||
thrd_success = 0, // succeeded
|
||||
thrd_timeout, // timeout
|
||||
thrd_error, // failed
|
||||
thrd_busy, // resource busy
|
||||
thrd_nomem // out of memory
|
||||
}; |
||||
|
||||
/*-------------------------- functions --------------------------*/ |
||||
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__) |
||||
#include "threads_win32.h" |
||||
#elif defined(HAVE_PTHREAD) |
||||
#include "threads_posix.h" |
||||
#else |
||||
#error Not supported on this platform. |
||||
#endif |
||||
|
||||
|
||||
|
||||
#endif /* EMULATED_THREADS_H_INCLUDED_ */ |
@ -0,0 +1,374 @@ |
||||
/*
|
||||
* C11 <threads.h> emulation library |
||||
* |
||||
* (C) Copyright yohhoy 2012. |
||||
* Distributed under the Boost Software License, Version 1.0. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person or organization |
||||
* obtaining a copy of the software and accompanying documentation covered by |
||||
* this license (the "Software") to use, reproduce, display, distribute, |
||||
* execute, and transmit the Software, and to prepare [[derivative work]]s of the |
||||
* Software, and to permit third-parties to whom the Software is furnished to |
||||
* do so, all subject to the following: |
||||
* |
||||
* The copyright notices in the Software and this entire statement, including |
||||
* the above license grant, this restriction and the following disclaimer, |
||||
* must be included in all copies of the Software, in whole or in part, and |
||||
* all derivative works of the Software, unless such copies or derivative |
||||
* works are solely in the form of machine-executable object code generated by |
||||
* a source language processor. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT |
||||
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE |
||||
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, |
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
* DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
#include <stdlib.h> |
||||
#ifndef assert |
||||
#include <assert.h> |
||||
#endif |
||||
#include <limits.h> |
||||
#include <errno.h> |
||||
#include <unistd.h> |
||||
#include <sched.h> |
||||
#include <stdint.h> /* for intptr_t */ |
||||
|
||||
/*
|
||||
Configuration macro: |
||||
|
||||
EMULATED_THREADS_USE_NATIVE_TIMEDLOCK |
||||
Use pthread_mutex_timedlock() for `mtx_timedlock()' |
||||
Otherwise use mtx_trylock() + *busy loop* emulation. |
||||
*/ |
||||
#if !defined(__CYGWIN__) && !defined(__APPLE__) && !defined(__NetBSD__) |
||||
#define EMULATED_THREADS_USE_NATIVE_TIMEDLOCK |
||||
#endif |
||||
|
||||
|
||||
#include <pthread.h> |
||||
|
||||
/*---------------------------- macros ----------------------------*/ |
||||
#define ONCE_FLAG_INIT PTHREAD_ONCE_INIT |
||||
#ifdef INIT_ONCE_STATIC_INIT |
||||
#define TSS_DTOR_ITERATIONS PTHREAD_DESTRUCTOR_ITERATIONS |
||||
#else |
||||
#define TSS_DTOR_ITERATIONS 1 // assume TSS dtor MAY be called at least once.
|
||||
#endif |
||||
|
||||
// FIXME: temporary non-standard hack to ease transition
|
||||
#define _MTX_INITIALIZER_NP PTHREAD_MUTEX_INITIALIZER |
||||
|
||||
/*---------------------------- types ----------------------------*/ |
||||
typedef pthread_cond_t cnd_t; |
||||
typedef pthread_t thrd_t; |
||||
typedef pthread_key_t tss_t; |
||||
typedef pthread_mutex_t mtx_t; |
||||
typedef pthread_once_t once_flag; |
||||
|
||||
|
||||
/*
|
||||
Implementation limits: |
||||
- Conditionally emulation for "mutex with timeout" |
||||
(see EMULATED_THREADS_USE_NATIVE_TIMEDLOCK macro) |
||||
*/ |
||||
struct impl_thrd_param { |
||||
thrd_start_t func; |
||||
void *arg; |
||||
}; |
||||
|
||||
static inline void * |
||||
impl_thrd_routine(void *p) |
||||
{ |
||||
struct impl_thrd_param pack = *((struct impl_thrd_param *)p); |
||||
free(p); |
||||
return (void*)(intptr_t)pack.func(pack.arg); |
||||
} |
||||
|
||||
|
||||
/*--------------- 7.25.2 Initialization functions ---------------*/ |
||||
// 7.25.2.1
|
||||
static inline void |
||||
call_once(once_flag *flag, void (*func)(void)) |
||||
{ |
||||
pthread_once(flag, func); |
||||
} |
||||
|
||||
|
||||
/*------------- 7.25.3 Condition variable functions -------------*/ |
||||
// 7.25.3.1
|
||||
static inline int |
||||
cnd_broadcast(cnd_t *cond) |
||||
{ |
||||
assert(cond != NULL); |
||||
return (pthread_cond_broadcast(cond) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.3.2
|
||||
static inline void |
||||
cnd_destroy(cnd_t *cond) |
||||
{ |
||||
assert(cond); |
||||
pthread_cond_destroy(cond); |
||||
} |
||||
|
||||
// 7.25.3.3
|
||||
static inline int |
||||
cnd_init(cnd_t *cond) |
||||
{ |
||||
assert(cond != NULL); |
||||
return (pthread_cond_init(cond, NULL) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.3.4
|
||||
static inline int |
||||
cnd_signal(cnd_t *cond) |
||||
{ |
||||
assert(cond != NULL); |
||||
return (pthread_cond_signal(cond) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.3.5
|
||||
static inline int |
||||
cnd_timedwait(cnd_t *cond, mtx_t *mtx, const xtime *xt) |
||||
{ |
||||
struct timespec abs_time; |
||||
int rt; |
||||
|
||||
assert(mtx != NULL); |
||||
assert(cond != NULL); |
||||
assert(xt != NULL); |
||||
|
||||
abs_time.tv_sec = xt->sec; |
||||
abs_time.tv_nsec = xt->nsec; |
||||
|
||||
rt = pthread_cond_timedwait(cond, mtx, &abs_time); |
||||
if (rt == ETIMEDOUT) |
||||
return thrd_busy; |
||||
return (rt == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.3.6
|
||||
static inline int |
||||
cnd_wait(cnd_t *cond, mtx_t *mtx) |
||||
{ |
||||
assert(mtx != NULL); |
||||
assert(cond != NULL); |
||||
return (pthread_cond_wait(cond, mtx) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
|
||||
/*-------------------- 7.25.4 Mutex functions --------------------*/ |
||||
// 7.25.4.1
|
||||
static inline void |
||||
mtx_destroy(mtx_t *mtx) |
||||
{ |
||||
assert(mtx != NULL); |
||||
pthread_mutex_destroy(mtx); |
||||
} |
||||
|
||||
// 7.25.4.2
|
||||
static inline int |
||||
mtx_init(mtx_t *mtx, int type) |
||||
{ |
||||
pthread_mutexattr_t attr; |
||||
assert(mtx != NULL); |
||||
if (type != mtx_plain && type != mtx_timed && type != mtx_try |
||||
&& type != (mtx_plain|mtx_recursive) |
||||
&& type != (mtx_timed|mtx_recursive) |
||||
&& type != (mtx_try|mtx_recursive)) |
||||
return thrd_error; |
||||
pthread_mutexattr_init(&attr); |
||||
if ((type & mtx_recursive) != 0) |
||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); |
||||
pthread_mutex_init(mtx, &attr); |
||||
pthread_mutexattr_destroy(&attr); |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.4.3
|
||||
static inline int |
||||
mtx_lock(mtx_t *mtx) |
||||
{ |
||||
assert(mtx != NULL); |
||||
return (pthread_mutex_lock(mtx) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
static inline int |
||||
mtx_trylock(mtx_t *mtx); |
||||
|
||||
static inline void |
||||
thrd_yield(void); |
||||
|
||||
// 7.25.4.4
|
||||
static inline int |
||||
mtx_timedlock(mtx_t *mtx, const xtime *xt) |
||||
{ |
||||
assert(mtx != NULL); |
||||
assert(xt != NULL); |
||||
|
||||
{ |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_TIMEDLOCK |
||||
struct timespec ts; |
||||
int rt; |
||||
ts.tv_sec = xt->sec; |
||||
ts.tv_nsec = xt->nsec; |
||||
rt = pthread_mutex_timedlock(mtx, &ts); |
||||
if (rt == 0) |
||||
return thrd_success; |
||||
return (rt == ETIMEDOUT) ? thrd_busy : thrd_error; |
||||
#else |
||||
time_t expire = time(NULL); |
||||
expire += xt->sec; |
||||
while (mtx_trylock(mtx) != thrd_success) { |
||||
time_t now = time(NULL); |
||||
if (expire < now) |
||||
return thrd_busy; |
||||
// busy loop!
|
||||
thrd_yield(); |
||||
} |
||||
return thrd_success; |
||||
#endif |
||||
} |
||||
} |
||||
|
||||
// 7.25.4.5
|
||||
static inline int |
||||
mtx_trylock(mtx_t *mtx) |
||||
{ |
||||
assert(mtx != NULL); |
||||
return (pthread_mutex_trylock(mtx) == 0) ? thrd_success : thrd_busy; |
||||
} |
||||
|
||||
// 7.25.4.6
|
||||
static inline int |
||||
mtx_unlock(mtx_t *mtx) |
||||
{ |
||||
assert(mtx != NULL); |
||||
return (pthread_mutex_unlock(mtx) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
|
||||
/*------------------- 7.25.5 Thread functions -------------------*/ |
||||
// 7.25.5.1
|
||||
static inline int |
||||
thrd_create(thrd_t *thr, thrd_start_t func, void *arg) |
||||
{ |
||||
struct impl_thrd_param *pack; |
||||
assert(thr != NULL); |
||||
pack = (struct impl_thrd_param *)malloc(sizeof(struct impl_thrd_param)); |
||||
if (!pack) return thrd_nomem; |
||||
pack->func = func; |
||||
pack->arg = arg; |
||||
if (pthread_create(thr, NULL, impl_thrd_routine, pack) != 0) { |
||||
free(pack); |
||||
return thrd_error; |
||||
} |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.5.2
|
||||
static inline thrd_t |
||||
thrd_current(void) |
||||
{ |
||||
return pthread_self(); |
||||
} |
||||
|
||||
// 7.25.5.3
|
||||
static inline int |
||||
thrd_detach(thrd_t thr) |
||||
{ |
||||
return (pthread_detach(thr) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.5.4
|
||||
static inline int |
||||
thrd_equal(thrd_t thr0, thrd_t thr1) |
||||
{ |
||||
return pthread_equal(thr0, thr1); |
||||
} |
||||
|
||||
// 7.25.5.5
|
||||
static inline void |
||||
thrd_exit(int res) |
||||
{ |
||||
pthread_exit((void*)(intptr_t)res); |
||||
} |
||||
|
||||
// 7.25.5.6
|
||||
static inline int |
||||
thrd_join(thrd_t thr, int *res) |
||||
{ |
||||
void *code; |
||||
if (pthread_join(thr, &code) != 0) |
||||
return thrd_error; |
||||
if (res) |
||||
*res = (int)(intptr_t)code; |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.5.7
|
||||
static inline void |
||||
thrd_sleep(const xtime *xt) |
||||
{ |
||||
struct timespec req; |
||||
assert(xt); |
||||
req.tv_sec = xt->sec; |
||||
req.tv_nsec = xt->nsec; |
||||
nanosleep(&req, NULL); |
||||
} |
||||
|
||||
// 7.25.5.8
|
||||
static inline void |
||||
thrd_yield(void) |
||||
{ |
||||
sched_yield(); |
||||
} |
||||
|
||||
|
||||
/*----------- 7.25.6 Thread-specific storage functions -----------*/ |
||||
// 7.25.6.1
|
||||
static inline int |
||||
tss_create(tss_t *key, tss_dtor_t dtor) |
||||
{ |
||||
assert(key != NULL); |
||||
return (pthread_key_create(key, dtor) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.6.2
|
||||
static inline void |
||||
tss_delete(tss_t key) |
||||
{ |
||||
pthread_key_delete(key); |
||||
} |
||||
|
||||
// 7.25.6.3
|
||||
static inline void * |
||||
tss_get(tss_t key) |
||||
{ |
||||
return pthread_getspecific(key); |
||||
} |
||||
|
||||
// 7.25.6.4
|
||||
static inline int |
||||
tss_set(tss_t key, void *val) |
||||
{ |
||||
return (pthread_setspecific(key, val) == 0) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
|
||||
/*-------------------- 7.25.7 Time functions --------------------*/ |
||||
// 7.25.6.1
|
||||
static inline int |
||||
xtime_get(xtime *xt, int base) |
||||
{ |
||||
if (!xt) return 0; |
||||
if (base == TIME_UTC) { |
||||
xt->sec = time(NULL); |
||||
xt->nsec = 0; |
||||
return base; |
||||
} |
||||
return 0; |
||||
} |
@ -0,0 +1,642 @@ |
||||
/*
|
||||
* C11 <threads.h> emulation library |
||||
* |
||||
* (C) Copyright yohhoy 2012. |
||||
* Distributed under the Boost Software License, Version 1.0. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person or organization |
||||
* obtaining a copy of the software and accompanying documentation covered by |
||||
* this license (the "Software") to use, reproduce, display, distribute, |
||||
* execute, and transmit the Software, and to prepare [[derivative work]]s of the |
||||
* Software, and to permit third-parties to whom the Software is furnished to |
||||
* do so, all subject to the following: |
||||
* |
||||
* The copyright notices in the Software and this entire statement, including |
||||
* the above license grant, this restriction and the following disclaimer, |
||||
* must be included in all copies of the Software, in whole or in part, and |
||||
* all derivative works of the Software, unless such copies or derivative |
||||
* works are solely in the form of machine-executable object code generated by |
||||
* a source language processor. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT |
||||
* SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE |
||||
* FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, |
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
* DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
#ifndef assert |
||||
#include <assert.h> |
||||
#endif |
||||
#include <limits.h> |
||||
#include <errno.h> |
||||
#include <process.h> // MSVCRT |
||||
#include <stdlib.h> |
||||
|
||||
/*
|
||||
Configuration macro: |
||||
|
||||
EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
Use native WindowsAPI one-time initialization function. |
||||
(requires WinVista or later) |
||||
Otherwise emulate by mtx_trylock() + *busy loop* for WinXP. |
||||
|
||||
EMULATED_THREADS_USE_NATIVE_CV |
||||
Use native WindowsAPI condition variable object. |
||||
(requires WinVista or later) |
||||
Otherwise use emulated implementation for WinXP. |
||||
|
||||
EMULATED_THREADS_TSS_DTOR_SLOTNUM |
||||
Max registerable TSS dtor number. |
||||
*/ |
||||
|
||||
// XXX: Retain XP compatability
|
||||
#if 0 |
||||
#if _WIN32_WINNT >= 0x0600 |
||||
// Prefer native WindowsAPI on newer environment.
|
||||
#if !defined(__MINGW32__) |
||||
#define EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
#endif |
||||
#define EMULATED_THREADS_USE_NATIVE_CV |
||||
#endif |
||||
#endif |
||||
#define EMULATED_THREADS_TSS_DTOR_SLOTNUM 64 // see TLS_MINIMUM_AVAILABLE
|
||||
|
||||
|
||||
#include <windows.h> |
||||
|
||||
// check configuration
|
||||
#if defined(EMULATED_THREADS_USE_NATIVE_CALL_ONCE) && (_WIN32_WINNT < 0x0600) |
||||
#error EMULATED_THREADS_USE_NATIVE_CALL_ONCE requires _WIN32_WINNT>=0x0600 |
||||
#endif |
||||
|
||||
#if defined(EMULATED_THREADS_USE_NATIVE_CV) && (_WIN32_WINNT < 0x0600) |
||||
#error EMULATED_THREADS_USE_NATIVE_CV requires _WIN32_WINNT>=0x0600 |
||||
#endif |
||||
|
||||
|
||||
/*---------------------------- macros ----------------------------*/ |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
#define ONCE_FLAG_INIT INIT_ONCE_STATIC_INIT |
||||
#else |
||||
#define ONCE_FLAG_INIT {0} |
||||
#endif |
||||
#define TSS_DTOR_ITERATIONS 1 |
||||
|
||||
// FIXME: temporary non-standard hack to ease transition
|
||||
#define _MTX_INITIALIZER_NP {(PCRITICAL_SECTION_DEBUG)-1, -1, 0, 0, 0, 0} |
||||
|
||||
/*---------------------------- types ----------------------------*/ |
||||
typedef struct cnd_t { |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
CONDITION_VARIABLE condvar; |
||||
#else |
||||
int blocked; |
||||
int gone; |
||||
int to_unblock; |
||||
HANDLE sem_queue; |
||||
HANDLE sem_gate; |
||||
CRITICAL_SECTION monitor; |
||||
#endif |
||||
} cnd_t; |
||||
|
||||
typedef HANDLE thrd_t; |
||||
|
||||
typedef DWORD tss_t; |
||||
|
||||
typedef CRITICAL_SECTION mtx_t; |
||||
|
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
typedef INIT_ONCE once_flag; |
||||
#else |
||||
typedef struct once_flag_t { |
||||
volatile LONG status; |
||||
} once_flag; |
||||
#endif |
||||
|
||||
|
||||
static inline void * tss_get(tss_t key); |
||||
static inline void thrd_yield(void); |
||||
static inline int mtx_trylock(mtx_t *mtx); |
||||
static inline int mtx_lock(mtx_t *mtx); |
||||
static inline int mtx_unlock(mtx_t *mtx); |
||||
|
||||
/*
|
||||
Implementation limits: |
||||
- Conditionally emulation for "Initialization functions" |
||||
(see EMULATED_THREADS_USE_NATIVE_CALL_ONCE macro) |
||||
- Emulated `mtx_timelock()' with mtx_trylock() + *busy loop* |
||||
*/ |
||||
static void impl_tss_dtor_invoke(void); // forward decl.
|
||||
|
||||
struct impl_thrd_param { |
||||
thrd_start_t func; |
||||
void *arg; |
||||
}; |
||||
|
||||
static unsigned __stdcall impl_thrd_routine(void *p) |
||||
{ |
||||
struct impl_thrd_param pack; |
||||
int code; |
||||
memcpy(&pack, p, sizeof(struct impl_thrd_param)); |
||||
free(p); |
||||
code = pack.func(pack.arg); |
||||
impl_tss_dtor_invoke(); |
||||
return (unsigned)code; |
||||
} |
||||
|
||||
static DWORD impl_xtime2msec(const xtime *xt) |
||||
{ |
||||
return (DWORD)((xt->sec * 1000U) + (xt->nsec / 1000000L)); |
||||
} |
||||
|
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
struct impl_call_once_param { void (*func)(void); }; |
||||
static BOOL CALLBACK impl_call_once_callback(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) |
||||
{ |
||||
struct impl_call_once_param *param = (struct impl_call_once_param*)Parameter; |
||||
(param->func)(); |
||||
((void)InitOnce); ((void)Context); // suppress warning
|
||||
return TRUE; |
||||
} |
||||
#endif // ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE
|
||||
|
||||
#ifndef EMULATED_THREADS_USE_NATIVE_CV |
||||
/*
|
||||
Note: |
||||
The implementation of condition variable is ported from Boost.Interprocess |
||||
See http://www.boost.org/boost/interprocess/sync/windows/condition.hpp
|
||||
*/ |
||||
static void impl_cond_do_signal(cnd_t *cond, int broadcast) |
||||
{ |
||||
int nsignal = 0; |
||||
|
||||
EnterCriticalSection(&cond->monitor); |
||||
if (cond->to_unblock != 0) { |
||||
if (cond->blocked == 0) { |
||||
LeaveCriticalSection(&cond->monitor); |
||||
return; |
||||
} |
||||
if (broadcast) { |
||||
cond->to_unblock += nsignal = cond->blocked; |
||||
cond->blocked = 0; |
||||
} else { |
||||
nsignal = 1; |
||||
cond->to_unblock++; |
||||
cond->blocked--; |
||||
} |
||||
} else if (cond->blocked > cond->gone) { |
||||
WaitForSingleObject(cond->sem_gate, INFINITE); |
||||
if (cond->gone != 0) { |
||||
cond->blocked -= cond->gone; |
||||
cond->gone = 0; |
||||
} |
||||
if (broadcast) { |
||||
nsignal = cond->to_unblock = cond->blocked; |
||||
cond->blocked = 0; |
||||
} else { |
||||
nsignal = cond->to_unblock = 1; |
||||
cond->blocked--; |
||||
} |
||||
} |
||||
LeaveCriticalSection(&cond->monitor); |
||||
|
||||
if (0 < nsignal) |
||||
ReleaseSemaphore(cond->sem_queue, nsignal, NULL); |
||||
} |
||||
|
||||
static int impl_cond_do_wait(cnd_t *cond, mtx_t *mtx, const xtime *xt) |
||||
{ |
||||
int nleft = 0; |
||||
int ngone = 0; |
||||
int timeout = 0; |
||||
DWORD w; |
||||
|
||||
WaitForSingleObject(cond->sem_gate, INFINITE); |
||||
cond->blocked++; |
||||
ReleaseSemaphore(cond->sem_gate, 1, NULL); |
||||
|
||||
mtx_unlock(mtx); |
||||
|
||||
w = WaitForSingleObject(cond->sem_queue, xt ? impl_xtime2msec(xt) : INFINITE); |
||||
timeout = (w == WAIT_TIMEOUT); |
||||
|
||||
EnterCriticalSection(&cond->monitor); |
||||
if ((nleft = cond->to_unblock) != 0) { |
||||
if (timeout) { |
||||
if (cond->blocked != 0) { |
||||
cond->blocked--; |
||||
} else { |
||||
cond->gone++; |
||||
} |
||||
} |
||||
if (--cond->to_unblock == 0) { |
||||
if (cond->blocked != 0) { |
||||
ReleaseSemaphore(cond->sem_gate, 1, NULL); |
||||
nleft = 0; |
||||
} |
||||
else if ((ngone = cond->gone) != 0) { |
||||
cond->gone = 0; |
||||
} |
||||
} |
||||
} else if (++cond->gone == INT_MAX/2) { |
||||
WaitForSingleObject(cond->sem_gate, INFINITE); |
||||
cond->blocked -= cond->gone; |
||||
ReleaseSemaphore(cond->sem_gate, 1, NULL); |
||||
cond->gone = 0; |
||||
} |
||||
LeaveCriticalSection(&cond->monitor); |
||||
|
||||
if (nleft == 1) { |
||||
while (ngone--) |
||||
WaitForSingleObject(cond->sem_queue, INFINITE); |
||||
ReleaseSemaphore(cond->sem_gate, 1, NULL); |
||||
} |
||||
|
||||
mtx_lock(mtx); |
||||
return timeout ? thrd_busy : thrd_success; |
||||
} |
||||
#endif // ifndef EMULATED_THREADS_USE_NATIVE_CV
|
||||
|
||||
static struct impl_tss_dtor_entry { |
||||
tss_t key; |
||||
tss_dtor_t dtor; |
||||
} impl_tss_dtor_tbl[EMULATED_THREADS_TSS_DTOR_SLOTNUM]; |
||||
|
||||
static int impl_tss_dtor_register(tss_t key, tss_dtor_t dtor) |
||||
{ |
||||
int i; |
||||
for (i = 0; i < EMULATED_THREADS_TSS_DTOR_SLOTNUM; i++) { |
||||
if (!impl_tss_dtor_tbl[i].dtor) |
||||
break; |
||||
} |
||||
if (i == EMULATED_THREADS_TSS_DTOR_SLOTNUM) |
||||
return 1; |
||||
impl_tss_dtor_tbl[i].key = key; |
||||
impl_tss_dtor_tbl[i].dtor = dtor; |
||||
return 0; |
||||
} |
||||
|
||||
static void impl_tss_dtor_invoke() |
||||
{ |
||||
int i; |
||||
for (i = 0; i < EMULATED_THREADS_TSS_DTOR_SLOTNUM; i++) { |
||||
if (impl_tss_dtor_tbl[i].dtor) { |
||||
void* val = tss_get(impl_tss_dtor_tbl[i].key); |
||||
if (val) |
||||
(impl_tss_dtor_tbl[i].dtor)(val); |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
/*--------------- 7.25.2 Initialization functions ---------------*/ |
||||
// 7.25.2.1
|
||||
static inline void |
||||
call_once(once_flag *flag, void (*func)(void)) |
||||
{ |
||||
assert(flag && func); |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE |
||||
{ |
||||
struct impl_call_once_param param; |
||||
param.func = func; |
||||
InitOnceExecuteOnce(flag, impl_call_once_callback, (PVOID)¶m, NULL); |
||||
} |
||||
#else |
||||
if (InterlockedCompareExchange(&flag->status, 1, 0) == 0) { |
||||
(func)(); |
||||
InterlockedExchange(&flag->status, 2); |
||||
} else { |
||||
while (flag->status == 1) { |
||||
// busy loop!
|
||||
thrd_yield(); |
||||
} |
||||
} |
||||
#endif |
||||
} |
||||
|
||||
|
||||
/*------------- 7.25.3 Condition variable functions -------------*/ |
||||
// 7.25.3.1
|
||||
static inline int |
||||
cnd_broadcast(cnd_t *cond) |
||||
{ |
||||
if (!cond) return thrd_error; |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
WakeAllConditionVariable(&cond->condvar); |
||||
#else |
||||
impl_cond_do_signal(cond, 1); |
||||
#endif |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.3.2
|
||||
static inline void |
||||
cnd_destroy(cnd_t *cond) |
||||
{ |
||||
assert(cond); |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
// do nothing
|
||||
#else |
||||
CloseHandle(cond->sem_queue); |
||||
CloseHandle(cond->sem_gate); |
||||
DeleteCriticalSection(&cond->monitor); |
||||
#endif |
||||
} |
||||
|
||||
// 7.25.3.3
|
||||
static inline int |
||||
cnd_init(cnd_t *cond) |
||||
{ |
||||
if (!cond) return thrd_error; |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
InitializeConditionVariable(&cond->condvar); |
||||
#else |
||||
cond->blocked = 0; |
||||
cond->gone = 0; |
||||
cond->to_unblock = 0; |
||||
cond->sem_queue = CreateSemaphore(NULL, 0, LONG_MAX, NULL); |
||||
cond->sem_gate = CreateSemaphore(NULL, 1, 1, NULL); |
||||
InitializeCriticalSection(&cond->monitor); |
||||
#endif |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.3.4
|
||||
static inline int |
||||
cnd_signal(cnd_t *cond) |
||||
{ |
||||
if (!cond) return thrd_error; |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
WakeConditionVariable(&cond->condvar); |
||||
#else |
||||
impl_cond_do_signal(cond, 0); |
||||
#endif |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.3.5
|
||||
static inline int |
||||
cnd_timedwait(cnd_t *cond, mtx_t *mtx, const xtime *xt) |
||||
{ |
||||
if (!cond || !mtx || !xt) return thrd_error; |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
if (SleepConditionVariableCS(&cond->condvar, mtx, impl_xtime2msec(xt))) |
||||
return thrd_success; |
||||
return (GetLastError() == ERROR_TIMEOUT) ? thrd_busy : thrd_error; |
||||
#else |
||||
return impl_cond_do_wait(cond, mtx, xt); |
||||
#endif |
||||
} |
||||
|
||||
// 7.25.3.6
|
||||
static inline int |
||||
cnd_wait(cnd_t *cond, mtx_t *mtx) |
||||
{ |
||||
if (!cond || !mtx) return thrd_error; |
||||
#ifdef EMULATED_THREADS_USE_NATIVE_CV |
||||
SleepConditionVariableCS(&cond->condvar, mtx, INFINITE); |
||||
#else |
||||
impl_cond_do_wait(cond, mtx, NULL); |
||||
#endif |
||||
return thrd_success; |
||||
} |
||||
|
||||
|
||||
/*-------------------- 7.25.4 Mutex functions --------------------*/ |
||||
// 7.25.4.1
|
||||
static inline void |
||||
mtx_destroy(mtx_t *mtx) |
||||
{ |
||||
assert(mtx); |
||||
DeleteCriticalSection(mtx); |
||||
} |
||||
|
||||
// 7.25.4.2
|
||||
static inline int |
||||
mtx_init(mtx_t *mtx, int type) |
||||
{ |
||||
if (!mtx) return thrd_error; |
||||
if (type != mtx_plain && type != mtx_timed && type != mtx_try |
||||
&& type != (mtx_plain|mtx_recursive) |
||||
&& type != (mtx_timed|mtx_recursive) |
||||
&& type != (mtx_try|mtx_recursive)) |
||||
return thrd_error; |
||||
InitializeCriticalSection(mtx); |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.4.3
|
||||
static inline int |
||||
mtx_lock(mtx_t *mtx) |
||||
{ |
||||
if (!mtx) return thrd_error; |
||||
EnterCriticalSection(mtx); |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.4.4
|
||||
static inline int |
||||
mtx_timedlock(mtx_t *mtx, const xtime *xt) |
||||
{ |
||||
time_t expire, now; |
||||
if (!mtx || !xt) return thrd_error; |
||||
expire = time(NULL); |
||||
expire += xt->sec; |
||||
while (mtx_trylock(mtx) != thrd_success) { |
||||
now = time(NULL); |
||||
if (expire < now) |
||||
return thrd_busy; |
||||
// busy loop!
|
||||
thrd_yield(); |
||||
} |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.4.5
|
||||
static inline int |
||||
mtx_trylock(mtx_t *mtx) |
||||
{ |
||||
if (!mtx) return thrd_error; |
||||
return TryEnterCriticalSection(mtx) ? thrd_success : thrd_busy; |
||||
} |
||||
|
||||
// 7.25.4.6
|
||||
static inline int |
||||
mtx_unlock(mtx_t *mtx) |
||||
{ |
||||
if (!mtx) return thrd_error; |
||||
LeaveCriticalSection(mtx); |
||||
return thrd_success; |
||||
} |
||||
|
||||
|
||||
/*------------------- 7.25.5 Thread functions -------------------*/ |
||||
// 7.25.5.1
|
||||
static inline int |
||||
thrd_create(thrd_t *thr, thrd_start_t func, void *arg) |
||||
{ |
||||
struct impl_thrd_param *pack; |
||||
uintptr_t handle; |
||||
if (!thr) return thrd_error; |
||||
pack = (struct impl_thrd_param *)malloc(sizeof(struct impl_thrd_param)); |
||||
if (!pack) return thrd_nomem; |
||||
pack->func = func; |
||||
pack->arg = arg; |
||||
handle = _beginthreadex(NULL, 0, impl_thrd_routine, pack, 0, NULL); |
||||
if (handle == 0) { |
||||
if (errno == EAGAIN || errno == EACCES) |
||||
return thrd_nomem; |
||||
return thrd_error; |
||||
} |
||||
*thr = (thrd_t)handle; |
||||
return thrd_success; |
||||
} |
||||
|
||||
#if 0 |
||||
// 7.25.5.2
|
||||
static inline thrd_t |
||||
thrd_current(void) |
||||
{ |
||||
HANDLE hCurrentThread; |
||||
BOOL bRet; |
||||
|
||||
/* GetCurrentThread() returns a pseudo-handle, which is useless. We need
|
||||
* to call DuplicateHandle to get a real handle. However the handle value |
||||
* will not match the one returned by thread_create. |
||||
* |
||||
* Other potential solutions would be: |
||||
* - define thrd_t as a thread Ids, but this would mean we'd need to OpenThread for many operations |
||||
* - use malloc'ed memory for thrd_t. This would imply using TLS for current thread. |
||||
* |
||||
* Neither is particularly nice. |
||||
* |
||||
* Life would be much easier if C11 threads had different abstractions for |
||||
* threads and thread IDs, just like C++11 threads does... |
||||
*/ |
||||
|
||||
bRet = DuplicateHandle(GetCurrentProcess(), // source process (pseudo) handle
|
||||
GetCurrentThread(), // source (pseudo) handle
|
||||
GetCurrentProcess(), // target process
|
||||
&hCurrentThread, // target handle
|
||||
0, |
||||
FALSE, |
||||
DUPLICATE_SAME_ACCESS); |
||||
assert(bRet); |
||||
if (!bRet) { |
||||
hCurrentThread = GetCurrentThread(); |
||||
} |
||||
return hCurrentThread; |
||||
} |
||||
#endif |
||||
|
||||
// 7.25.5.3
|
||||
static inline int |
||||
thrd_detach(thrd_t thr) |
||||
{ |
||||
CloseHandle(thr); |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.5.4
|
||||
static inline int |
||||
thrd_equal(thrd_t thr0, thrd_t thr1) |
||||
{ |
||||
return GetThreadId(thr0) == GetThreadId(thr1); |
||||
} |
||||
|
||||
// 7.25.5.5
|
||||
static inline void |
||||
thrd_exit(int res) |
||||
{ |
||||
impl_tss_dtor_invoke(); |
||||
_endthreadex((unsigned)res); |
||||
} |
||||
|
||||
// 7.25.5.6
|
||||
static inline int |
||||
thrd_join(thrd_t thr, int *res) |
||||
{ |
||||
DWORD w, code; |
||||
w = WaitForSingleObject(thr, INFINITE); |
||||
if (w != WAIT_OBJECT_0) |
||||
return thrd_error; |
||||
if (res) { |
||||
if (!GetExitCodeThread(thr, &code)) { |
||||
CloseHandle(thr); |
||||
return thrd_error; |
||||
} |
||||
*res = (int)code; |
||||
} |
||||
CloseHandle(thr); |
||||
return thrd_success; |
||||
} |
||||
|
||||
// 7.25.5.7
|
||||
static inline void |
||||
thrd_sleep(const xtime *xt) |
||||
{ |
||||
assert(xt); |
||||
Sleep(impl_xtime2msec(xt)); |
||||
} |
||||
|
||||
// 7.25.5.8
|
||||
static inline void |
||||
thrd_yield(void) |
||||
{ |
||||
SwitchToThread(); |
||||
} |
||||
|
||||
|
||||
/*----------- 7.25.6 Thread-specific storage functions -----------*/ |
||||
// 7.25.6.1
|
||||
static inline int |
||||
tss_create(tss_t *key, tss_dtor_t dtor) |
||||
{ |
||||
if (!key) return thrd_error; |
||||
*key = TlsAlloc(); |
||||
if (dtor) { |
||||
if (impl_tss_dtor_register(*key, dtor)) { |
||||
TlsFree(*key); |
||||
return thrd_error; |
||||
} |
||||
} |
||||
return (*key != 0xFFFFFFFF) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
// 7.25.6.2
|
||||
static inline void |
||||
tss_delete(tss_t key) |
||||
{ |
||||
TlsFree(key); |
||||
} |
||||
|
||||
// 7.25.6.3
|
||||
static inline void * |
||||
tss_get(tss_t key) |
||||
{ |
||||
return TlsGetValue(key); |
||||
} |
||||
|
||||
// 7.25.6.4
|
||||
static inline int |
||||
tss_set(tss_t key, void *val) |
||||
{ |
||||
return TlsSetValue(key, val) ? thrd_success : thrd_error; |
||||
} |
||||
|
||||
|
||||
/*-------------------- 7.25.7 Time functions --------------------*/ |
||||
// 7.25.6.1
|
||||
static inline int |
||||
xtime_get(xtime *xt, int base) |
||||
{ |
||||
if (!xt) return 0; |
||||
if (base == TIME_UTC) { |
||||
xt->sec = time(NULL); |
||||
xt->nsec = 0; |
||||
return base; |
||||
} |
||||
return 0; |
||||
} |
@ -0,0 +1,138 @@ |
||||
/**************************************************************************
|
||||
* |
||||
* Copyright 2007-2013 VMware, Inc. |
||||
* All Rights Reserved. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person obtaining a |
||||
* copy of this software and associated documentation files (the |
||||
* "Software"), to deal in the Software without restriction, including |
||||
* without limitation the rights to use, copy, modify, merge, publish, |
||||
* distribute, sub license, and/or sell copies of the Software, and to |
||||
* permit persons to whom the Software is furnished to do so, subject to |
||||
* the following conditions: |
||||
* |
||||
* The above copyright notice and this permission notice (including the |
||||
* next paragraph) shall be included in all copies or substantial portions |
||||
* of the Software. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
||||
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
||||
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||||
* |
||||
**************************************************************************/ |
||||
|
||||
#include "no_extern_c.h" |
||||
|
||||
#ifndef _C99_COMPAT_H_ |
||||
#define _C99_COMPAT_H_ |
||||
|
||||
|
||||
/*
|
||||
* MSVC hacks. |
||||
*/ |
||||
#if defined(_MSC_VER) |
||||
|
||||
# if _MSC_VER < 1500 |
||||
# error "Microsoft Visual Studio 2008 or higher required" |
||||
# endif |
||||
|
||||
/*
|
||||
* Visual Studio 2012 will complain if we define the `inline` keyword, but |
||||
* actually it only supports the keyword on C++. |
||||
* |
||||
* To avoid this the _ALLOW_KEYWORD_MACROS must be set. |
||||
*/ |
||||
# if (_MSC_VER >= 1700) && !defined(_ALLOW_KEYWORD_MACROS) |
||||
# define _ALLOW_KEYWORD_MACROS |
||||
# endif |
||||
|
||||
/*
|
||||
* XXX: MSVC has a `__restrict` keyword, but it also has a |
||||
* `__declspec(restrict)` modifier, so it is impossible to define a |
||||
* `restrict` macro without interfering with the latter. Furthermore the |
||||
* MSVC standard library uses __declspec(restrict) under the _CRTRESTRICT |
||||
* macro. For now resolve this issue by redefining _CRTRESTRICT, but going |
||||
* forward we should probably should stop using restrict, especially |
||||
* considering that our code does not obbey strict aliasing rules any way. |
||||
*/ |
||||
# include <crtdefs.h> |
||||
# undef _CRTRESTRICT |
||||
# define _CRTRESTRICT |
||||
#endif |
||||
|
||||
|
||||
/*
|
||||
* C99 inline keyword |
||||
*/ |
||||
#ifndef inline |
||||
# ifdef __cplusplus |
||||
/* C++ supports inline keyword */ |
||||
# elif defined(__GNUC__) |
||||
# define inline __inline__ |
||||
# elif defined(_MSC_VER) |
||||
# define inline __inline |
||||
# elif defined(__ICL) |
||||
# define inline __inline |
||||
# elif defined(__INTEL_COMPILER) |
||||
/* Intel compiler supports inline keyword */ |
||||
# elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100) |
||||
# define inline __inline |
||||
# elif (__STDC_VERSION__ >= 199901L) |
||||
/* C99 supports inline keyword */ |
||||
# else |
||||
# define inline |
||||
# endif |
||||
#endif |
||||
|
||||
|
||||
/*
|
||||
* C99 restrict keyword |
||||
* |
||||
* See also: |
||||
* - http://cellperformance.beyond3d.com/articles/2006/05/demystifying-the-restrict-keyword.html
|
||||
*/ |
||||
#ifndef restrict |
||||
# if (__STDC_VERSION__ >= 199901L) |
||||
/* C99 */ |
||||
# elif defined(__GNUC__) |
||||
# define restrict __restrict__ |
||||
# elif defined(_MSC_VER) |
||||
# define restrict __restrict |
||||
# else |
||||
# define restrict /* */ |
||||
# endif |
||||
#endif |
||||
|
||||
|
||||
/*
|
||||
* C99 __func__ macro |
||||
*/ |
||||
#ifndef __func__ |
||||
# if (__STDC_VERSION__ >= 199901L) |
||||
/* C99 */ |
||||
# elif defined(__GNUC__) |
||||
# define __func__ __FUNCTION__ |
||||
# elif defined(_MSC_VER) |
||||
# define __func__ __FUNCTION__ |
||||
# else |
||||
# define __func__ "<unknown>" |
||||
# endif |
||||
#endif |
||||
|
||||
|
||||
/* Simple test case for debugging */ |
||||
#if 0 |
||||
static inline const char * |
||||
test_c99_compat_h(const void * restrict a, |
||||
const void * restrict b) |
||||
{ |
||||
return __func__; |
||||
} |
||||
#endif |
||||
|
||||
|
||||
#endif /* _C99_COMPAT_H_ */ |
@ -0,0 +1,48 @@ |
||||
/**************************************************************************
|
||||
* |
||||
* Copyright 2014 VMware, Inc. |
||||
* All Rights Reserved. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person obtaining a |
||||
* copy of this software and associated documentation files (the "Software"), |
||||
* to deal in the Software without restriction, including without limitation |
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
* and/or sell copies of the Software, and to permit persons to whom the |
||||
* Software is furnished to do so, subject to the following conditions: |
||||
* |
||||
* The above copyright notice and this permission notice shall be included |
||||
* in all copies or substantial portions of the Software. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
||||
* OTHER DEALINGS IN THE SOFTWARE. |
||||
* |
||||
**************************************************************************/ |
||||
|
||||
|
||||
/*
|
||||
* Including system's headers inside `extern "C" { ... }` is not safe, as system |
||||
* headers may have C++ code in them, and C++ code inside extern "C" |
||||
* leads to syntatically incorrect code. |
||||
* |
||||
* This is because putting code inside extern "C" won't make __cplusplus define |
||||
* go away, that is, the system header being included thinks is free to use C++ |
||||
* as it sees fits. |
||||
* |
||||
* Including non-system headers inside extern "C" is not safe either, because |
||||
* non-system headers end up including system headers, hence fall in the above |
||||
* case too. |
||||
* |
||||
* Conclusion, includes inside extern "C" is simply not portable. |
||||
* |
||||
* |
||||
* This header helps surface these issues. |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
template<class T> class _IncludeInsideExternCNotPortable; |
||||
#endif |
Loading…
Reference in new issue