From 2c9156e2c18c9789c79e34bae296914e6aeca66e Mon Sep 17 00:00:00 2001 From: Jon Lipstate Date: Tue, 4 Apr 2023 23:57:52 -0700 Subject: [PATCH] repaired autoformatter --- core/sys/windows/kernel32.odin | 903 ++++++++++++++++++++++++--------- 1 file changed, 660 insertions(+), 243 deletions(-) diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin index 37cb25d3b..ae21654b4 100644 --- a/core/sys/windows/kernel32.odin +++ b/core/sys/windows/kernel32.odin @@ -3,53 +3,75 @@ package sys_windows foreign import kernel32 "system:Kernel32.lib" -FOREGROUND_BLUE :: WORD(0x0001) -FOREGROUND_GREEN :: WORD(0x0002) -FOREGROUND_RED :: WORD(0x0004) -FOREGROUND_INTENSITY :: WORD(0x0008) -BACKGROUND_BLUE :: WORD(0x0010) -BACKGROUND_GREEN :: WORD(0x0020) -BACKGROUND_RED :: WORD(0x0040) -BACKGROUND_INTENSITY :: WORD(0x0080) -COMMON_LVB_LEADING_BYTE :: WORD(0x0100) -COMMON_LVB_TRAILING_BYTE :: WORD(0x0200) +FOREGROUND_BLUE :: WORD(0x0001) +FOREGROUND_GREEN :: WORD(0x0002) +FOREGROUND_RED :: WORD(0x0004) +FOREGROUND_INTENSITY :: WORD(0x0008) +BACKGROUND_BLUE :: WORD(0x0010) +BACKGROUND_GREEN :: WORD(0x0020) +BACKGROUND_RED :: WORD(0x0040) +BACKGROUND_INTENSITY :: WORD(0x0080) +COMMON_LVB_LEADING_BYTE :: WORD(0x0100) +COMMON_LVB_TRAILING_BYTE :: WORD(0x0200) COMMON_LVB_GRID_HORIZONTAL :: WORD(0x0400) -COMMON_LVB_GRID_LVERTICAL :: WORD(0x0800) -COMMON_LVB_GRID_RVERTICAL :: WORD(0x1000) -COMMON_LVB_REVERSE_VIDEO :: WORD(0x4000) -COMMON_LVB_UNDERSCORE :: WORD(0x8000) -COMMON_LVB_SBCSDBCS :: WORD(0x0300) +COMMON_LVB_GRID_LVERTICAL :: WORD(0x0800) +COMMON_LVB_GRID_RVERTICAL :: WORD(0x1000) +COMMON_LVB_REVERSE_VIDEO :: WORD(0x4000) +COMMON_LVB_UNDERSCORE :: WORD(0x8000) +COMMON_LVB_SBCSDBCS :: WORD(0x0300) -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { OutputDebugStringA :: proc(lpOutputString: LPCSTR) --- // The only A thing that is allowed OutputDebugStringW :: proc(lpOutputString: LPCWSTR) --- - ReadConsoleW :: proc(hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD, lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL --- + ReadConsoleW :: proc(hConsoleInput: HANDLE, + lpBuffer: LPVOID, + nNumberOfCharsToRead: DWORD, + lpNumberOfCharsRead: LPDWORD, + pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL --- - WriteConsoleW :: proc(hConsoleOutput: HANDLE, lpBuffer: LPCVOID, nNumberOfCharsToWrite: DWORD, lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID) -> BOOL --- + WriteConsoleW :: proc(hConsoleOutput: HANDLE, + lpBuffer: LPCVOID, + nNumberOfCharsToWrite: DWORD, + lpNumberOfCharsWritten: LPDWORD, + lpReserved: LPVOID) -> BOOL --- - GetConsoleMode :: proc(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL --- - SetConsoleMode :: proc(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL --- - SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE, dwCursorPosition: COORD) -> BOOL --- - SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL --- + GetConsoleMode :: proc(hConsoleHandle: HANDLE, + lpMode: LPDWORD) -> BOOL --- + SetConsoleMode :: proc(hConsoleHandle: HANDLE, + dwMode: DWORD) -> BOOL --- + SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE, + dwCursorPosition: COORD) -> BOOL --- + SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, + wAttributes: WORD) -> BOOL --- SetConsoleOutputCP :: proc(wCodePageID: UINT) -> BOOL --- - + GetFileInformationByHandle :: proc(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) -> BOOL --- - SetHandleInformation :: proc(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL --- - SetFileInformationByHandle :: proc(hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL --- + SetHandleInformation :: proc(hObject: HANDLE, + dwMask: DWORD, + dwFlags: DWORD) -> BOOL --- + SetFileInformationByHandle :: proc(hFile: HANDLE, + FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, + lpFileInformation: LPVOID, + dwBufferSize: DWORD) -> BOOL --- AddVectoredExceptionHandler :: proc(FirstHandler: ULONG, VectoredHandler: PVECTORED_EXCEPTION_HANDLER) -> LPVOID --- - AddVectoredContinueHandler :: proc(FirstHandler: ULONG, VectoredHandler: PVECTORED_EXCEPTION_HANDLER) -> LPVOID --- - RemoveVectoredExceptionHandler :: proc(Handle: LPVOID) -> DWORD --- - RemoveVectoredContinueHandler :: proc(Handle: LPVOID) -> DWORD --- + AddVectoredContinueHandler :: proc(FirstHandler: ULONG, VectoredHandler: PVECTORED_EXCEPTION_HANDLER) -> LPVOID --- + RemoveVectoredExceptionHandler :: proc(Handle: LPVOID) -> DWORD --- + RemoveVectoredContinueHandler :: proc(Handle: LPVOID) -> DWORD --- RaiseException :: proc(dwExceptionCode, dwExceptionFlags, nNumberOfArguments: DWORD, lpArguments: ^ULONG_PTR) -> ! --- - CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL --- + CreateHardLinkW :: proc(lpSymlinkFileName: LPCWSTR, + lpTargetFileName: LPCWSTR, + lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL --- - GetFileInformationByHandleEx :: proc(hFile: HANDLE, fileInfoClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD) -> BOOL --- + GetFileInformationByHandleEx :: proc(hFile: HANDLE, + fileInfoClass: FILE_INFO_BY_HANDLE_CLASS, + lpFileInformation: LPVOID, + dwBufferSize: DWORD) -> BOOL --- InitializeCriticalSection :: proc(CriticalSection: ^CRITICAL_SECTION) --- InitializeCriticalSectionAndSpinCount :: proc(CriticalSection: ^CRITICAL_SECTION, dwSpinCount: DWORD) -> BOOL --- @@ -67,12 +89,42 @@ foreign kernel32 { GetCurrentProcessId :: proc() -> DWORD --- GetCurrentThread :: proc() -> HANDLE --- GetCurrentThreadId :: proc() -> DWORD --- - GetProcessTimes :: proc(hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME, lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME) -> BOOL --- + GetProcessTimes :: proc( + hProcess: HANDLE, + lpCreationTime: LPFILETIME, + lpExitTime: LPFILETIME, + lpKernelTime: LPFILETIME, + lpUserTime: LPFILETIME, + ) -> BOOL --- GetStdHandle :: proc(which: DWORD) -> HANDLE --- ExitProcess :: proc(uExitCode: c_uint) -> ! --- - DeviceIoControl :: proc(hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL --- - CreateThread :: proc(lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE --- - CreateRemoteThread :: proc(hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: proc "stdcall" (_: rawptr) -> DWORD, lpParameter: LPVOID, dwCreationFlags: DWORD, lpThreadId: LPDWORD) -> HANDLE --- + DeviceIoControl :: proc( + hDevice: HANDLE, + dwIoControlCode: DWORD, + lpInBuffer: LPVOID, + nInBufferSize: DWORD, + lpOutBuffer: LPVOID, + nOutBufferSize: DWORD, + lpBytesReturned: LPDWORD, + lpOverlapped: LPOVERLAPPED, + ) -> BOOL --- + CreateThread :: proc( + lpThreadAttributes: LPSECURITY_ATTRIBUTES, + dwStackSize: SIZE_T, + lpStartAddress: proc "stdcall" (rawptr) -> DWORD, + lpParameter: LPVOID, + dwCreationFlags: DWORD, + lpThreadId: LPDWORD, + ) -> HANDLE --- + CreateRemoteThread :: proc( + hProcess: HANDLE, + lpThreadAttributes: LPSECURITY_ATTRIBUTES, + dwStackSize: SIZE_T, + lpStartAddress: proc "stdcall" (rawptr) -> DWORD, + lpParameter: LPVOID, + dwCreationFlags: DWORD, + lpThreadId: LPDWORD, + ) -> HANDLE --- SwitchToThread :: proc() -> BOOL --- ResumeThread :: proc(thread: HANDLE) -> DWORD --- GetThreadPriority :: proc(thread: HANDLE) -> c_int --- @@ -83,14 +135,46 @@ foreign kernel32 { CreateSemaphoreW :: proc(attributes: LPSECURITY_ATTRIBUTES, initial_count, maximum_count: LONG, name: LPCWSTR) -> HANDLE --- ReleaseSemaphore :: proc(semaphore: HANDLE, release_count: LONG, previous_count: ^LONG) -> BOOL --- - CreateWaitableTimerW :: proc(lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR) -> HANDLE --- - CreateWaitableTimerExW :: proc(lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD) -> HANDLE --- - SetWaitableTimerEx :: proc(hTimer: HANDLE, lpDueTime: ^LARGE_INTEGER, lPeriod: LONG, pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG) -> BOOL --- + CreateWaitableTimerW :: proc( + lpTimerAttributes: LPSECURITY_ATTRIBUTES, + bManualReset: BOOL, + lpTimerName: LPCWSTR, + ) -> HANDLE --- + CreateWaitableTimerExW :: proc( + lpTimerAttributes: LPSECURITY_ATTRIBUTES, + lpTimerName: LPCWSTR, + dwFlags: DWORD, + dwDesiredAccess: DWORD, + ) -> HANDLE --- + SetWaitableTimerEx :: proc( + hTimer: HANDLE, + lpDueTime: ^LARGE_INTEGER, + lPeriod: LONG, + pfnCompletionRoutine: PTIMERAPCROUTINE, + lpArgToCompletionRoutine: LPVOID, + WakeContext: PREASON_CONTEXT, + TolerableDelay: ULONG, + ) -> BOOL --- WaitForSingleObject :: proc(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD --- Sleep :: proc(dwMilliseconds: DWORD) --- GetProcessId :: proc(handle: HANDLE) -> DWORD --- - CopyFileExW :: proc(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD) -> BOOL --- - FormatMessageW :: proc(flags: DWORD, lpSrc: LPVOID, msgId: DWORD, langId: DWORD, buf: LPWSTR, nsize: DWORD, args: rawptr) -> DWORD --- + CopyFileExW :: proc( + lpExistingFileName: LPCWSTR, + lpNewFileName: LPCWSTR, + lpProgressRoutine: LPPROGRESS_ROUTINE, + lpData: LPVOID, + pbCancel: LPBOOL, + dwCopyFlags: DWORD, + ) -> BOOL --- + FormatMessageW :: proc( + flags: DWORD, + lpSrc: LPVOID, + msgId: DWORD, + langId: DWORD, + buf: LPWSTR, + nsize: DWORD, + args: rawptr, + ) -> DWORD --- TlsAlloc :: proc() -> DWORD --- TlsFree :: proc(dwTlsIndex: DWORD) -> BOOL --- TlsGetValue :: proc(dwTlsIndex: DWORD) -> LPVOID --- @@ -100,26 +184,89 @@ foreign kernel32 { QueryPerformanceCounter :: proc(lpPerformanceCount: ^LARGE_INTEGER) -> BOOL --- GetExitCodeProcess :: proc(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL --- TerminateProcess :: proc(hProcess: HANDLE, uExitCode: UINT) -> BOOL --- - CreateProcessW :: proc(lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFO, lpProcessInformation: LPPROCESS_INFORMATION) -> BOOL --- + CreateProcessW :: proc( + lpApplicationName: LPCWSTR, + lpCommandLine: LPWSTR, + lpProcessAttributes: LPSECURITY_ATTRIBUTES, + lpThreadAttributes: LPSECURITY_ATTRIBUTES, + bInheritHandles: BOOL, + dwCreationFlags: DWORD, + lpEnvironment: LPVOID, + lpCurrentDirectory: LPCWSTR, + lpStartupInfo: LPSTARTUPINFO, + lpProcessInformation: LPPROCESS_INFORMATION, + ) -> BOOL --- GetEnvironmentVariableW :: proc(n: LPCWSTR, v: LPWSTR, nsize: DWORD) -> DWORD --- SetEnvironmentVariableW :: proc(n: LPCWSTR, v: LPCWSTR) -> BOOL --- GetEnvironmentStringsW :: proc() -> LPWCH --- FreeEnvironmentStringsW :: proc(env_ptr: LPWCH) -> BOOL --- GetModuleFileNameW :: proc(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD) -> DWORD --- - CreateDirectoryW :: proc(lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> BOOL --- + CreateDirectoryW :: proc( + lpPathName: LPCWSTR, + lpSecurityAttributes: LPSECURITY_ATTRIBUTES, + ) -> BOOL --- DeleteFileW :: proc(lpPathName: LPCWSTR) -> BOOL --- GetCurrentDirectoryW :: proc(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD --- SetCurrentDirectoryW :: proc(lpPathName: LPCWSTR) -> BOOL --- - WideCharToMultiByte :: proc(CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWSTR, cchWideChar: c_int, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCSTR, lpUsedDefaultChar: LPBOOL) -> c_int --- - MultiByteToWideChar :: proc(CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpWideCharStr: LPWSTR, cchWideChar: c_int) -> c_int --- - DuplicateHandle :: proc(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) -> BOOL --- - ReadFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL --- - WriteFile :: proc(hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL --- + WideCharToMultiByte :: proc( + CodePage: UINT, + dwFlags: DWORD, + lpWideCharStr: LPCWSTR, + cchWideChar: c_int, + lpMultiByteStr: LPSTR, + cbMultiByte: c_int, + lpDefaultChar: LPCSTR, + lpUsedDefaultChar: LPBOOL, + ) -> c_int --- + MultiByteToWideChar :: proc( + CodePage: UINT, + dwFlags: DWORD, + lpMultiByteStr: LPSTR, + cbMultiByte: c_int, + lpWideCharStr: LPWSTR, + cchWideChar: c_int, + ) -> c_int --- + DuplicateHandle :: proc( + hSourceProcessHandle: HANDLE, + hSourceHandle: HANDLE, + hTargetProcessHandle: HANDLE, + lpTargetHandle: LPHANDLE, + dwDesiredAccess: DWORD, + bInheritHandle: BOOL, + dwOptions: DWORD, + ) -> BOOL --- + ReadFile :: proc( + hFile: HANDLE, + lpBuffer: LPVOID, + nNumberOfBytesToRead: DWORD, + lpNumberOfBytesRead: LPDWORD, + lpOverlapped: LPOVERLAPPED, + ) -> BOOL --- + WriteFile :: proc( + hFile: HANDLE, + lpBuffer: LPVOID, + nNumberOfBytesToWrite: DWORD, + lpNumberOfBytesWritten: LPDWORD, + lpOverlapped: LPOVERLAPPED, + ) -> BOOL --- CloseHandle :: proc(hObject: HANDLE) -> BOOL --- MoveFileExW :: proc(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD) -> BOOL --- - SetFilePointerEx :: proc(hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER, dwMoveMethod: DWORD) -> BOOL --- + SetFilePointerEx :: proc( + hFile: HANDLE, + liDistanceToMove: LARGE_INTEGER, + lpNewFilePointer: PLARGE_INTEGER, + dwMoveMethod: DWORD, + ) -> BOOL --- FlushFileBuffers :: proc(hFile: HANDLE) -> BOOL --- - CreateFileW :: proc(lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE) -> HANDLE --- + CreateFileW :: proc( + lpFileName: LPCWSTR, + dwDesiredAccess: DWORD, + dwShareMode: DWORD, + lpSecurityAttributes: LPSECURITY_ATTRIBUTES, + dwCreationDisposition: DWORD, + dwFlagsAndAttributes: DWORD, + hTemplateFile: HANDLE, + ) -> HANDLE --- FindFirstFileW :: proc(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW) -> HANDLE --- FindNextFileW :: proc(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW) -> BOOL --- @@ -129,14 +276,45 @@ foreign kernel32 { GetSystemTimeAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) --- GetSystemTimePreciseAsFileTime :: proc(lpSystemTimeAsFileTime: LPFILETIME) --- FileTimeToSystemTime :: proc(lpFileTime: ^FILETIME, lpSystemTime: ^SYSTEMTIME) -> BOOL --- - SystemTimeToTzSpecificLocalTime :: proc(lpTimeZoneInformation: ^TIME_ZONE_INFORMATION, lpUniversalTime: ^SYSTEMTIME, lpLocalTime: ^SYSTEMTIME) -> BOOL --- - SystemTimeToFileTime :: proc(lpSystemTime: ^SYSTEMTIME, lpFileTime: LPFILETIME) -> BOOL --- - CreateEventW :: proc(lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL, lpName: LPCWSTR) -> HANDLE --- + SystemTimeToTzSpecificLocalTime :: proc( + lpTimeZoneInformation: ^TIME_ZONE_INFORMATION, + lpUniversalTime: ^SYSTEMTIME, + lpLocalTime: ^SYSTEMTIME, + ) -> BOOL --- + SystemTimeToFileTime :: proc( + lpSystemTime: ^SYSTEMTIME, + lpFileTime: LPFILETIME, + ) -> BOOL --- + CreateEventW :: proc( + lpEventAttributes: LPSECURITY_ATTRIBUTES, + bManualReset: BOOL, + bInitialState: BOOL, + lpName: LPCWSTR, + ) -> HANDLE --- ResetEvent :: proc(hEvent: HANDLE) -> BOOL --- - WaitForMultipleObjects :: proc(nCount: DWORD, lpHandles: ^HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) -> DWORD --- - CreateNamedPipeW :: proc(lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES) -> HANDLE --- + WaitForMultipleObjects :: proc( + nCount: DWORD, + lpHandles: ^HANDLE, + bWaitAll: BOOL, + dwMilliseconds: DWORD, + ) -> DWORD --- + CreateNamedPipeW :: proc( + lpName: LPCWSTR, + dwOpenMode: DWORD, + dwPipeMode: DWORD, + nMaxInstances: DWORD, + nOutBufferSize: DWORD, + nInBufferSize: DWORD, + nDefaultTimeOut: DWORD, + lpSecurityAttributes: LPSECURITY_ATTRIBUTES, + ) -> HANDLE --- CancelIo :: proc(handle: HANDLE) -> BOOL --- - GetOverlappedResult :: proc(hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL) -> BOOL --- + GetOverlappedResult :: proc( + hFile: HANDLE, + lpOverlapped: LPOVERLAPPED, + lpNumberOfBytesTransferred: LPDWORD, + bWait: BOOL, + ) -> BOOL --- GetProcessHeap :: proc() -> HANDLE --- HeapAlloc :: proc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID --- HeapReAlloc :: proc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID --- @@ -147,30 +325,43 @@ foreign kernel32 { LocalFree :: proc(mem: LPVOID) -> LPVOID --- - ReadDirectoryChangesW :: proc(hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) -> BOOL --- - FindFirstChangeNotificationW :: proc(lpPathName: LPWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD) -> HANDLE --- + ReadDirectoryChangesW :: proc( + hDirectory: HANDLE, + lpBuffer: LPVOID, + nBufferLength: DWORD, + bWatchSubtree: BOOL, + dwNotifyFilter: DWORD, + lpBytesReturned: LPDWORD, + lpOverlapped: LPOVERLAPPED, + lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, + ) -> BOOL --- + FindFirstChangeNotificationW :: proc( + lpPathName: LPWSTR, + bWatchSubtree: BOOL, + dwNotifyFilter: DWORD, + ) -> HANDLE --- FindNextChangeNotification :: proc(hChangeHandle: HANDLE) -> BOOL --- FindCloseChangeNotification :: proc(hChangeHandle: HANDLE) -> BOOL --- - InitializeSRWLock :: proc(SRWLock: ^SRWLOCK) --- - AcquireSRWLockExclusive :: proc(SRWLock: ^SRWLOCK) --- + InitializeSRWLock :: proc(SRWLock: ^SRWLOCK) --- + AcquireSRWLockExclusive :: proc(SRWLock: ^SRWLOCK) --- TryAcquireSRWLockExclusive :: proc(SRWLock: ^SRWLOCK) -> BOOLEAN --- - ReleaseSRWLockExclusive :: proc(SRWLock: ^SRWLOCK) --- - AcquireSRWLockShared :: proc(SRWLock: ^SRWLOCK) --- + ReleaseSRWLockExclusive :: proc(SRWLock: ^SRWLOCK) --- + AcquireSRWLockShared :: proc(SRWLock: ^SRWLOCK) --- TryAcquireSRWLockShared :: proc(SRWLock: ^SRWLOCK) -> BOOLEAN --- - ReleaseSRWLockShared :: proc(SRWLock: ^SRWLOCK) --- + ReleaseSRWLockShared :: proc(SRWLock: ^SRWLOCK) --- InitializeConditionVariable :: proc(ConditionVariable: ^CONDITION_VARIABLE) --- - WakeConditionVariable :: proc(ConditionVariable: ^CONDITION_VARIABLE) --- - WakeAllConditionVariable :: proc(ConditionVariable: ^CONDITION_VARIABLE) --- - SleepConditionVariableCS :: proc(ConditionVariable: ^CONDITION_VARIABLE, CriticalSection: ^CRITICAL_SECTION, dwMilliseconds: DWORD) -> BOOL --- - SleepConditionVariableSRW :: proc(ConditionVariable: ^CONDITION_VARIABLE, SRWLock: ^SRWLOCK, dwMilliseconds: DWORD, Flags: LONG) -> BOOL --- + WakeConditionVariable :: proc(ConditionVariable: ^CONDITION_VARIABLE) --- + WakeAllConditionVariable :: proc(ConditionVariable: ^CONDITION_VARIABLE) --- + SleepConditionVariableCS :: proc(ConditionVariable: ^CONDITION_VARIABLE, CriticalSection: ^CRITICAL_SECTION, dwMilliseconds: DWORD) -> BOOL --- + SleepConditionVariableSRW :: proc(ConditionVariable: ^CONDITION_VARIABLE, SRWLock: ^SRWLOCK, dwMilliseconds: DWORD, Flags: LONG) -> BOOL --- GetFileType :: proc(file_handle: HANDLE) -> DWORD --- SetFilePointer :: proc(file_handle: HANDLE, distance_to_move: LONG, distance_to_move_high: ^LONG, move_method: DWORD) -> DWORD --- GetFileSizeEx :: proc(file_handle: HANDLE, file_size: ^LARGE_INTEGER) -> BOOL --- - GetFileAttributesW :: proc(lpFileName: LPCWSTR) -> DWORD --- + GetFileAttributesW :: proc(lpFileName: LPCWSTR) -> DWORD --- GetFileAttributesExW :: proc(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID) -> BOOL --- GetSystemInfo :: proc(system_info: ^SYSTEM_INFO) --- GetVersionExW :: proc(osvi: ^OSVERSIONINFOEXW) --- @@ -180,8 +371,8 @@ foreign kernel32 { GetProcAddress :: proc(h: HMODULE, c_str: LPCSTR) -> rawptr --- - GetFullPathNameW :: proc(filename: LPCWSTR, buffer_length: DWORD, buffer: LPCWSTR, file_part: ^LPCWSTR) -> DWORD --- - GetLongPathNameW :: proc(short, long: LPCWSTR, len: DWORD) -> DWORD --- + GetFullPathNameW :: proc(filename: LPCWSTR, buffer_length: DWORD, buffer: LPCWSTR, file_part: ^LPCWSTR) -> DWORD --- + GetLongPathNameW :: proc(short, long: LPCWSTR, len: DWORD) -> DWORD --- GetShortPathNameW :: proc(long, short: LPCWSTR, len: DWORD) -> DWORD --- GetFinalPathNameByHandleW :: proc(hFile: HANDLE, lpszFilePath: LPCWSTR, cchFilePath: DWORD, dwFlags: DWORD) -> DWORD --- @@ -191,9 +382,9 @@ foreign kernel32 { CreatePipe :: proc(hReadPipe, hWritePipe: ^HANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES, nSize: DWORD) -> BOOL --- - ConnectNamedPipe :: proc(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL --- - DisconnectNamedPipe :: proc(hNamedPipe: HANDLE) -> BOOL --- - WaitNamedPipeW :: proc(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD) -> BOOL --- + ConnectNamedPipe :: proc(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED,) -> BOOL --- + DisconnectNamedPipe :: proc(hNamedPipe: HANDLE,) -> BOOL --- + WaitNamedPipeW :: proc(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD,) -> BOOL --- SetConsoleCtrlHandler :: proc(HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL) -> BOOL --- GenerateConsoleCtrlEvent :: proc(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD) -> BOOL --- @@ -201,11 +392,16 @@ foreign kernel32 { GetConsoleWindow :: proc() -> HWND --- GetConsoleScreenBufferInfo :: proc(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO) -> BOOL --- SetConsoleScreenBufferSize :: proc(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL --- - SetConsoleWindowInfo :: proc(hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: ^SMALL_RECT) -> BOOL --- + SetConsoleWindowInfo :: proc(hConsoleOutput: HANDLE, bAbsolute : BOOL, lpConsoleWindow: ^SMALL_RECT) -> BOOL --- GetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL --- SetConsoleCursorInfo :: proc(hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO) -> BOOL --- - GetDiskFreeSpaceExW :: proc(lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER, lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER) -> BOOL --- + GetDiskFreeSpaceExW :: proc( + lpDirectoryName: LPCWSTR, + lpFreeBytesAvailableToCaller: PULARGE_INTEGER, + lpTotalNumberOfBytes: PULARGE_INTEGER, + lpTotalNumberOfFreeBytes: PULARGE_INTEGER, + ) -> BOOL --- GetLogicalProcessorInformation :: proc(buffer: ^SYSTEM_LOGICAL_PROCESSOR_INFORMATION, returnedLength: PDWORD) -> BOOL --- @@ -219,100 +415,197 @@ foreign kernel32 { GetQueuedCompletionStatusEx :: proc(CompletionPort: HANDLE, lpCompletionPortEntries: ^OVERLAPPED_ENTRY, ulCount: c_ulong, ulNumEntriesRemoved: ^c_ulong, dwMilliseconds: DWORD, fAlertable: BOOL) -> BOOL --- // [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-postqueuedcompletionstatus) PostQueuedCompletionStatus :: proc(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: c_ulong, lpOverlapped: ^OVERLAPPED) -> BOOL --- - // [MS-Docs] (https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-gettickcount64) - GetTickCount64 :: proc() -> u64 --- - // [MS-Docs](https://github.com/mic101/windows/blob/master/WRK-v1.2/base/ntos/ex/keyedevent.c) - NtCreateKeyedEvent :: proc(KeyedEventHandle: ^HANDLE, DesiredAccess: ACCESS_MASK, ObjectAttributes: OBJECT_ATTRIBUTES, Flags: u32) -> NTSTATUS --- // [MS-Docs](https://learn.microsoft.com/en-us/windows/win32/api/handleapi/nf-handleapi-gethandleinformation) GetHandleInformation :: proc(hObject: HANDLE, lpdwFlags: ^DWORD) -> BOOL --- } -SECTION_QUERY :: DWORD(0x0001) -SECTION_MAP_WRITE :: DWORD(0x0002) -SECTION_MAP_READ :: DWORD(0x0004) -SECTION_MAP_EXECUTE :: DWORD(0x0008) -SECTION_EXTEND_SIZE :: DWORD(0x0010) -SECTION_ALL_ACCESS :: - STANDARD_RIGHTS_REQUIRED | - SECTION_QUERY | - SECTION_MAP_WRITE | - SECTION_MAP_READ | - SECTION_MAP_EXECUTE | - SECTION_EXTEND_SIZE +SECTION_QUERY :: DWORD(0x0001) +SECTION_MAP_WRITE :: DWORD(0x0002) +SECTION_MAP_READ :: DWORD(0x0004) +SECTION_MAP_EXECUTE :: DWORD(0x0008) +SECTION_EXTEND_SIZE :: DWORD(0x0010) +SECTION_ALL_ACCESS :: STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE SECTION_MAP_EXECUTE_EXPLICIT :: DWORD(0x0020) -FILE_MAP_WRITE :: SECTION_MAP_WRITE -FILE_MAP_READ :: SECTION_MAP_READ -FILE_MAP_ALL_ACCESS :: SECTION_ALL_ACCESS -FILE_MAP_EXECUTE :: SECTION_MAP_EXECUTE_EXPLICIT -FILE_MAP_COPY :: DWORD(0x00000001) -FILE_MAP_RESERVE :: DWORD(0x80000000) +FILE_MAP_WRITE :: SECTION_MAP_WRITE +FILE_MAP_READ :: SECTION_MAP_READ +FILE_MAP_ALL_ACCESS :: SECTION_ALL_ACCESS +FILE_MAP_EXECUTE :: SECTION_MAP_EXECUTE_EXPLICIT +FILE_MAP_COPY :: DWORD(0x00000001) +FILE_MAP_RESERVE :: DWORD(0x80000000) FILE_MAP_TARGETS_INVALID :: DWORD(0x40000000) -FILE_MAP_LARGE_PAGES :: DWORD(0x20000000) +FILE_MAP_LARGE_PAGES :: DWORD(0x20000000) -PAGE_NOACCESS :: 0x01 -PAGE_READONLY :: 0x02 -PAGE_READWRITE :: 0x04 -PAGE_WRITECOPY :: 0x08 -PAGE_EXECUTE :: 0x10 -PAGE_EXECUTE_READ :: 0x20 +PAGE_NOACCESS :: 0x01 +PAGE_READONLY :: 0x02 +PAGE_READWRITE :: 0x04 +PAGE_WRITECOPY :: 0x08 +PAGE_EXECUTE :: 0x10 +PAGE_EXECUTE_READ :: 0x20 PAGE_EXECUTE_READWRITE :: 0x40 PAGE_EXECUTE_WRITECOPY :: 0x80 -PAGE_GUARD :: 0x100 -PAGE_NOCACHE :: 0x200 -PAGE_WRITECOMBINE :: 0x400 +PAGE_GUARD :: 0x100 +PAGE_NOCACHE :: 0x200 +PAGE_WRITECOMBINE :: 0x400 MEMORY_BASIC_INFORMATION :: struct { - BaseAddress: PVOID, - AllocationBase: PVOID, + BaseAddress: PVOID, + AllocationBase: PVOID, AllocationProtect: DWORD, - PartitionId: WORD, - RegionSize: SIZE_T, - State: DWORD, - Protect: DWORD, - Type: DWORD, + PartitionId: WORD, + RegionSize: SIZE_T, + State: DWORD, + Protect: DWORD, + Type: DWORD, } PMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION LPMEMORY_BASIC_INFORMATION :: ^MEMORY_BASIC_INFORMATION -MEM_COMMIT :: 0x1000 -MEM_RESERVE :: 0x2000 -MEM_DECOMMIT :: 0x4000 -MEM_RELEASE :: 0x8000 -MEM_FREE :: 0x10000 -MEM_PRIVATE :: 0x20000 -MEM_MAPPED :: 0x40000 -MEM_RESET :: 0x80000 -MEM_TOP_DOWN :: 0x100000 +MEM_COMMIT :: 0x1000 +MEM_RESERVE :: 0x2000 +MEM_DECOMMIT :: 0x4000 +MEM_RELEASE :: 0x8000 +MEM_FREE :: 0x10000 +MEM_PRIVATE :: 0x20000 +MEM_MAPPED :: 0x40000 +MEM_RESET :: 0x80000 +MEM_TOP_DOWN :: 0x100000 MEM_LARGE_PAGES :: 0x20000000 -MEM_4MB_PAGES :: 0x80000000 +MEM_4MB_PAGES :: 0x80000000 -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - VirtualAlloc :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID --- - VirtualProtect :: proc(lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL --- - VirtualFree :: proc(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL --- - VirtualQuery :: proc(lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T --- - VirtualAllocEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) -> LPVOID --- - VirtualFreeEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL --- - VirtualProtectEx :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: PDWORD) -> BOOL --- - VirtualQueryEx :: proc(hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T) -> SIZE_T --- - ReadProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T, lpNumberOfBytesRead: ^SIZE_T) -> BOOL --- - WriteProcessMemory :: proc(hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T, lpNumberOfBytesWritten: ^SIZE_T) -> BOOL --- - CreateFileMappingW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR) -> HANDLE --- - OpenFileMappingW :: proc(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE --- - MapViewOfFile :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T) -> LPVOID --- - MapViewOfFileEx :: proc(hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID) -> LPVOID --- - FlushViewOfFile :: proc(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T) -> BOOL --- - UnmapViewOfFile :: proc(lpBaseAddress: LPCVOID) -> BOOL --- + VirtualAlloc :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + ) -> LPVOID --- + VirtualProtect :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + flNewProtect: DWORD, + lpflOldProtect: PDWORD, + ) -> BOOL --- + VirtualFree :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + dwFreeType: DWORD, + ) -> BOOL --- + VirtualQuery :: proc( + lpAddress: LPCVOID, + lpBuffer: PMEMORY_BASIC_INFORMATION, + dwLength: SIZE_T, + ) -> SIZE_T --- + VirtualAllocEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + ) -> LPVOID --- + VirtualFreeEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + dwFreeType: DWORD, + ) -> BOOL --- + VirtualProtectEx :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flNewProtect: DWORD, + lpflOldProtect: PDWORD, + ) -> BOOL --- + VirtualQueryEx :: proc( + hProcess: HANDLE, + lpAddress: LPCVOID, + lpBuffer: PMEMORY_BASIC_INFORMATION, + dwLength: SIZE_T, + ) -> SIZE_T --- + ReadProcessMemory :: proc( + hProcess: HANDLE, + lpBaseAddress: LPCVOID, + lpBuffer: LPVOID, + nSize: SIZE_T, + lpNumberOfBytesRead: ^SIZE_T, + ) -> BOOL --- + WriteProcessMemory :: proc( + hProcess: HANDLE, + lpBaseAddress: LPVOID, + lpBuffer: LPCVOID, + nSize: SIZE_T, + lpNumberOfBytesWritten: ^SIZE_T, + ) -> BOOL --- + CreateFileMappingW :: proc( + hFile: HANDLE, + lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, + flProtect: DWORD, + dwMaximumSizeHigh: DWORD, + dwMaximumSizeLow: DWORD, + lpName: LPCWSTR, + ) -> HANDLE --- + OpenFileMappingW :: proc( + dwDesiredAccess: DWORD, + bInheritHandle: BOOL, + lpName: LPCWSTR, + ) -> HANDLE --- + MapViewOfFile :: proc( + hFileMappingObject: HANDLE, + dwDesiredAccess: DWORD, + dwFileOffsetHigh: DWORD, + dwFileOffsetLow: DWORD, + dwNumberOfBytesToMap: SIZE_T, + ) -> LPVOID --- + MapViewOfFileEx :: proc( + hFileMappingObject: HANDLE, + dwDesiredAccess: DWORD, + dwFileOffsetHigh: DWORD, + dwFileOffsetLow: DWORD, + dwNumberOfBytesToMap: SIZE_T, + lpBaseAddress: LPVOID, + ) -> LPVOID --- + FlushViewOfFile :: proc( + lpBaseAddress: LPCVOID, + dwNumberOfBytesToFlush: SIZE_T, + ) -> BOOL --- + UnmapViewOfFile :: proc( + lpBaseAddress: LPCVOID, + ) -> BOOL --- GetLargePageMinimum :: proc() -> SIZE_T --- - GetProcessWorkingSetSizeEx :: proc(hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, Flags: PDWORD) -> BOOL --- - SetProcessWorkingSetSizeEx :: proc(hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, Flags: DWORD) -> BOOL --- - VirtualLock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL --- - VirtualUnlock :: proc(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL --- - GetWriteWatch :: proc(dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: ^PVOID, lpdwCount: ^ULONG_PTR, lpdwGranularity: LPDWORD) -> UINT --- - ResetWriteWatch :: proc(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T) -> UINT --- + GetProcessWorkingSetSizeEx :: proc( + hProcess: HANDLE, + lpMinimumWorkingSetSize: PSIZE_T, + lpMaximumWorkingSetSize: PSIZE_T, + Flags: PDWORD, + ) -> BOOL --- + SetProcessWorkingSetSizeEx :: proc( + hProcess: HANDLE, + dwMinimumWorkingSetSize: SIZE_T, + dwMaximumWorkingSetSize: SIZE_T, + Flags: DWORD, + ) -> BOOL --- + VirtualLock :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + ) -> BOOL --- + VirtualUnlock :: proc( + lpAddress: LPVOID, + dwSize: SIZE_T, + ) -> BOOL --- + GetWriteWatch :: proc( + dwFlags: DWORD, + lpBaseAddress: PVOID, + dwRegionSize: SIZE_T, + lpAddresses: ^PVOID, + lpdwCount: ^ULONG_PTR, + lpdwGranularity: LPDWORD, + ) -> UINT --- + ResetWriteWatch :: proc( + lpBaseAddress: LPVOID, + dwRegionSize: SIZE_T, + ) -> UINT --- } @@ -320,66 +613,138 @@ MEMORY_RESOURCE_NOTIFICATION_TYPE :: enum c_int { LowMemoryResourceNotification, HighMemoryResourceNotification, } -LowMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.LowMemoryResourceNotification +LowMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.LowMemoryResourceNotification HighMemoryResourceNotification :: MEMORY_RESOURCE_NOTIFICATION_TYPE.HighMemoryResourceNotification -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - CreateMemoryResourceNotification :: proc(NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE) -> HANDLE --- - QueryMemoryResourceNotification :: proc(ResourceNotificationHandle: HANDLE, ResourceState: PBOOL) -> BOOL --- + CreateMemoryResourceNotification :: proc( + NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE, + ) -> HANDLE --- + QueryMemoryResourceNotification :: proc( + ResourceNotificationHandle: HANDLE, + ResourceState: PBOOL, + ) -> BOOL --- } -FILE_CACHE_MAX_HARD_ENABLE :: DWORD(0x00000001) +FILE_CACHE_MAX_HARD_ENABLE :: DWORD(0x00000001) FILE_CACHE_MAX_HARD_DISABLE :: DWORD(0x00000002) -FILE_CACHE_MIN_HARD_ENABLE :: DWORD(0x00000004) +FILE_CACHE_MIN_HARD_ENABLE :: DWORD(0x00000004) FILE_CACHE_MIN_HARD_DISABLE :: DWORD(0x00000008) -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - GetSystemFileCacheSize :: proc(lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD) -> BOOL --- - SetSystemFileCacheSize :: proc(MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD) -> BOOL --- - CreateFileMappingNumaW :: proc(hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD) -> HANDLE --- + GetSystemFileCacheSize :: proc( + lpMinimumFileCacheSize: PSIZE_T, + lpMaximumFileCacheSize: PSIZE_T, + lpFlags: PDWORD, + ) -> BOOL --- + SetSystemFileCacheSize :: proc( + MinimumFileCacheSize: SIZE_T, + MaximumFileCacheSize: SIZE_T, + Flags: DWORD, + ) -> BOOL --- + CreateFileMappingNumaW :: proc( + hFile: HANDLE, + lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, + flProtect: DWORD, + dwMaximumSizeHigh: DWORD, + dwMaximumSizeLow: DWORD, + lpName: LPCWSTR, + nndPreferred: DWORD, + ) -> HANDLE --- } WIN32_MEMORY_RANGE_ENTRY :: struct { VirtualAddress: PVOID, - NumberOfBytes: SIZE_T, + NumberOfBytes: SIZE_T, } PWIN32_MEMORY_RANGE_ENTRY :: ^WIN32_MEMORY_RANGE_ENTRY -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - PrefetchVirtualMemory :: proc(hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, Flags: ULONG) -> BOOL --- - CreateFileMappingFromApp :: proc(hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG, MaximumSize: ULONG64, Name: PCWSTR) -> HANDLE --- - MapViewOfFileFromApp :: proc(hFileMappingObject: HANDLE, DesiredAccess: ULONG, FileOffset: ULONG64, NumberOfBytesToMap: SIZE_T) -> PVOID --- - UnmapViewOfFileEx :: proc(BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL --- - AllocateUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL --- - FreeUserPhysicalPages :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR) -> BOOL --- - MapUserPhysicalPages :: proc(VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR) -> BOOL --- - AllocateUserPhysicalPagesNuma :: proc(hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD) -> BOOL --- - VirtualAllocExNuma :: proc(hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD, nndPreferred: DWORD) -> LPVOID --- + PrefetchVirtualMemory :: proc( + hProcess: HANDLE, + NumberOfEntries: ULONG_PTR, + VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY, + Flags: ULONG, + ) -> BOOL --- + CreateFileMappingFromApp :: proc( + hFile: HANDLE, + SecurityAttributes: PSECURITY_ATTRIBUTES, + PageProtection: ULONG, + MaximumSize: ULONG64, + Name: PCWSTR, + ) -> HANDLE --- + MapViewOfFileFromApp :: proc( + hFileMappingObject: HANDLE, + DesiredAccess: ULONG, + FileOffset: ULONG64, + NumberOfBytesToMap: SIZE_T, + ) -> PVOID --- + UnmapViewOfFileEx :: proc( + BaseAddress: PVOID, + UnmapFlags: ULONG, + ) -> BOOL --- + AllocateUserPhysicalPages :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL --- + FreeUserPhysicalPages :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL --- + MapUserPhysicalPages :: proc( + VirtualAddress: PVOID, + NumberOfPages: ULONG_PTR, + PageArray: PULONG_PTR, + ) -> BOOL --- + AllocateUserPhysicalPagesNuma :: proc( + hProcess: HANDLE, + NumberOfPages: PULONG_PTR, + PageArray: PULONG_PTR, + nndPreferred: DWORD, + ) -> BOOL --- + VirtualAllocExNuma :: proc( + hProcess: HANDLE, + lpAddress: LPVOID, + dwSize: SIZE_T, + flAllocationType: DWORD, + flProtect: DWORD, + nndPreferred: DWORD, + ) -> LPVOID --- } MEHC_PATROL_SCRUBBER_PRESENT :: ULONG(0x1) -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - GetMemoryErrorHandlingCapabilities :: proc(Capabilities: PULONG) -> BOOL --- + GetMemoryErrorHandlingCapabilities :: proc( + Capabilities: PULONG, + ) -> BOOL --- } -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - GlobalMemoryStatusEx :: proc(lpBuffer: ^MEMORYSTATUSEX) -> BOOL --- + GlobalMemoryStatusEx :: proc( + lpBuffer: ^MEMORYSTATUSEX, + ) -> BOOL --- } PBAD_MEMORY_CALLBACK_ROUTINE :: #type proc "stdcall" () -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - RegisterBadMemoryNotification :: proc(Callback: PBAD_MEMORY_CALLBACK_ROUTINE) -> PVOID --- - UnregisterBadMemoryNotification :: proc(RegistrationHandle: PVOID) -> BOOL --- + RegisterBadMemoryNotification :: proc( + Callback: PBAD_MEMORY_CALLBACK_ROUTINE, + ) -> PVOID --- + UnregisterBadMemoryNotification :: proc( + RegistrationHandle: PVOID, + ) -> BOOL --- } OFFER_PRIORITY :: enum c_int { @@ -388,19 +753,43 @@ OFFER_PRIORITY :: enum c_int { VmOfferPriorityBelowNormal, VmOfferPriorityNormal, } -VmOfferPriorityVeryLow :: OFFER_PRIORITY.VmOfferPriorityVeryLow -VmOfferPriorityLow :: OFFER_PRIORITY.VmOfferPriorityLow +VmOfferPriorityVeryLow :: OFFER_PRIORITY.VmOfferPriorityVeryLow +VmOfferPriorityLow :: OFFER_PRIORITY.VmOfferPriorityLow VmOfferPriorityBelowNormal :: OFFER_PRIORITY.VmOfferPriorityBelowNormal -VmOfferPriorityNormal :: OFFER_PRIORITY.VmOfferPriorityNormal +VmOfferPriorityNormal :: OFFER_PRIORITY.VmOfferPriorityNormal -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - OfferVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T, Priority: OFFER_PRIORITY) -> DWORD --- - ReclaimVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD --- - DiscardVirtualMemory :: proc(VirtualAddress: PVOID, Size: SIZE_T) -> DWORD --- - VirtualAllocFromApp :: proc(BaseAddress: PVOID, Size: SIZE_T, AllocationType: ULONG, Protection: ULONG) -> PVOID --- - VirtualProtectFromApp :: proc(Address: PVOID, Size: SIZE_T, NewProtection: ULONG, OldProtection: PULONG) -> BOOL --- - OpenFileMappingFromApp :: proc(DesiredAccess: ULONG, InheritHandle: BOOL, Name: PCWSTR) -> HANDLE --- + OfferVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + Priority: OFFER_PRIORITY, + ) -> DWORD --- + ReclaimVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + ) -> DWORD --- + DiscardVirtualMemory :: proc( + VirtualAddress: PVOID, + Size: SIZE_T, + ) -> DWORD --- + VirtualAllocFromApp :: proc( + BaseAddress: PVOID, + Size: SIZE_T, + AllocationType: ULONG, + Protection: ULONG, + ) -> PVOID --- + VirtualProtectFromApp :: proc( + Address: PVOID, + Size: SIZE_T, + NewProtection: ULONG, + OldProtection: PULONG, + ) -> BOOL --- + OpenFileMappingFromApp :: proc( + DesiredAccess: ULONG, + InheritHandle: BOOL, + Name: PCWSTR, + ) -> HANDLE --- } WIN32_MEMORY_INFORMATION_CLASS :: enum c_int { @@ -409,16 +798,16 @@ WIN32_MEMORY_INFORMATION_CLASS :: enum c_int { MemoryRegionInfo :: WIN32_MEMORY_INFORMATION_CLASS.MemoryRegionInfo WIN32_MEMORY_REGION_INFORMATION :: struct { - AllocationBase: PVOID, + AllocationBase: PVOID, AllocationProtect: ULONG, - u: WIN32_MEMORY_REGION_INFORMATION_u, - RegionSize: SIZE_T, - CommitSize: SIZE_T, + u: WIN32_MEMORY_REGION_INFORMATION_u, + RegionSize: SIZE_T, + CommitSize: SIZE_T, } WIN32_MEMORY_REGION_INFORMATION_u :: struct #raw_union { - u: [1]u32, + u: [1]u32, Flags: ULONG, - s: WIN32_MEMORY_REGION_INFORMATION_u_s, + s: WIN32_MEMORY_REGION_INFORMATION_u_s, } WIN32_MEMORY_REGION_INFORMATION_u_s :: struct { Bitfield: ULONG, @@ -434,10 +823,26 @@ WIN32_MEMORY_REGION_INFORMATION_u_s_Bitfield :: distinct ULONG Reserved : 32-6, }*/ -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - QueryVirtualMemoryInformation :: proc(Process: HANDLE, VirtualAddress: PVOID, MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, MemoryInformation: PVOID, MemoryInformationSize: SIZE_T, ReturnSize: PSIZE_T) -> BOOL --- - MapViewOfFileNuma2 :: proc(FileMappingHandle: HANDLE, ProcessHandle: HANDLE, Offset: ULONG64, BaseAddress: PVOID, ViewSize: SIZE_T, AllocationType: ULONG, PageProtection: ULONG, PreferredNode: ULONG) -> PVOID --- + QueryVirtualMemoryInformation :: proc( + Process: HANDLE, + VirtualAddress: PVOID, + MemoryInformationClass: WIN32_MEMORY_INFORMATION_CLASS, + MemoryInformation: PVOID, + MemoryInformationSize: SIZE_T, + ReturnSize: PSIZE_T, + ) -> BOOL --- + MapViewOfFileNuma2 :: proc( + FileMappingHandle: HANDLE, + ProcessHandle: HANDLE, + Offset: ULONG64, + BaseAddress: PVOID, + ViewSize: SIZE_T, + AllocationType: ULONG, + PageProtection: ULONG, + PreferredNode: ULONG, + ) -> PVOID --- } @@ -464,45 +869,57 @@ MapViewOfFile2 :: #force_inline proc "stdcall" ( ) } -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - UnmapViewOfFile2 :: proc(ProcessHandle: HANDLE, BaseAddress: PVOID, UnmapFlags: ULONG) -> BOOL --- + UnmapViewOfFile2 :: proc( + ProcessHandle: HANDLE, + BaseAddress: PVOID, + UnmapFlags: ULONG, + ) -> BOOL --- } -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { - GetProductInfo :: proc(OSMajorVersion: DWORD, OSMinorVersion: DWORD, SpMajorVersion: DWORD, SpMinorVersion: DWORD, product_type: ^Windows_Product_Type) -> BOOL --- + GetProductInfo :: proc( + OSMajorVersion: DWORD, + OSMinorVersion: DWORD, + SpMajorVersion: DWORD, + SpMinorVersion: DWORD, + product_type: ^Windows_Product_Type, + ) -> BOOL --- } HandlerRoutine :: proc "stdcall" (dwCtrlType: DWORD) -> BOOL PHANDLER_ROUTINE :: HandlerRoutine + + DCB_Config :: struct { - fParity: bool, - fOutxCtsFlow: bool, - fOutxDsrFlow: bool, - fDtrControl: DTR_Control, - fDsrSensitivity: bool, + fParity: bool, + fOutxCtsFlow: bool, + fOutxDsrFlow: bool, + fDtrControl: DTR_Control, + fDsrSensitivity: bool, fTXContinueOnXoff: bool, - fOutX: bool, - fInX: bool, - fErrorChar: bool, - fNull: bool, - fRtsControl: RTS_Control, - fAbortOnError: bool, - BaudRate: DWORD, - ByteSize: BYTE, - Parity: Parity, - StopBits: Stop_Bits, - XonChar: byte, - XoffChar: byte, - ErrorChar: byte, - EvtChar: byte, + fOutX: bool, + fInX: bool, + fErrorChar: bool, + fNull: bool, + fRtsControl: RTS_Control, + fAbortOnError: bool, + BaudRate: DWORD, + ByteSize: BYTE, + Parity: Parity, + StopBits: Stop_Bits, + XonChar: byte, + XoffChar: byte, + ErrorChar: byte, + EvtChar: byte, } DTR_Control :: enum byte { - Disable = 0, - Enable = 1, + Disable = 0, + Enable = 1, Handshake = 2, } RTS_Control :: enum byte { @@ -519,9 +936,9 @@ Parity :: enum byte { Space = 4, } Stop_Bits :: enum byte { - One = 0, + One = 0, One_And_A_Half = 1, - Two = 2, + Two = 2, } // A helper procedure to set the values of a DCB structure. @@ -596,24 +1013,24 @@ get_dcb_config :: proc "contextless" (dcb: DCB) -> (config: DCB_Config) { // NOTE(tetra): See get_dcb_config() and init_dcb_with_config() for help with initializing this. DCB :: struct { - DCBlength: DWORD, // NOTE(tetra): Must be set to size_of(DCB). - BaudRate: DWORD, - settings: u32, // NOTE(tetra): These are bitfields in the C struct. - wReserved: WORD, - XOnLim: WORD, - XOffLim: WORD, - ByteSize: BYTE, - Parity: Parity, - StopBits: Stop_Bits, - XonChar: byte, - XoffChar: byte, - ErrorChar: byte, - EofChar: byte, - EvtChar: byte, + DCBlength: DWORD, // NOTE(tetra): Must be set to size_of(DCB). + BaudRate: DWORD, + settings: u32, // NOTE(tetra): These are bitfields in the C struct. + wReserved: WORD, + XOnLim: WORD, + XOffLim: WORD, + ByteSize: BYTE, + Parity: Parity, + StopBits: Stop_Bits, + XonChar: byte, + XoffChar: byte, + ErrorChar: byte, + EofChar: byte, + EvtChar: byte, wReserved1: WORD, } -@(default_calling_convention = "stdcall") +@(default_calling_convention="stdcall") foreign kernel32 { GetCommState :: proc(handle: HANDLE, dcb: ^DCB) -> BOOL --- SetCommState :: proc(handle: HANDLE, dcb: ^DCB) -> BOOL --- @@ -650,11 +1067,11 @@ PROCESSOR_CACHE_TYPE :: enum c_int { } CACHE_DESCRIPTOR :: struct { - Level: BYTE, + Level: BYTE, Associativity: BYTE, - LineSize: WORD, - Size: DWORD, - Type: PROCESSOR_CACHE_TYPE, + LineSize: WORD, + Size: DWORD, + Type: PROCESSOR_CACHE_TYPE, } ProcessorCore :: struct { @@ -664,14 +1081,14 @@ NumaNode :: struct { NodeNumber: DWORD, } DUMMYUNIONNAME_u :: struct #raw_union { - Core: ProcessorCore, - Node: NumaNode, - Cache: CACHE_DESCRIPTOR, + Core: ProcessorCore, + Node: NumaNode, + Cache: CACHE_DESCRIPTOR, Reserved: [2]ULONGLONG, } SYSTEM_LOGICAL_PROCESSOR_INFORMATION :: struct { ProcessorMask: ULONG_PTR, - Relationship: LOGICAL_PROCESSOR_RELATIONSHIP, - DummyUnion: DUMMYUNIONNAME_u, + Relationship: LOGICAL_PROCESSOR_RELATIONSHIP, + DummyUnion: DUMMYUNIONNAME_u, }