mirror of
https://github.com/yuzu-emu/ext-boost.git
synced 2025-01-05 18:55:34 +00:00
294 lines
10 KiB
C++
294 lines
10 KiB
C++
// synchronizaion.hpp --------------------------------------------------------------//
|
|
|
|
// Copyright 2010 Vicente J. Botet Escriba
|
|
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// See http://www.boost.org/LICENSE_1_0.txt
|
|
|
|
|
|
#ifndef BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP
|
|
#define BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP
|
|
|
|
#include <boost/detail/winapi/basic_types.hpp>
|
|
|
|
#ifdef BOOST_HAS_PRAGMA_ONCE
|
|
#pragma once
|
|
#endif
|
|
|
|
namespace boost
|
|
{
|
|
namespace detail
|
|
{
|
|
namespace winapi
|
|
{
|
|
#if defined( BOOST_USE_WINDOWS_H )
|
|
typedef ::CRITICAL_SECTION CRITICAL_SECTION_;
|
|
typedef ::PAPCFUNC PAPCFUNC_;
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
typedef ::INIT_ONCE INIT_ONCE_;
|
|
typedef ::PINIT_ONCE PINIT_ONCE_;
|
|
typedef ::LPINIT_ONCE LPINIT_ONCE_;
|
|
#define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT INIT_ONCE_STATIC_INIT
|
|
typedef ::PINIT_ONCE_FN PINIT_ONCE_FN_;
|
|
|
|
typedef ::SRWLOCK SRWLOCK_;
|
|
typedef ::PSRWLOCK PSRWLOCK_;
|
|
#define BOOST_DETAIL_WINAPI_SRWLOCK_INIT SRWLOCK_INIT
|
|
|
|
typedef ::CONDITION_VARIABLE CONDITION_VARIABLE_;
|
|
typedef ::PCONDITION_VARIABLE PCONDITION_VARIABLE_;
|
|
#define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT CONDITION_VARIABLE_INIT
|
|
#endif
|
|
|
|
using ::InitializeCriticalSection;
|
|
#if BOOST_USE_WINAPI_VERSION >= 0x0403
|
|
using ::InitializeCriticalSectionAndSpinCount;
|
|
#endif
|
|
using ::EnterCriticalSection;
|
|
using ::TryEnterCriticalSection;
|
|
using ::LeaveCriticalSection;
|
|
using ::DeleteCriticalSection;
|
|
|
|
# ifdef BOOST_NO_ANSI_APIS
|
|
using ::CreateMutexW;
|
|
using ::OpenMutexW;
|
|
using ::CreateEventW;
|
|
using ::OpenEventW;
|
|
using ::CreateSemaphoreW;
|
|
using ::OpenSemaphoreW;
|
|
# else
|
|
using ::CreateMutexA;
|
|
using ::OpenMutexA;
|
|
using ::CreateEventA;
|
|
using ::OpenEventA;
|
|
using ::CreateSemaphoreA;
|
|
using ::OpenSemaphoreA;
|
|
# endif
|
|
using ::ReleaseMutex;
|
|
using ::ReleaseSemaphore;
|
|
using ::SetEvent;
|
|
using ::ResetEvent;
|
|
using ::WaitForMultipleObjects;
|
|
using ::WaitForSingleObject;
|
|
using ::QueueUserAPC;
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
using ::InitOnceInitialize;
|
|
using ::InitOnceExecuteOnce;
|
|
using ::InitOnceBeginInitialize;
|
|
using ::InitOnceComplete;
|
|
|
|
using ::InitializeSRWLock;
|
|
using ::AcquireSRWLockExclusive;
|
|
using ::TryAcquireSRWLockExclusive;
|
|
using ::ReleaseSRWLockExclusive;
|
|
using ::AcquireSRWLockShared;
|
|
using ::TryAcquireSRWLockShared;
|
|
using ::ReleaseSRWLockShared;
|
|
|
|
using ::InitializeConditionVariable;
|
|
using ::WakeConditionVariable;
|
|
using ::WakeAllConditionVariable;
|
|
using ::SleepConditionVariableCS;
|
|
using ::SleepConditionVariableSRW;
|
|
#endif
|
|
|
|
const DWORD_ infinite = INFINITE;
|
|
const DWORD_ wait_abandoned = WAIT_ABANDONED;
|
|
const DWORD_ wait_object_0 = WAIT_OBJECT_0;
|
|
const DWORD_ wait_timeout = WAIT_TIMEOUT;
|
|
const DWORD_ wait_failed = WAIT_FAILED;
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
const DWORD_ init_once_async = INIT_ONCE_ASYNC;
|
|
const DWORD_ init_once_check_only = INIT_ONCE_CHECK_ONLY;
|
|
const DWORD_ init_once_init_failed = INIT_ONCE_INIT_FAILED;
|
|
const DWORD_ init_once_ctx_reserved_bits = INIT_ONCE_CTX_RESERVED_BITS;
|
|
|
|
const ULONG_ condition_variable_lockmode_shared = CONDITION_VARIABLE_LOCKMODE_SHARED;
|
|
#endif
|
|
|
|
#else // defined( BOOST_USE_WINDOWS_H )
|
|
|
|
extern "C" {
|
|
|
|
typedef struct CRITICAL_SECTION_
|
|
{
|
|
struct critical_section_debug * DebugInfo;
|
|
long LockCount;
|
|
long RecursionCount;
|
|
void * OwningThread;
|
|
void * LockSemaphore;
|
|
#if defined(_WIN64)
|
|
unsigned __int64 SpinCount;
|
|
#else
|
|
unsigned long SpinCount;
|
|
#endif
|
|
}
|
|
*PCRITICAL_SECTION_;
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
typedef union INIT_ONCE_
|
|
{
|
|
PVOID_ Ptr;
|
|
}
|
|
*PINIT_ONCE_, *LPINIT_ONCE_;
|
|
#define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT {0}
|
|
typedef BOOL_ (WINAPI *PINIT_ONCE_FN_)(PINIT_ONCE_ InitOnce, PVOID_ Parameter, PVOID_ *Context);
|
|
|
|
typedef struct SRWLOCK_
|
|
{
|
|
PVOID_ Ptr;
|
|
}
|
|
* PSRWLOCK_;
|
|
#define BOOST_DETAIL_WINAPI_SRWLOCK_INIT {0}
|
|
|
|
typedef struct CONDITION_VARIABLE_
|
|
{
|
|
PVOID_ Ptr;
|
|
}
|
|
* PCONDITION_VARIABLE_;
|
|
#define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT {0}
|
|
|
|
#endif
|
|
|
|
__declspec(dllimport) void WINAPI
|
|
InitializeCriticalSection(PCRITICAL_SECTION_);
|
|
#if BOOST_USE_WINAPI_VERSION >= 0x0403
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION_* lpCS, DWORD_ dwSpinCount);
|
|
#endif
|
|
__declspec(dllimport) void WINAPI
|
|
EnterCriticalSection(PCRITICAL_SECTION_);
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
TryEnterCriticalSection(PCRITICAL_SECTION_);
|
|
__declspec(dllimport) void WINAPI
|
|
LeaveCriticalSection(PCRITICAL_SECTION_);
|
|
__declspec(dllimport) void WINAPI
|
|
DeleteCriticalSection(PCRITICAL_SECTION_);
|
|
|
|
struct _SECURITY_ATTRIBUTES;
|
|
# ifdef BOOST_NO_ANSI_APIS
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateMutexW(_SECURITY_ATTRIBUTES*, BOOL_, LPCWSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenMutexW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateSemaphoreW(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCWSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenSemaphoreW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateEventW(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCWSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenEventW(DWORD_, BOOL_, LPCWSTR_);
|
|
# else
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateMutexA(_SECURITY_ATTRIBUTES*, BOOL_, LPCSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenMutexA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateSemaphoreA(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenSemaphoreA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
CreateEventA(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCSTR_);
|
|
__declspec(dllimport) HANDLE_ WINAPI
|
|
OpenEventA(DWORD_, BOOL_, LPCSTR_);
|
|
# endif
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
ReleaseMutex(HANDLE_);
|
|
__declspec(dllimport) DWORD_ WINAPI
|
|
WaitForSingleObject(HANDLE_, DWORD_);
|
|
__declspec(dllimport) DWORD_ WINAPI
|
|
WaitForMultipleObjects(DWORD_ nCount,
|
|
HANDLE_ const * lpHandles,
|
|
BOOL_ bWaitAll,
|
|
DWORD_ dwMilliseconds);
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
ReleaseSemaphore(HANDLE_, LONG_, LONG_*);
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
SetEvent(HANDLE_);
|
|
__declspec(dllimport) BOOL_ WINAPI
|
|
ResetEvent(HANDLE_);
|
|
|
|
typedef void (__stdcall *PAPCFUNC_)(ULONG_PTR_);
|
|
__declspec(dllimport) DWORD_ WINAPI
|
|
QueueUserAPC(PAPCFUNC_, HANDLE_, ULONG_PTR_);
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
__declspec(dllimport) void WINAPI InitOnceInitialize(PINIT_ONCE_);
|
|
__declspec(dllimport) BOOL_ WINAPI InitOnceExecuteOnce(PINIT_ONCE_ InitOnce, PINIT_ONCE_FN_ InitFn, PVOID_ Parameter, LPVOID_* Context);
|
|
__declspec(dllimport) BOOL_ WINAPI InitOnceBeginInitialize(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, BOOL_* fPending, LPVOID_* lpContext);
|
|
__declspec(dllimport) BOOL_ WINAPI InitOnceComplete(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, LPVOID_* lpContext);
|
|
|
|
|
|
__declspec(dllimport) void WINAPI InitializeSRWLock(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) void WINAPI AcquireSRWLockExclusive(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockExclusive(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) void WINAPI ReleaseSRWLockExclusive(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) void WINAPI AcquireSRWLockShared(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockShared(PSRWLOCK_ SRWLock);
|
|
__declspec(dllimport) void WINAPI ReleaseSRWLockShared(PSRWLOCK_ SRWLock);
|
|
|
|
__declspec(dllimport) void WINAPI InitializeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
|
|
__declspec(dllimport) void WINAPI WakeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
|
|
__declspec(dllimport) void WINAPI WakeAllConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
|
|
__declspec(dllimport) BOOL_ WINAPI SleepConditionVariableCS(PCONDITION_VARIABLE_ ConditionVariable, PCRITICAL_SECTION_ CriticalSection, DWORD_ dwMilliseconds);
|
|
__declspec(dllimport) BOOL_ WINAPI SleepConditionVariableSRW(PCONDITION_VARIABLE_ ConditionVariable, PSRWLOCK_ SRWLock, DWORD_ dwMilliseconds, ULONG_ Flags);
|
|
#endif
|
|
|
|
} // extern "C"
|
|
|
|
const DWORD_ infinite = (DWORD_)0xFFFFFFFF;
|
|
const DWORD_ wait_abandoned = 0x00000080L;
|
|
const DWORD_ wait_object_0 = 0x00000000L;
|
|
const DWORD_ wait_timeout = 0x00000102L;
|
|
const DWORD_ wait_failed = (DWORD_)0xFFFFFFFF;
|
|
|
|
#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
|
|
const DWORD_ init_once_async = 0x00000002UL;
|
|
const DWORD_ init_once_check_only = 0x00000001UL;
|
|
const DWORD_ init_once_init_failed = 0x00000004UL;
|
|
const DWORD_ init_once_ctx_reserved_bits = 2;
|
|
|
|
const ULONG_ condition_variable_lockmode_shared = 0x00000001;
|
|
#endif
|
|
|
|
#endif // defined( BOOST_USE_WINDOWS_H )
|
|
|
|
const DWORD_ max_non_infinite_wait = (DWORD_)0xFFFFFFFE;
|
|
|
|
BOOST_FORCEINLINE HANDLE_ create_anonymous_mutex(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bInitialOwner)
|
|
{
|
|
#ifdef BOOST_NO_ANSI_APIS
|
|
return CreateMutexW(lpAttributes, bInitialOwner, 0);
|
|
#else
|
|
return CreateMutexA(lpAttributes, bInitialOwner, 0);
|
|
#endif
|
|
}
|
|
|
|
BOOST_FORCEINLINE HANDLE_ create_anonymous_semaphore(_SECURITY_ATTRIBUTES* lpAttributes, LONG_ lInitialCount, LONG_ lMaximumCount)
|
|
{
|
|
#ifdef BOOST_NO_ANSI_APIS
|
|
return CreateSemaphoreW(lpAttributes, lInitialCount, lMaximumCount, 0);
|
|
#else
|
|
return CreateSemaphoreA(lpAttributes, lInitialCount, lMaximumCount, 0);
|
|
#endif
|
|
}
|
|
|
|
BOOST_FORCEINLINE HANDLE_ create_anonymous_event(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bManualReset, BOOL_ bInitialState)
|
|
{
|
|
#ifdef BOOST_NO_ANSI_APIS
|
|
return CreateEventW(lpAttributes, bManualReset, bInitialState, 0);
|
|
#else
|
|
return CreateEventA(lpAttributes, bManualReset, bInitialState, 0);
|
|
#endif
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP
|