Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 349 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/synchapi.rs b/vendor/winapi/src/um/synchapi.rs
new file mode 100644
index 0000000..205579e
--- /dev/null
+++ b/vendor/winapi/src/um/synchapi.rs
@@ -0,0 +1,349 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! ApiSet Contract for api-ms-win-core-synch-l1
+use shared::basetsd::SIZE_T;
+use shared::minwindef::{BOOL, DWORD, LPLONG, LPVOID, PBOOL, ULONG};
+use um::minwinbase::{
+    LPCRITICAL_SECTION, LPSECURITY_ATTRIBUTES, PCRITICAL_SECTION, PREASON_CONTEXT,
+};
+use um::winnt::{
+    BOOLEAN, HANDLE, LARGE_INTEGER, LONG, LPCSTR, LPCWSTR, PRTL_BARRIER, PRTL_RUN_ONCE,
+    PVOID, RTL_BARRIER, RTL_CONDITION_VARIABLE, RTL_CONDITION_VARIABLE_INIT,
+    RTL_RUN_ONCE, RTL_SRWLOCK, RTL_SRWLOCK_INIT, VOID
+};
+pub const SRWLOCK_INIT: SRWLOCK = RTL_SRWLOCK_INIT;
+pub type SRWLOCK = RTL_SRWLOCK;
+pub type PSRWLOCK = *mut RTL_SRWLOCK;
+extern "system" {
+    pub fn InitializeSRWLock(
+        SRWLock: PSRWLOCK,
+    );
+    pub fn ReleaseSRWLockExclusive(
+        SRWLock: PSRWLOCK,
+    );
+    pub fn ReleaseSRWLockShared(
+        SRWLock: PSRWLOCK,
+    );
+    pub fn AcquireSRWLockExclusive(
+        SRWLock: PSRWLOCK,
+    );
+    pub fn AcquireSRWLockShared(
+        SRWLock: PSRWLOCK,
+    );
+    pub fn TryAcquireSRWLockExclusive(
+        SRWLock: PSRWLOCK,
+    ) -> BOOLEAN;
+    pub fn TryAcquireSRWLockShared(
+        SRWLock: PSRWLOCK,
+    ) -> BOOLEAN;
+    pub fn InitializeCriticalSection(
+        lpCriticalSection: LPCRITICAL_SECTION,
+    );
+    pub fn EnterCriticalSection(
+        lpCriticalSection: LPCRITICAL_SECTION,
+    );
+    pub fn LeaveCriticalSection(
+        lpCriticalSection: LPCRITICAL_SECTION,
+    );
+    pub fn InitializeCriticalSectionAndSpinCount(
+        lpCriticalSection: LPCRITICAL_SECTION,
+        dwSpinCount: DWORD,
+    ) -> BOOL;
+    pub fn InitializeCriticalSectionEx(
+        lpCriticalSection: LPCRITICAL_SECTION,
+        dwSpinCount: DWORD,
+        Flags: DWORD,
+    ) -> BOOL;
+    pub fn SetCriticalSectionSpinCount(
+        lpCriticalSection: LPCRITICAL_SECTION,
+        dwSpinCount: DWORD,
+    ) -> DWORD;
+    pub fn TryEnterCriticalSection(
+        lpCriticalSection: LPCRITICAL_SECTION,
+    ) -> BOOL;
+    pub fn DeleteCriticalSection(
+        lpCriticalSection: LPCRITICAL_SECTION,
+    );
+}
+pub type INIT_ONCE = RTL_RUN_ONCE;
+pub type PINIT_ONCE = PRTL_RUN_ONCE;
+pub type LPINIT_ONCE = PRTL_RUN_ONCE;
+//pub const INIT_ONCE_STATIC_INIT: INIT_ONCE = RTL_RUN_ONCE_INIT;
+//pub const INIT_ONCE_CHECK_ONLY: ULONG = RTL_RUN_ONCE_CHECK_ONLY;
+//pub const INIT_ONCE_ASYNC: ULONG = RTL_RUN_ONCE_ASYNC;
+//pub const INIT_ONCE_INIT_FAILED: ULONG = RTL_RUN_ONCE_INIT_FAILED;
+//pub const INIT_ONCE_CTX_RESERVED_BITS: usize = RTL_RUN_ONCE_CTX_RESERVED_BITS;
+FN!{stdcall PINIT_ONCE_FN(
+    InitOnce: PINIT_ONCE,
+    Parameter: PVOID,
+    Context: *mut PVOID,
+) -> BOOL}
+extern "system" {
+    pub fn InitOnceInitialize(
+        InitOnce: PINIT_ONCE,
+    );
+    pub fn InitOnceExecuteOnce(
+        InitOnce: PINIT_ONCE,
+        InitFn: PINIT_ONCE_FN,
+        Parameter: PVOID,
+        Context: *mut LPVOID,
+    ) -> BOOL;
+    pub fn InitOnceBeginInitialize(
+        lpInitOnce: LPINIT_ONCE,
+        dwFlags: DWORD,
+        fPending: PBOOL,
+        lpContext: *mut LPVOID,
+    ) -> BOOL;
+    pub fn InitOnceComplete(
+        lpInitOnce: LPINIT_ONCE,
+        dwFlags: DWORD,
+        lpContext: LPVOID,
+    ) -> BOOL;
+}
+pub type CONDITION_VARIABLE = RTL_CONDITION_VARIABLE;
+pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
+pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = RTL_CONDITION_VARIABLE_INIT;
+//pub const CONDITION_VARIABLE_LOCKMODE_SHARED: ULONG = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED;
+extern "system" {
+    pub fn InitializeConditionVariable(
+        ConditionVariable: PCONDITION_VARIABLE,
+    );
+    pub fn WakeConditionVariable(
+        ConditionVariable: PCONDITION_VARIABLE,
+    );
+    pub fn WakeAllConditionVariable(
+        ConditionVariable: PCONDITION_VARIABLE,
+    );
+    pub fn SleepConditionVariableCS(
+        ConditionVariable: PCONDITION_VARIABLE,
+        CriticalSection: PCRITICAL_SECTION,
+        dwMilliseconds: DWORD,
+    ) -> BOOL;
+    pub fn SleepConditionVariableSRW(
+        ConditionVariable: PCONDITION_VARIABLE,
+        SRWLock: PSRWLOCK,
+        dwMilliseconds: DWORD,
+        Flags: ULONG,
+    ) -> BOOL;
+    pub fn SetEvent(
+        hEvent: HANDLE,
+    ) -> BOOL;
+    pub fn ResetEvent(
+        hEvent: HANDLE,
+    ) -> BOOL;
+    pub fn ReleaseSemaphore(
+        hSemaphore: HANDLE,
+        lReleaseCount: LONG,
+        lpPreviousCount: LPLONG,
+    ) -> BOOL;
+    pub fn ReleaseMutex(
+        hMutex: HANDLE,
+    ) -> BOOL;
+    pub fn WaitForSingleObject(
+        hHandle: HANDLE,
+        dwMilliseconds: DWORD,
+    ) -> DWORD;
+    pub fn SleepEx(
+        dwMilliseconds: DWORD,
+        bAlertable: BOOL,
+    ) -> DWORD;
+    pub fn WaitForSingleObjectEx(
+        hHandle: HANDLE,
+        dwMilliseconds: DWORD,
+        bAlertable: BOOL,
+    ) -> DWORD;
+    pub fn WaitForMultipleObjectsEx(
+        nCount: DWORD,
+        lpHandles: *const HANDLE,
+        bWaitAll: BOOL,
+        dwMilliseconds: DWORD,
+        bAlertable: BOOL,
+    ) -> DWORD;
+}
+//pub const MUTEX_MODIFY_STATE: DWORD = MUTANT_QUERY_STATE;
+//pub const MUTEX_ALL_ACCESS: DWORD = MUTANT_ALL_ACCESS;
+extern "system" {
+    pub fn CreateMutexA(
+        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
+        bInitialOwner: BOOL,
+        lpName: LPCSTR,
+    ) -> HANDLE;
+    pub fn CreateMutexW(
+        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
+        bInitialOwner: BOOL,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn OpenMutexW(
+        dwDesiredAccess: DWORD,
+        bInheritHandle: BOOL,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn CreateEventA(
+        lpEventAttributes: LPSECURITY_ATTRIBUTES,
+        bManualReset: BOOL,
+        bInitialState: BOOL,
+        lpName: LPCSTR,
+    ) -> HANDLE;
+    pub fn CreateEventW(
+        lpEventAttributes: LPSECURITY_ATTRIBUTES,
+        bManualReset: BOOL,
+        bInitialState: BOOL,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn OpenEventA(
+        dwDesiredAccess: DWORD,
+        bInheritHandle: BOOL,
+        lpName: LPCSTR,
+    ) -> HANDLE;
+    pub fn OpenEventW(
+        dwDesiredAccess: DWORD,
+        bInheritHandle: BOOL,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn OpenSemaphoreW(
+        dwDesiredAccess: DWORD,
+        bInheritHandle: BOOL,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+}
+FN!{stdcall PTIMERAPCROUTINE(
+    lpArgToCompletionRoutine: LPVOID,
+    dwTimerLowValue: DWORD,
+    dwTimerHighValue: DWORD,
+) -> ()}
+extern "system" {
+    pub fn OpenWaitableTimerW(
+        dwDesiredAccess: DWORD,
+        bInheritHandle: BOOL,
+        lpTimerName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn SetWaitableTimerEx(
+        hTimer: HANDLE,
+        lpDueTime: *const LARGE_INTEGER,
+        lPeriod: LONG,
+        pfnCompletionRoutine: PTIMERAPCROUTINE,
+        lpArgToCompletionRoutine: LPVOID,
+        WakeContext: PREASON_CONTEXT,
+        TolerableDelay: ULONG,
+    ) -> BOOL;
+    pub fn SetWaitableTimer(
+        hTimer: HANDLE,
+        lpDueTime: *const LARGE_INTEGER,
+        lPeriod: LONG,
+        pfnCompletionRoutine: PTIMERAPCROUTINE,
+        lpArgToCompletionRoutine: LPVOID,
+        fResume: BOOL,
+    ) -> BOOL;
+    pub fn CancelWaitableTimer(
+        hTimer: HANDLE,
+    ) -> BOOL;
+}
+pub const CREATE_MUTEX_INITIAL_OWNER: DWORD = 0x00000001;
+extern "system" {
+    pub fn CreateMutexExA(
+        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
+        lpName: LPCSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+    pub fn CreateMutexExW(
+        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
+        lpName: LPCWSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+}
+pub const CREATE_EVENT_MANUAL_RESET: DWORD = 0x00000001;
+pub const CREATE_EVENT_INITIAL_SET: DWORD = 0x00000002;
+extern "system" {
+    pub fn CreateEventExA(
+        lpEventAttributes: LPSECURITY_ATTRIBUTES,
+        lpName: LPCSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+    pub fn CreateEventExW(
+        lpEventAttributes: LPSECURITY_ATTRIBUTES,
+        lpName: LPCWSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+    pub fn CreateSemaphoreExW(
+        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
+        lInitialCount: LONG,
+        lMaximumCount: LONG,
+        lpName: LPCWSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+}
+pub const CREATE_WAITABLE_TIMER_MANUAL_RESET: DWORD = 0x00000001;
+extern "system" {
+    pub fn CreateWaitableTimerExW(
+        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
+        lpTimerName: LPCWSTR,
+        dwFlags: DWORD,
+        dwDesiredAccess: DWORD,
+    ) -> HANDLE;
+}
+pub type SYNCHRONIZATION_BARRIER = RTL_BARRIER;
+pub type PSYNCHRONIZATION_BARRIER = PRTL_BARRIER;
+pub type LPSYNCHRONIZATION_BARRIER = PRTL_BARRIER;
+pub const SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY: DWORD = 0x01;
+pub const SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY: DWORD = 0x02;
+pub const SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE: DWORD = 0x04;
+extern "system" {
+    pub fn EnterSynchronizationBarrier(
+        lpBarrier: LPSYNCHRONIZATION_BARRIER,
+        dwFlags: DWORD,
+    ) -> BOOL;
+    pub fn InitializeSynchronizationBarrier(
+        lpBarrier: LPSYNCHRONIZATION_BARRIER,
+        lTotalThreads: LONG,
+        lSpinCount: LONG,
+    ) -> BOOL;
+    pub fn DeleteSynchronizationBarrier(
+        lpBarrier: LPSYNCHRONIZATION_BARRIER,
+    ) -> BOOL;
+    pub fn Sleep(
+        dwMilliseconds: DWORD,
+    );
+    pub fn WaitOnAddress(
+        Address: *mut VOID,
+        CompareAddress: PVOID,
+        AddressSize: SIZE_T,
+        dwMilliseconds: DWORD,
+    ) -> BOOL;
+    pub fn WakeByAddressSingle(
+        Address: PVOID,
+    );
+    pub fn WakeByAddressAll(
+        Address: PVOID,
+    );
+    pub fn SignalObjectAndWait(
+        hObjectToSignal: HANDLE,
+        hObjectToWaitOn: HANDLE,
+        dwMilliseconds: DWORD,
+        bAlertable: BOOL,
+    ) -> DWORD;
+    pub fn WaitForMultipleObjects(
+        nCount: DWORD,
+        lpHandles: *const HANDLE,
+        bWaitAll: BOOL,
+        dwMilliseconds: DWORD,
+    ) -> DWORD;
+    pub fn CreateSemaphoreW(
+        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
+        lInitialCount: LONG,
+        lMaximumCount: LONG,
+        lpName: LPCWSTR,
+    ) -> HANDLE;
+    pub fn CreateWaitableTimerW(
+        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
+        bManualReset: BOOL,
+        lpTimerName: LPCWSTR,
+    ) -> HANDLE;
+}