authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-11-19 19:03:08+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2020-11-19 19:03:08+02:00
logcf819b95fe7dec15f4ed87cd4bd8ae0be8ce7fdf
tree612ec79d1895e59d3ac50a8a2b8c0d59d34d2772
parent25ec2dbc1e2302d1138749262b588d3e438fcd55
parent3a28b659bd66a1312f5586b7fc8afdd6c6a32eb2
signature Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #6829 from tadeokondrak/error-unsupported-callconv

stage1: Compile error instead of falling back to C for unsupported cc

17 files changed, 388 insertions(+), 252 deletions(-)

doc/langref.html.in+2-2
......@@ -4191,7 +4191,7 @@ test "noreturn" {
41914191 <p>Another use case for {#syntax#}noreturn{#endsyntax#} is the {#syntax#}exit{#endsyntax#} function:</p>
41924192 {#code_begin|test#}
41934193 {#target_windows#}
4194pub extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(.Stdcall) noreturn;
4194pub extern "kernel32" fn ExitProcess(exit_code: c_uint) callconv(if (@import("builtin").arch == .i386) .Stdcall else .C) noreturn;
41954195
41964196test "foo" {
41974197 const value = bar() catch ExitProcess(1);
......@@ -4226,7 +4226,7 @@ export fn sub(a: i8, b: i8) i8 { return a - b; }
42264226// at link time, when linking statically, or at runtime, when linking
42274227// dynamically.
42284228// The callconv specifier changes the calling convention of the function.
4229extern "kernel32" fn ExitProcess(exit_code: u32) callconv(.Stdcall) noreturn;
4229extern "kernel32" fn ExitProcess(exit_code: u32) callconv(if (@import("builtin").arch == .i386) .Stdcall else .C) noreturn;
42304230extern "c" fn atan2(a: f64, b: f64) f64;
42314231
42324232// The @setCold builtin tells the optimizer that a function is rarely called.
lib/std/debug.zig+1-1
......@@ -1801,7 +1801,7 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v
18011801 os.abort();
18021802}
18031803
1804fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.Stdcall) c_long {
1804fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WINAPI) c_long {
18051805 switch (info.ExceptionRecord.ExceptionCode) {
18061806 windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, 0, "Unaligned Memory Access"),
18071807 windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, 1, null),
lib/std/os/windows/advapi32.zig+3-3
......@@ -11,7 +11,7 @@ pub extern "advapi32" fn RegOpenKeyExW(
1111 ulOptions: DWORD,
1212 samDesired: REGSAM,
1313 phkResult: *HKEY,
14) callconv(.Stdcall) LSTATUS;
14) callconv(WINAPI) LSTATUS;
1515
1616pub extern "advapi32" fn RegQueryValueExW(
1717 hKey: HKEY,
......@@ -20,9 +20,9 @@ pub extern "advapi32" fn RegQueryValueExW(
2020 lpType: LPDWORD,
2121 lpData: LPBYTE,
2222 lpcbData: LPDWORD,
23) callconv(.Stdcall) LSTATUS;
23) callconv(WINAPI) LSTATUS;
2424
2525// RtlGenRandom is known as SystemFunction036 under advapi32
2626// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
27pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(.Stdcall) BOOL;
27pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(WINAPI) BOOL;
2828pub const RtlGenRandom = SystemFunction036;
lib/std/os/windows/bits.zig+6-1
......@@ -24,6 +24,11 @@ pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
2424/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
2525pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
2626
27pub const WINAPI: builtin.CallingConvention = if (builtin.arch == .i386)
28 .Stdcall
29else
30 .C;
31
2732pub const BOOL = c_int;
2833pub const BOOLEAN = BYTE;
2934pub const BYTE = u8;
......@@ -1150,7 +1155,7 @@ pub const EXCEPTION_POINTERS = extern struct {
11501155 ContextRecord: PCONTEXT,
11511156};
11521157
1153pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(.Stdcall) c_long;
1158pub const VECTORED_EXCEPTION_HANDLER = fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(WINAPI) c_long;
11541159
11551160pub const OBJECT_ATTRIBUTES = extern struct {
11561161 Length: ULONG,
lib/std/os/windows/gdi32.zig+5-5
......@@ -38,13 +38,13 @@ pub extern "gdi32" fn SetPixelFormat(
3838 hdc: ?HDC,
3939 format: i32,
4040 ppfd: ?*const PIXELFORMATDESCRIPTOR,
41) callconv(.Stdcall) bool;
41) callconv(WINAPI) bool;
4242
4343pub extern "gdi32" fn ChoosePixelFormat(
4444 hdc: ?HDC,
4545 ppfd: ?*const PIXELFORMATDESCRIPTOR,
46) callconv(.Stdcall) i32;
46) callconv(WINAPI) i32;
4747
48pub extern "gdi32" fn SwapBuffers(hdc: ?HDC) callconv(.Stdcall) bool;
49pub extern "gdi32" fn wglCreateContext(hdc: ?HDC) callconv(.Stdcall) ?HGLRC;
50pub extern "gdi32" fn wglMakeCurrent(hdc: ?HDC, hglrc: ?HGLRC) callconv(.Stdcall) bool;
48pub extern "gdi32" fn SwapBuffers(hdc: ?HDC) callconv(WINAPI) bool;
49pub extern "gdi32" fn wglCreateContext(hdc: ?HDC) callconv(WINAPI) ?HGLRC;
50pub extern "gdi32" fn wglMakeCurrent(hdc: ?HDC, hglrc: ?HGLRC) callconv(WINAPI) bool;
lib/std/os/windows/kernel32.zig+127-127
......@@ -5,22 +5,22 @@
55// and substantial portions of the software.
66usingnamespace @import("bits.zig");
77
8pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(.Stdcall) ?*c_void;
9pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(.Stdcall) c_ulong;
8pub extern "kernel32" fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) callconv(WINAPI) ?*c_void;
9pub extern "kernel32" fn RemoveVectoredExceptionHandler(Handle: HANDLE) callconv(WINAPI) c_ulong;
1010
11pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(.Stdcall) BOOL;
11pub extern "kernel32" fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) callconv(WINAPI) BOOL;
1212
13pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(.Stdcall) BOOL;
13pub extern "kernel32" fn CloseHandle(hObject: HANDLE) callconv(WINAPI) BOOL;
1414
15pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*:0]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(.Stdcall) BOOL;
16pub extern "kernel32" fn SetEndOfFile(hFile: HANDLE) callconv(.Stdcall) BOOL;
15pub extern "kernel32" fn CreateDirectoryW(lpPathName: [*:0]const u16, lpSecurityAttributes: ?*SECURITY_ATTRIBUTES) callconv(WINAPI) BOOL;
16pub extern "kernel32" fn SetEndOfFile(hFile: HANDLE) callconv(WINAPI) BOOL;
1717
1818pub extern "kernel32" fn CreateEventExW(
1919 lpEventAttributes: ?*SECURITY_ATTRIBUTES,
2020 lpName: [*:0]const u16,
2121 dwFlags: DWORD,
2222 dwDesiredAccess: DWORD,
23) callconv(.Stdcall) ?HANDLE;
23) callconv(WINAPI) ?HANDLE;
2424
2525pub extern "kernel32" fn CreateFileW(
2626 lpFileName: [*:0]const u16,
......@@ -30,14 +30,14 @@ pub extern "kernel32" fn CreateFileW(
3030 dwCreationDisposition: DWORD,
3131 dwFlagsAndAttributes: DWORD,
3232 hTemplateFile: ?HANDLE,
33) callconv(.Stdcall) HANDLE;
33) callconv(WINAPI) HANDLE;
3434
3535pub extern "kernel32" fn CreatePipe(
3636 hReadPipe: *HANDLE,
3737 hWritePipe: *HANDLE,
3838 lpPipeAttributes: *const SECURITY_ATTRIBUTES,
3939 nSize: DWORD,
40) callconv(.Stdcall) BOOL;
40) callconv(WINAPI) BOOL;
4141
4242pub extern "kernel32" fn CreateProcessW(
4343 lpApplicationName: ?LPWSTR,
......@@ -50,13 +50,13 @@ pub extern "kernel32" fn CreateProcessW(
5050 lpCurrentDirectory: ?LPWSTR,
5151 lpStartupInfo: *STARTUPINFOW,
5252 lpProcessInformation: *PROCESS_INFORMATION,
53) callconv(.Stdcall) BOOL;
53) callconv(WINAPI) BOOL;
5454
55pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*:0]const u16, lpTargetFileName: [*:0]const u16, dwFlags: DWORD) callconv(.Stdcall) BOOLEAN;
55pub extern "kernel32" fn CreateSymbolicLinkW(lpSymlinkFileName: [*:0]const u16, lpTargetFileName: [*:0]const u16, dwFlags: DWORD) callconv(WINAPI) BOOLEAN;
5656
57pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(.Stdcall) ?HANDLE;
57pub extern "kernel32" fn CreateIoCompletionPort(FileHandle: HANDLE, ExistingCompletionPort: ?HANDLE, CompletionKey: ULONG_PTR, NumberOfConcurrentThreads: DWORD) callconv(WINAPI) ?HANDLE;
5858
59pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(.Stdcall) ?HANDLE;
59pub extern "kernel32" fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) callconv(WINAPI) ?HANDLE;
6060
6161pub extern "kernel32" fn DeviceIoControl(
6262 h: HANDLE,
......@@ -67,111 +67,111 @@ pub extern "kernel32" fn DeviceIoControl(
6767 nOutBufferSize: DWORD,
6868 lpBytesReturned: ?*DWORD,
6969 lpOverlapped: ?*OVERLAPPED,
70) callconv(.Stdcall) BOOL;
70) callconv(WINAPI) BOOL;
7171
72pub extern "kernel32" fn DeleteFileW(lpFileName: [*:0]const u16) callconv(.Stdcall) BOOL;
72pub extern "kernel32" fn DeleteFileW(lpFileName: [*:0]const u16) callconv(WINAPI) BOOL;
7373
74pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(.Stdcall) BOOL;
74pub extern "kernel32" fn DuplicateHandle(hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE, lpTargetHandle: *HANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD) callconv(WINAPI) BOOL;
7575
76pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(.Stdcall) noreturn;
76pub extern "kernel32" fn ExitProcess(exit_code: UINT) callconv(WINAPI) noreturn;
7777
78pub extern "kernel32" fn FindFirstFileW(lpFileName: [*:0]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) HANDLE;
79pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(.Stdcall) BOOL;
80pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(.Stdcall) BOOL;
78pub extern "kernel32" fn FindFirstFileW(lpFileName: [*:0]const u16, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) HANDLE;
79pub extern "kernel32" fn FindClose(hFindFile: HANDLE) callconv(WINAPI) BOOL;
80pub extern "kernel32" fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: *WIN32_FIND_DATAW) callconv(WINAPI) BOOL;
8181
82pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: Win32Error, dwLanguageId: DWORD, lpBuffer: [*]u16, nSize: DWORD, Arguments: ?*va_list) callconv(.Stdcall) DWORD;
82pub extern "kernel32" fn FormatMessageW(dwFlags: DWORD, lpSource: ?LPVOID, dwMessageId: Win32Error, dwLanguageId: DWORD, lpBuffer: [*]u16, nSize: DWORD, Arguments: ?*va_list) callconv(WINAPI) DWORD;
8383
84pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*:0]u16) callconv(.Stdcall) BOOL;
84pub extern "kernel32" fn FreeEnvironmentStringsW(penv: [*:0]u16) callconv(WINAPI) BOOL;
8585
86pub extern "kernel32" fn GetCommandLineA() callconv(.Stdcall) LPSTR;
87pub extern "kernel32" fn GetCommandLineW() callconv(.Stdcall) LPWSTR;
86pub extern "kernel32" fn GetCommandLineA() callconv(WINAPI) LPSTR;
87pub extern "kernel32" fn GetCommandLineW() callconv(WINAPI) LPWSTR;
8888
89pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(.Stdcall) BOOL;
89pub extern "kernel32" fn GetConsoleMode(in_hConsoleHandle: HANDLE, out_lpMode: *DWORD) callconv(WINAPI) BOOL;
9090
91pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(.Stdcall) BOOL;
92pub extern "kernel32" fn FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: TCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD) callconv(.Stdcall) BOOL;
93pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD) callconv(.Stdcall) BOOL;
94pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(.Stdcall) BOOL;
91pub extern "kernel32" fn GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO) callconv(WINAPI) BOOL;
92pub extern "kernel32" fn FillConsoleOutputCharacterA(hConsoleOutput: HANDLE, cCharacter: TCHAR, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfCharsWritten: LPDWORD) callconv(WINAPI) BOOL;
93pub extern "kernel32" fn FillConsoleOutputAttribute(hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD, lpNumberOfAttrsWritten: LPDWORD) callconv(WINAPI) BOOL;
94pub extern "kernel32" fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) callconv(WINAPI) BOOL;
9595
96pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(.Stdcall) DWORD;
96pub extern "kernel32" fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: ?[*]WCHAR) callconv(WINAPI) DWORD;
9797
98pub extern "kernel32" fn GetCurrentThread() callconv(.Stdcall) HANDLE;
99pub extern "kernel32" fn GetCurrentThreadId() callconv(.Stdcall) DWORD;
98pub extern "kernel32" fn GetCurrentThread() callconv(WINAPI) HANDLE;
99pub extern "kernel32" fn GetCurrentThreadId() callconv(WINAPI) DWORD;
100100
101pub extern "kernel32" fn GetCurrentProcess() callconv(.Stdcall) HANDLE;
101pub extern "kernel32" fn GetCurrentProcess() callconv(WINAPI) HANDLE;
102102
103pub extern "kernel32" fn GetEnvironmentStringsW() callconv(.Stdcall) ?[*:0]u16;
103pub extern "kernel32" fn GetEnvironmentStringsW() callconv(WINAPI) ?[*:0]u16;
104104
105pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;
105pub extern "kernel32" fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
106106
107pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(.Stdcall) BOOL;
107pub extern "kernel32" fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: *DWORD) callconv(WINAPI) BOOL;
108108
109pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
109pub extern "kernel32" fn GetFileSizeEx(hFile: HANDLE, lpFileSize: *LARGE_INTEGER) callconv(WINAPI) BOOL;
110110
111pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(.Stdcall) DWORD;
111pub extern "kernel32" fn GetFileAttributesW(lpFileName: [*]const WCHAR) callconv(WINAPI) DWORD;
112112
113pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(.Stdcall) DWORD;
113pub extern "kernel32" fn GetModuleFileNameW(hModule: ?HMODULE, lpFilename: [*]u16, nSize: DWORD) callconv(WINAPI) DWORD;
114114
115pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*:0]const WCHAR) callconv(.Stdcall) ?HMODULE;
115pub extern "kernel32" fn GetModuleHandleW(lpModuleName: ?[*:0]const WCHAR) callconv(WINAPI) ?HMODULE;
116116
117pub extern "kernel32" fn GetLastError() callconv(.Stdcall) Win32Error;
117pub extern "kernel32" fn GetLastError() callconv(WINAPI) Win32Error;
118118
119119pub extern "kernel32" fn GetFileInformationByHandle(
120120 hFile: HANDLE,
121121 lpFileInformation: *BY_HANDLE_FILE_INFORMATION,
122) callconv(.Stdcall) BOOL;
122) callconv(WINAPI) BOOL;
123123
124124pub extern "kernel32" fn GetFileInformationByHandleEx(
125125 in_hFile: HANDLE,
126126 in_FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
127127 out_lpFileInformation: *c_void,
128128 in_dwBufferSize: DWORD,
129) callconv(.Stdcall) BOOL;
129) callconv(WINAPI) BOOL;
130130
131131pub extern "kernel32" fn GetFinalPathNameByHandleW(
132132 hFile: HANDLE,
133133 lpszFilePath: [*]u16,
134134 cchFilePath: DWORD,
135135 dwFlags: DWORD,
136) callconv(.Stdcall) DWORD;
136) callconv(WINAPI) DWORD;
137137
138pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(.Stdcall) BOOL;
138pub extern "kernel32" fn GetOverlappedResult(hFile: HANDLE, lpOverlapped: *OVERLAPPED, lpNumberOfBytesTransferred: *DWORD, bWait: BOOL) callconv(WINAPI) BOOL;
139139
140pub extern "kernel32" fn GetProcessHeap() callconv(.Stdcall) ?HANDLE;
141pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(.Stdcall) BOOL;
140pub extern "kernel32" fn GetProcessHeap() callconv(WINAPI) ?HANDLE;
141pub extern "kernel32" fn GetQueuedCompletionStatus(CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: *ULONG_PTR, lpOverlapped: *?*OVERLAPPED, dwMilliseconds: DWORD) callconv(WINAPI) BOOL;
142142
143pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(.Stdcall) void;
144pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(.Stdcall) void;
143pub extern "kernel32" fn GetSystemInfo(lpSystemInfo: *SYSTEM_INFO) callconv(WINAPI) void;
144pub extern "kernel32" fn GetSystemTimeAsFileTime(*FILETIME) callconv(WINAPI) void;
145145
146pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(.Stdcall) ?HANDLE;
147pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(.Stdcall) BOOL;
148pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
149pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(.Stdcall) SIZE_T;
150pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(.Stdcall) SIZE_T;
151pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(.Stdcall) BOOL;
146pub extern "kernel32" fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) callconv(WINAPI) ?HANDLE;
147pub extern "kernel32" fn HeapDestroy(hHeap: HANDLE) callconv(WINAPI) BOOL;
148pub extern "kernel32" fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void, dwBytes: SIZE_T) callconv(WINAPI) ?*c_void;
149pub extern "kernel32" fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: *const c_void) callconv(WINAPI) SIZE_T;
150pub extern "kernel32" fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) callconv(WINAPI) SIZE_T;
151pub extern "kernel32" fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) callconv(WINAPI) BOOL;
152152
153pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(.Stdcall) ?HANDLE;
153pub extern "kernel32" fn GetStdHandle(in_nStdHandle: DWORD) callconv(WINAPI) ?HANDLE;
154154
155pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(.Stdcall) ?*c_void;
155pub extern "kernel32" fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) callconv(WINAPI) ?*c_void;
156156
157pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(.Stdcall) BOOL;
157pub extern "kernel32" fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: *c_void) callconv(WINAPI) BOOL;
158158
159pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(.Stdcall) BOOL;
159pub extern "kernel32" fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: ?*const c_void) callconv(WINAPI) BOOL;
160160
161pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(.Stdcall) ?LPVOID;
162pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(.Stdcall) BOOL;
161pub extern "kernel32" fn VirtualAlloc(lpAddress: ?LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD) callconv(WINAPI) ?LPVOID;
162pub extern "kernel32" fn VirtualFree(lpAddress: ?LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) callconv(WINAPI) BOOL;
163163
164164pub extern "kernel32" fn MoveFileExW(
165165 lpExistingFileName: [*:0]const u16,
166166 lpNewFileName: [*:0]const u16,
167167 dwFlags: DWORD,
168) callconv(.Stdcall) BOOL;
168) callconv(WINAPI) BOOL;
169169
170pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(.Stdcall) BOOL;
170pub extern "kernel32" fn PostQueuedCompletionStatus(CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR, lpOverlapped: ?*OVERLAPPED) callconv(WINAPI) BOOL;
171171
172pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
172pub extern "kernel32" fn QueryPerformanceCounter(lpPerformanceCount: *LARGE_INTEGER) callconv(WINAPI) BOOL;
173173
174pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(.Stdcall) BOOL;
174pub extern "kernel32" fn QueryPerformanceFrequency(lpFrequency: *LARGE_INTEGER) callconv(WINAPI) BOOL;
175175
176176pub extern "kernel32" fn ReadDirectoryChangesW(
177177 hDirectory: HANDLE,
......@@ -182,7 +182,7 @@ pub extern "kernel32" fn ReadDirectoryChangesW(
182182 lpBytesReturned: ?*DWORD,
183183 lpOverlapped: ?*OVERLAPPED,
184184 lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
185) callconv(.Stdcall) BOOL;
185) callconv(WINAPI) BOOL;
186186
187187pub extern "kernel32" fn ReadFile(
188188 in_hFile: HANDLE,
......@@ -190,43 +190,43 @@ pub extern "kernel32" fn ReadFile(
190190 in_nNumberOfBytesToRead: DWORD,
191191 out_lpNumberOfBytesRead: ?*DWORD,
192192 in_out_lpOverlapped: ?*OVERLAPPED,
193) callconv(.Stdcall) BOOL;
193) callconv(WINAPI) BOOL;
194194
195pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*:0]const u16) callconv(.Stdcall) BOOL;
195pub extern "kernel32" fn RemoveDirectoryW(lpPathName: [*:0]const u16) callconv(WINAPI) BOOL;
196196
197pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(.Stdcall) BOOL;
197pub extern "kernel32" fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) callconv(WINAPI) BOOL;
198198
199199pub extern "kernel32" fn SetFilePointerEx(
200200 in_fFile: HANDLE,
201201 in_liDistanceToMove: LARGE_INTEGER,
202202 out_opt_ldNewFilePointer: ?*LARGE_INTEGER,
203203 in_dwMoveMethod: DWORD,
204) callconv(.Stdcall) BOOL;
204) callconv(WINAPI) BOOL;
205205
206206pub extern "kernel32" fn SetFileTime(
207207 hFile: HANDLE,
208208 lpCreationTime: ?*const FILETIME,
209209 lpLastAccessTime: ?*const FILETIME,
210210 lpLastWriteTime: ?*const FILETIME,
211) callconv(.Stdcall) BOOL;
211) callconv(WINAPI) BOOL;
212212
213pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(.Stdcall) BOOL;
213pub extern "kernel32" fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) callconv(WINAPI) BOOL;
214214
215pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(.Stdcall) void;
215pub extern "kernel32" fn Sleep(dwMilliseconds: DWORD) callconv(WINAPI) void;
216216
217pub extern "kernel32" fn SwitchToThread() callconv(.Stdcall) BOOL;
217pub extern "kernel32" fn SwitchToThread() callconv(WINAPI) BOOL;
218218
219pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(.Stdcall) BOOL;
219pub extern "kernel32" fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) callconv(WINAPI) BOOL;
220220
221pub extern "kernel32" fn TlsAlloc() callconv(.Stdcall) DWORD;
221pub extern "kernel32" fn TlsAlloc() callconv(WINAPI) DWORD;
222222
223pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(.Stdcall) BOOL;
223pub extern "kernel32" fn TlsFree(dwTlsIndex: DWORD) callconv(WINAPI) BOOL;
224224
225pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
225pub extern "kernel32" fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
226226
227pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(.Stdcall) DWORD;
227pub extern "kernel32" fn WaitForSingleObjectEx(hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL) callconv(WINAPI) DWORD;
228228
229pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(.Stdcall) DWORD;
229pub extern "kernel32" fn WaitForMultipleObjects(nCount: DWORD, lpHandle: [*]const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD) callconv(WINAPI) DWORD;
230230
231231pub extern "kernel32" fn WaitForMultipleObjectsEx(
232232 nCount: DWORD,
......@@ -234,7 +234,7 @@ pub extern "kernel32" fn WaitForMultipleObjectsEx(
234234 bWaitAll: BOOL,
235235 dwMilliseconds: DWORD,
236236 bAlertable: BOOL,
237) callconv(.Stdcall) DWORD;
237) callconv(WINAPI) DWORD;
238238
239239pub extern "kernel32" fn WriteFile(
240240 in_hFile: HANDLE,
......@@ -242,49 +242,49 @@ pub extern "kernel32" fn WriteFile(
242242 in_nNumberOfBytesToWrite: DWORD,
243243 out_lpNumberOfBytesWritten: ?*DWORD,
244244 in_out_lpOverlapped: ?*OVERLAPPED,
245) callconv(.Stdcall) BOOL;
246
247pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(.Stdcall) BOOL;
248
249pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*:0]const u16) callconv(.Stdcall) ?HMODULE;
250
251pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(.Stdcall) ?FARPROC;
252
253pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(.Stdcall) BOOL;
254
255pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
256pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
257pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
258pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(.Stdcall) void;
259
260pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(.Stdcall) BOOL;
261
262pub extern "kernel32" fn K32EmptyWorkingSet(hProcess: HANDLE) callconv(.Stdcall) BOOL;
263pub extern "kernel32" fn K32EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
264pub extern "kernel32" fn K32EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(.Stdcall) BOOL;
265pub extern "kernel32" fn K32EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(.Stdcall) BOOL;
266pub extern "kernel32" fn K32EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
267pub extern "kernel32" fn K32EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(.Stdcall) BOOL;
268pub extern "kernel32" fn K32EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
269pub extern "kernel32" fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
270pub extern "kernel32" fn K32GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
271pub extern "kernel32" fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
272pub extern "kernel32" fn K32GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
273pub extern "kernel32" fn K32GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
274pub extern "kernel32" fn K32GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
275pub extern "kernel32" fn K32GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
276pub extern "kernel32" fn K32GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
277pub extern "kernel32" fn K32GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
278pub extern "kernel32" fn K32GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
279pub extern "kernel32" fn K32GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(.Stdcall) BOOL;
280pub extern "kernel32" fn K32GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;
281pub extern "kernel32" fn K32GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
282pub extern "kernel32" fn K32GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
283pub extern "kernel32" fn K32GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(.Stdcall) BOOL;
284pub extern "kernel32" fn K32GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;
285pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(.Stdcall) BOOL;
286pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(.Stdcall) BOOL;
287pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
288pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
289
290pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(.Stdcall) BOOL;
245) callconv(WINAPI) BOOL;
246
247pub extern "kernel32" fn WriteFileEx(hFile: HANDLE, lpBuffer: [*]const u8, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE) callconv(WINAPI) BOOL;
248
249pub extern "kernel32" fn LoadLibraryW(lpLibFileName: [*:0]const u16) callconv(WINAPI) ?HMODULE;
250
251pub extern "kernel32" fn GetProcAddress(hModule: HMODULE, lpProcName: [*]const u8) callconv(WINAPI) ?FARPROC;
252
253pub extern "kernel32" fn FreeLibrary(hModule: HMODULE) callconv(WINAPI) BOOL;
254
255pub extern "kernel32" fn InitializeCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
256pub extern "kernel32" fn EnterCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
257pub extern "kernel32" fn LeaveCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
258pub extern "kernel32" fn DeleteCriticalSection(lpCriticalSection: *CRITICAL_SECTION) callconv(WINAPI) void;
259
260pub extern "kernel32" fn InitOnceExecuteOnce(InitOnce: *INIT_ONCE, InitFn: INIT_ONCE_FN, Parameter: ?*c_void, Context: ?*c_void) callconv(WINAPI) BOOL;
261
262pub extern "kernel32" fn K32EmptyWorkingSet(hProcess: HANDLE) callconv(WINAPI) BOOL;
263pub extern "kernel32" fn K32EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
264pub extern "kernel32" fn K32EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(WINAPI) BOOL;
265pub extern "kernel32" fn K32EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(WINAPI) BOOL;
266pub extern "kernel32" fn K32EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
267pub extern "kernel32" fn K32EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(WINAPI) BOOL;
268pub extern "kernel32" fn K32EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(WINAPI) BOOL;
269pub extern "kernel32" fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
270pub extern "kernel32" fn K32GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
271pub extern "kernel32" fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
272pub extern "kernel32" fn K32GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
273pub extern "kernel32" fn K32GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
274pub extern "kernel32" fn K32GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
275pub extern "kernel32" fn K32GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
276pub extern "kernel32" fn K32GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
277pub extern "kernel32" fn K32GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
278pub extern "kernel32" fn K32GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
279pub extern "kernel32" fn K32GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(WINAPI) BOOL;
280pub extern "kernel32" fn K32GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
281pub extern "kernel32" fn K32GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
282pub extern "kernel32" fn K32GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
283pub extern "kernel32" fn K32GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(WINAPI) BOOL;
284pub extern "kernel32" fn K32GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
285pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(WINAPI) BOOL;
286pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(WINAPI) BOOL;
287pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
288pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
289
290pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(WINAPI) BOOL;
lib/std/os/windows/ntdll.zig+16-16
......@@ -7,32 +7,32 @@ usingnamespace @import("bits.zig");
77
88pub extern "NtDll" fn RtlGetVersion(
99 lpVersionInformation: PRTL_OSVERSIONINFOW,
10) callconv(.Stdcall) NTSTATUS;
10) callconv(WINAPI) NTSTATUS;
1111pub extern "NtDll" fn RtlCaptureStackBackTrace(
1212 FramesToSkip: DWORD,
1313 FramesToCapture: DWORD,
1414 BackTrace: **c_void,
1515 BackTraceHash: ?*DWORD,
16) callconv(.Stdcall) WORD;
16) callconv(WINAPI) WORD;
1717pub extern "NtDll" fn NtQueryInformationFile(
1818 FileHandle: HANDLE,
1919 IoStatusBlock: *IO_STATUS_BLOCK,
2020 FileInformation: *c_void,
2121 Length: ULONG,
2222 FileInformationClass: FILE_INFORMATION_CLASS,
23) callconv(.Stdcall) NTSTATUS;
23) callconv(WINAPI) NTSTATUS;
2424pub extern "NtDll" fn NtSetInformationFile(
2525 FileHandle: HANDLE,
2626 IoStatusBlock: *IO_STATUS_BLOCK,
2727 FileInformation: PVOID,
2828 Length: ULONG,
2929 FileInformationClass: FILE_INFORMATION_CLASS,
30) callconv(.Stdcall) NTSTATUS;
30) callconv(WINAPI) NTSTATUS;
3131
3232pub extern "NtDll" fn NtQueryAttributesFile(
3333 ObjectAttributes: *OBJECT_ATTRIBUTES,
3434 FileAttributes: *FILE_BASIC_INFORMATION,
35) callconv(.Stdcall) NTSTATUS;
35) callconv(WINAPI) NTSTATUS;
3636
3737pub extern "NtDll" fn NtCreateFile(
3838 FileHandle: *HANDLE,
......@@ -46,7 +46,7 @@ pub extern "NtDll" fn NtCreateFile(
4646 CreateOptions: ULONG,
4747 EaBuffer: ?*c_void,
4848 EaLength: ULONG,
49) callconv(.Stdcall) NTSTATUS;
49) callconv(WINAPI) NTSTATUS;
5050pub extern "NtDll" fn NtDeviceIoControlFile(
5151 FileHandle: HANDLE,
5252 Event: ?HANDLE,
......@@ -58,7 +58,7 @@ pub extern "NtDll" fn NtDeviceIoControlFile(
5858 InputBufferLength: ULONG,
5959 OutputBuffer: ?PVOID,
6060 OutputBufferLength: ULONG,
61) callconv(.Stdcall) NTSTATUS;
61) callconv(WINAPI) NTSTATUS;
6262pub extern "NtDll" fn NtFsControlFile(
6363 FileHandle: HANDLE,
6464 Event: ?HANDLE,
......@@ -70,15 +70,15 @@ pub extern "NtDll" fn NtFsControlFile(
7070 InputBufferLength: ULONG,
7171 OutputBuffer: ?PVOID,
7272 OutputBufferLength: ULONG,
73) callconv(.Stdcall) NTSTATUS;
74pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(.Stdcall) NTSTATUS;
73) callconv(WINAPI) NTSTATUS;
74pub extern "NtDll" fn NtClose(Handle: HANDLE) callconv(WINAPI) NTSTATUS;
7575pub extern "NtDll" fn RtlDosPathNameToNtPathName_U(
7676 DosPathName: [*:0]const u16,
7777 NtPathName: *UNICODE_STRING,
7878 NtFileNamePart: ?*?[*:0]const u16,
7979 DirectoryInfo: ?*CURDIR,
80) callconv(.Stdcall) BOOL;
81pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(.Stdcall) void;
80) callconv(WINAPI) BOOL;
81pub extern "NtDll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(WINAPI) void;
8282
8383pub extern "NtDll" fn NtQueryDirectoryFile(
8484 FileHandle: HANDLE,
......@@ -92,26 +92,26 @@ pub extern "NtDll" fn NtQueryDirectoryFile(
9292 ReturnSingleEntry: BOOLEAN,
9393 FileName: ?*UNICODE_STRING,
9494 RestartScan: BOOLEAN,
95) callconv(.Stdcall) NTSTATUS;
95) callconv(WINAPI) NTSTATUS;
9696pub extern "NtDll" fn NtCreateKeyedEvent(
9797 KeyedEventHandle: *HANDLE,
9898 DesiredAccess: ACCESS_MASK,
9999 ObjectAttributes: ?PVOID,
100100 Flags: ULONG,
101) callconv(.Stdcall) NTSTATUS;
101) callconv(WINAPI) NTSTATUS;
102102pub extern "NtDll" fn NtReleaseKeyedEvent(
103103 EventHandle: HANDLE,
104104 Key: *const c_void,
105105 Alertable: BOOLEAN,
106106 Timeout: ?*LARGE_INTEGER,
107) callconv(.Stdcall) NTSTATUS;
107) callconv(WINAPI) NTSTATUS;
108108pub extern "NtDll" fn NtWaitForKeyedEvent(
109109 EventHandle: HANDLE,
110110 Key: *const c_void,
111111 Alertable: BOOLEAN,
112112 Timeout: ?*LARGE_INTEGER,
113) callconv(.Stdcall) NTSTATUS;
113) callconv(WINAPI) NTSTATUS;
114114
115115pub extern "NtDll" fn RtlSetCurrentDirectory_U(
116116 PathName: *UNICODE_STRING
117) callconv(.Stdcall) NTSTATUS;
117) callconv(WINAPI) NTSTATUS;
lib/std/os/windows/ole32.zig+4-4
......@@ -5,7 +5,7 @@
55// and substantial portions of the software.
66usingnamespace @import("bits.zig");
77
8pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(.Stdcall) void;
9pub extern "ole32" fn CoUninitialize() callconv(.Stdcall) void;
10pub extern "ole32" fn CoGetCurrentProcess() callconv(.Stdcall) DWORD;
11pub extern "ole32" fn CoInitializeEx(pvReserved: ?LPVOID, dwCoInit: DWORD) callconv(.Stdcall) HRESULT;
8pub extern "ole32" fn CoTaskMemFree(pv: LPVOID) callconv(WINAPI) void;
9pub extern "ole32" fn CoUninitialize() callconv(WINAPI) void;
10pub extern "ole32" fn CoGetCurrentProcess() callconv(WINAPI) DWORD;
11pub extern "ole32" fn CoInitializeEx(pvReserved: ?LPVOID, dwCoInit: DWORD) callconv(WINAPI) HRESULT;
lib/std/os/windows/psapi.zig+27-27
......@@ -5,30 +5,30 @@
55// and substantial portions of the software.
66usingnamespace @import("bits.zig");
77
8pub extern "psapi" fn EmptyWorkingSet(hProcess: HANDLE) callconv(.Stdcall) BOOL;
9pub extern "psapi" fn EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
10pub extern "psapi" fn EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(.Stdcall) BOOL;
11pub extern "psapi" fn EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(.Stdcall) BOOL;
12pub extern "psapi" fn EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
13pub extern "psapi" fn EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(.Stdcall) BOOL;
14pub extern "psapi" fn EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(.Stdcall) BOOL;
15pub extern "psapi" fn GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
16pub extern "psapi" fn GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
17pub extern "psapi" fn GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
18pub extern "psapi" fn GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
19pub extern "psapi" fn GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
20pub extern "psapi" fn GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
21pub extern "psapi" fn GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
22pub extern "psapi" fn GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
23pub extern "psapi" fn GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
24pub extern "psapi" fn GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
25pub extern "psapi" fn GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(.Stdcall) BOOL;
26pub extern "psapi" fn GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;
27pub extern "psapi" fn GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
28pub extern "psapi" fn GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(.Stdcall) DWORD;
29pub extern "psapi" fn GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(.Stdcall) BOOL;
30pub extern "psapi" fn GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(.Stdcall) BOOL;
31pub extern "psapi" fn GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(.Stdcall) BOOL;
32pub extern "psapi" fn InitializeProcessForWsWatch(hProcess: HANDLE) callconv(.Stdcall) BOOL;
33pub extern "psapi" fn QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
34pub extern "psapi" fn QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
8pub extern "psapi" fn EmptyWorkingSet(hProcess: HANDLE) callconv(WINAPI) BOOL;
9pub extern "psapi" fn EnumDeviceDrivers(lpImageBase: [*]LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
10pub extern "psapi" fn EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID) callconv(WINAPI) BOOL;
11pub extern "psapi" fn EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID) callconv(WINAPI) BOOL;
12pub extern "psapi" fn EnumProcessModules(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD) callconv(WINAPI) BOOL;
13pub extern "psapi" fn EnumProcessModulesEx(hProcess: HANDLE, lphModule: [*]HMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD) callconv(WINAPI) BOOL;
14pub extern "psapi" fn EnumProcesses(lpidProcess: [*]DWORD, cb: DWORD, cbNeeded: LPDWORD) callconv(WINAPI) BOOL;
15pub extern "psapi" fn GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
16pub extern "psapi" fn GetDeviceDriverBaseNameW(ImageBase: LPVOID, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
17pub extern "psapi" fn GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
18pub extern "psapi" fn GetDeviceDriverFileNameW(ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
19pub extern "psapi" fn GetMappedFileNameA(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
20pub extern "psapi" fn GetMappedFileNameW(hProcess: HANDLE, lpv: ?LPVOID, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
21pub extern "psapi" fn GetModuleBaseNameA(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
22pub extern "psapi" fn GetModuleBaseNameW(hProcess: HANDLE, hModule: ?HMODULE, lpBaseName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
23pub extern "psapi" fn GetModuleFileNameExA(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
24pub extern "psapi" fn GetModuleFileNameExW(hProcess: HANDLE, hModule: ?HMODULE, lpFilename: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
25pub extern "psapi" fn GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD) callconv(WINAPI) BOOL;
26pub extern "psapi" fn GetPerformanceInfo(pPerformanceInformation: PPERFORMACE_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
27pub extern "psapi" fn GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD) callconv(WINAPI) DWORD;
28pub extern "psapi" fn GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD) callconv(WINAPI) DWORD;
29pub extern "psapi" fn GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD) callconv(WINAPI) BOOL;
30pub extern "psapi" fn GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD) callconv(WINAPI) BOOL;
31pub extern "psapi" fn GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD) callconv(WINAPI) BOOL;
32pub extern "psapi" fn InitializeProcessForWsWatch(hProcess: HANDLE) callconv(WINAPI) BOOL;
33pub extern "psapi" fn QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
34pub extern "psapi" fn QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(WINAPI) BOOL;
lib/std/os/windows/shell32.zig+1-1
......@@ -5,4 +5,4 @@
55// and substantial portions of the software.
66usingnamespace @import("bits.zig");
77
8pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*:0]WCHAR) callconv(.Stdcall) HRESULT;
8pub extern "shell32" fn SHGetKnownFolderPath(rfid: *const KNOWNFOLDERID, dwFlags: DWORD, hToken: ?HANDLE, ppszPath: *[*:0]WCHAR) callconv(WINAPI) HRESULT;
lib/std/os/windows/user32.zig+12-12
......@@ -103,7 +103,7 @@ pub const CS_OWNDC = 0x0020;
103103pub const SW_HIDE = 0;
104104pub const SW_SHOW = 5;
105105
106pub const WNDPROC = fn (HWND, UINT, WPARAM, LPARAM) callconv(.Stdcall) LRESULT;
106pub const WNDPROC = fn (HWND, UINT, WPARAM, LPARAM) callconv(WINAPI) LRESULT;
107107
108108pub const WNDCLASSEXA = extern struct {
109109 cbSize: UINT = @sizeOf(WNDCLASSEXA),
......@@ -147,13 +147,13 @@ pub extern "user32" fn CreateWindowExA(
147147 hMenu: ?HMENU,
148148 hInstance: HINSTANCE,
149149 lpParam: ?LPVOID,
150) callconv(.Stdcall) ?HWND;
150) callconv(WINAPI) ?HWND;
151151
152pub extern "user32" fn RegisterClassExA(*const WNDCLASSEXA) callconv(.Stdcall) c_ushort;
153pub extern "user32" fn DefWindowProcA(HWND, Msg: UINT, WPARAM, LPARAM) callconv(.Stdcall) LRESULT;
154pub extern "user32" fn ShowWindow(hWnd: ?HWND, nCmdShow: i32) callconv(.Stdcall) bool;
155pub extern "user32" fn UpdateWindow(hWnd: ?HWND) callconv(.Stdcall) bool;
156pub extern "user32" fn GetDC(hWnd: ?HWND) callconv(.Stdcall) ?HDC;
152pub extern "user32" fn RegisterClassExA(*const WNDCLASSEXA) callconv(WINAPI) c_ushort;
153pub extern "user32" fn DefWindowProcA(HWND, Msg: UINT, WPARAM, LPARAM) callconv(WINAPI) LRESULT;
154pub extern "user32" fn ShowWindow(hWnd: ?HWND, nCmdShow: i32) callconv(WINAPI) bool;
155pub extern "user32" fn UpdateWindow(hWnd: ?HWND) callconv(WINAPI) bool;
156pub extern "user32" fn GetDC(hWnd: ?HWND) callconv(WINAPI) ?HDC;
157157
158158pub extern "user32" fn PeekMessageA(
159159 lpMsg: ?*MSG,
......@@ -161,15 +161,15 @@ pub extern "user32" fn PeekMessageA(
161161 wMsgFilterMin: UINT,
162162 wMsgFilterMax: UINT,
163163 wRemoveMsg: UINT,
164) callconv(.Stdcall) bool;
164) callconv(WINAPI) bool;
165165
166166pub extern "user32" fn GetMessageA(
167167 lpMsg: ?*MSG,
168168 hWnd: ?HWND,
169169 wMsgFilterMin: UINT,
170170 wMsgFilterMax: UINT,
171) callconv(.Stdcall) bool;
171) callconv(WINAPI) bool;
172172
173pub extern "user32" fn TranslateMessage(lpMsg: *const MSG) callconv(.Stdcall) bool;
174pub extern "user32" fn DispatchMessageA(lpMsg: *const MSG) callconv(.Stdcall) LRESULT;
175pub extern "user32" fn PostQuitMessage(nExitCode: i32) callconv(.Stdcall) void;
173pub extern "user32" fn TranslateMessage(lpMsg: *const MSG) callconv(WINAPI) bool;
174pub extern "user32" fn DispatchMessageA(lpMsg: *const MSG) callconv(WINAPI) LRESULT;
175pub extern "user32" fn PostQuitMessage(nExitCode: i32) callconv(WINAPI) void;
lib/std/os/windows/ws2_32.zig+21-21
......@@ -756,9 +756,9 @@ pub const TCP_NODELAY = 0x0001;
756756pub extern "ws2_32" fn WSAStartup(
757757 wVersionRequired: WORD,
758758 lpWSAData: *WSADATA,
759) callconv(.Stdcall) c_int;
760pub extern "ws2_32" fn WSACleanup() callconv(.Stdcall) c_int;
761pub extern "ws2_32" fn WSAGetLastError() callconv(.Stdcall) WinsockError;
759) callconv(WINAPI) c_int;
760pub extern "ws2_32" fn WSACleanup() callconv(WINAPI) c_int;
761pub extern "ws2_32" fn WSAGetLastError() callconv(WINAPI) WinsockError;
762762pub extern "ws2_32" fn WSASocketA(
763763 af: c_int,
764764 type: c_int,
......@@ -766,7 +766,7 @@ pub extern "ws2_32" fn WSASocketA(
766766 lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
767767 g: GROUP,
768768 dwFlags: DWORD,
769) callconv(.Stdcall) SOCKET;
769) callconv(WINAPI) SOCKET;
770770pub extern "ws2_32" fn WSASocketW(
771771 af: c_int,
772772 type: c_int,
......@@ -774,8 +774,8 @@ pub extern "ws2_32" fn WSASocketW(
774774 lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
775775 g: GROUP,
776776 dwFlags: DWORD,
777) callconv(.Stdcall) SOCKET;
778pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(.Stdcall) c_int;
777) callconv(WINAPI) SOCKET;
778pub extern "ws2_32" fn closesocket(s: SOCKET) callconv(WINAPI) c_int;
779779pub extern "ws2_32" fn WSAIoctl(
780780 s: SOCKET,
781781 dwIoControlCode: DWORD,
......@@ -786,26 +786,26 @@ pub extern "ws2_32" fn WSAIoctl(
786786 lpcbBytesReturned: LPDWORD,
787787 lpOverlapped: ?*WSAOVERLAPPED,
788788 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
789) callconv(.Stdcall) c_int;
789) callconv(WINAPI) c_int;
790790pub extern "ws2_32" fn accept(
791791 s: SOCKET,
792792 addr: ?*sockaddr,
793793 addrlen: ?*c_int,
794) callconv(.Stdcall) SOCKET;
794) callconv(WINAPI) SOCKET;
795795pub extern "ws2_32" fn bind(
796796 s: SOCKET,
797797 addr: ?*const sockaddr,
798798 addrlen: c_int,
799) callconv(.Stdcall) c_int;
799) callconv(WINAPI) c_int;
800800pub extern "ws2_32" fn connect(
801801 s: SOCKET,
802802 name: *const sockaddr,
803803 namelen: c_int,
804) callconv(.Stdcall) c_int;
804) callconv(WINAPI) c_int;
805805pub extern "ws2_32" fn listen(
806806 s: SOCKET,
807807 backlog: c_int,
808) callconv(.Stdcall) c_int;
808) callconv(WINAPI) c_int;
809809pub extern "ws2_32" fn WSARecv(
810810 s: SOCKET,
811811 lpBuffers: [*]const WSABUF,
......@@ -814,7 +814,7 @@ pub extern "ws2_32" fn WSARecv(
814814 lpFlags: *DWORD,
815815 lpOverlapped: ?*WSAOVERLAPPED,
816816 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
817) callconv(.Stdcall) c_int;
817) callconv(WINAPI) c_int;
818818pub extern "ws2_32" fn WSARecvFrom(
819819 s: SOCKET,
820820 lpBuffers: [*]const WSABUF,
......@@ -825,7 +825,7 @@ pub extern "ws2_32" fn WSARecvFrom(
825825 lpFromlen: ?*socklen_t,
826826 lpOverlapped: ?*WSAOVERLAPPED,
827827 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
828) callconv(.Stdcall) c_int;
828) callconv(WINAPI) c_int;
829829pub extern "ws2_32" fn WSASend(
830830 s: SOCKET,
831831 lpBuffers: [*]WSABUF,
......@@ -834,7 +834,7 @@ pub extern "ws2_32" fn WSASend(
834834 dwFlags: DWORD,
835835 lpOverlapped: ?*WSAOVERLAPPED,
836836 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
837) callconv(.Stdcall) c_int;
837) callconv(WINAPI) c_int;
838838pub extern "ws2_32" fn WSASendTo(
839839 s: SOCKET,
840840 lpBuffers: [*]WSABUF,
......@@ -845,35 +845,35 @@ pub extern "ws2_32" fn WSASendTo(
845845 iTolen: c_int,
846846 lpOverlapped: ?*WSAOVERLAPPED,
847847 lpCompletionRoutine: ?WSAOVERLAPPED_COMPLETION_ROUTINE,
848) callconv(.Stdcall) c_int;
848) callconv(WINAPI) c_int;
849849pub extern "ws2_32" fn WSAPoll(
850850 fdArray: [*]pollfd,
851851 fds: c_ulong,
852852 timeout: c_int,
853) callconv(.Stdcall) c_int;
853) callconv(WINAPI) c_int;
854854pub extern "ws2_32" fn getaddrinfo(
855855 pNodeName: [*:0]const u8,
856856 pServiceName: [*:0]const u8,
857857 pHints: *const addrinfo,
858858 ppResult: **addrinfo,
859) callconv(.Stdcall) i32;
859) callconv(WINAPI) i32;
860860pub extern "ws2_32" fn freeaddrinfo(
861861 pAddrInfo: *addrinfo,
862) callconv(.Stdcall) void;
862) callconv(WINAPI) void;
863863pub extern "ws2_32" fn ioctlsocket(
864864 s: SOCKET,
865865 cmd: c_long,
866866 argp: *c_ulong,
867) callconv(.Stdcall) c_int;
867) callconv(WINAPI) c_int;
868868pub extern "ws2_32" fn getsockname(
869869 s: SOCKET,
870870 name: *sockaddr,
871871 namelen: *c_int,
872) callconv(.Stdcall) c_int;
872) callconv(WINAPI) c_int;
873873pub extern "ws2_32" fn setsockopt(
874874 s: SOCKET,
875875 level: u32,
876876 optname: u32,
877877 optval: ?*const c_void,
878878 optlen: socklen_t,
879) callconv(.Stdcall) c_int;
879) callconv(WINAPI) c_int;
lib/std/start.zig+3-3
......@@ -53,7 +53,7 @@ fn _DllMainCRTStartup(
5353 hinstDLL: std.os.windows.HINSTANCE,
5454 fdwReason: std.os.windows.DWORD,
5555 lpReserved: std.os.windows.LPVOID,
56) callconv(.Stdcall) std.os.windows.BOOL {
56) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
5757 if (!builtin.single_threaded and !builtin.link_libc) {
5858 _ = @import("start_windows_tls.zig");
5959 }
......@@ -162,7 +162,7 @@ fn _start() callconv(.Naked) noreturn {
162162 @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
163163}
164164
165fn WinStartup() callconv(.Stdcall) noreturn {
165fn WinStartup() callconv(std.os.windows.WINAPI) noreturn {
166166 @setAlignStack(16);
167167 if (!builtin.single_threaded) {
168168 _ = @import("start_windows_tls.zig");
......@@ -173,7 +173,7 @@ fn WinStartup() callconv(.Stdcall) noreturn {
173173 std.os.windows.kernel32.ExitProcess(initEventLoopAndCallMain());
174174}
175175
176fn wWinMainCRTStartup() callconv(.Stdcall) noreturn {
176fn wWinMainCRTStartup() callconv(std.os.windows.WINAPI) noreturn {
177177 @setAlignStack(16);
178178 if (!builtin.single_threaded) {
179179 _ = @import("start_windows_tls.zig");
src/stage1/analyze.cpp+63-4
......@@ -971,9 +971,9 @@ const char *calling_convention_name(CallingConvention cc) {
971971 case CallingConventionFastcall: return "Fastcall";
972972 case CallingConventionVectorcall: return "Vectorcall";
973973 case CallingConventionThiscall: return "Thiscall";
974 case CallingConventionAPCS: return "Apcs";
975 case CallingConventionAAPCS: return "Aapcs";
976 case CallingConventionAAPCSVFP: return "Aapcsvfp";
974 case CallingConventionAPCS: return "APCS";
975 case CallingConventionAAPCS: return "AAPCS";
976 case CallingConventionAAPCSVFP: return "AAPCSVFP";
977977 }
978978 zig_unreachable();
979979}
......@@ -1880,6 +1880,58 @@ ZigType *get_auto_err_set_type(CodeGen *g, ZigFn *fn_entry) {
18801880 return err_set_type;
18811881}
18821882
1883// Sync this with get_llvm_cc in codegen.cpp
1884static Error emit_error_unless_callconv_allowed_for_target(CodeGen *g, AstNode *source_node, CallingConvention cc) {
1885 Error ret = ErrorNone;
1886 const char *allowed_platforms = nullptr;
1887 switch (cc) {
1888 case CallingConventionUnspecified:
1889 case CallingConventionC:
1890 case CallingConventionNaked:
1891 case CallingConventionAsync:
1892 break;
1893 case CallingConventionInterrupt:
1894 if (g->zig_target->arch != ZigLLVM_x86
1895 && g->zig_target->arch != ZigLLVM_x86_64
1896 && g->zig_target->arch != ZigLLVM_avr
1897 && g->zig_target->arch != ZigLLVM_msp430)
1898 {
1899 allowed_platforms = "x86, x86_64, AVR, and MSP430";
1900 }
1901 break;
1902 case CallingConventionSignal:
1903 if (g->zig_target->arch != ZigLLVM_avr)
1904 allowed_platforms = "AVR";
1905 break;
1906 case CallingConventionStdcall:
1907 case CallingConventionFastcall:
1908 case CallingConventionThiscall:
1909 if (g->zig_target->arch != ZigLLVM_x86)
1910 allowed_platforms = "x86";
1911 break;
1912 case CallingConventionVectorcall:
1913 if (g->zig_target->arch != ZigLLVM_x86
1914 && !(target_is_arm(g->zig_target) && target_arch_pointer_bit_width(g->zig_target->arch) == 64))
1915 {
1916 allowed_platforms = "x86 and AArch64";
1917 }
1918 break;
1919 case CallingConventionAPCS:
1920 case CallingConventionAAPCS:
1921 case CallingConventionAAPCSVFP:
1922 if (!target_is_arm(g->zig_target))
1923 allowed_platforms = "ARM";
1924 }
1925 if (allowed_platforms != nullptr) {
1926 add_node_error(g, source_node, buf_sprintf(
1927 "callconv '%s' is only available on %s, not %s",
1928 calling_convention_name(cc), allowed_platforms,
1929 target_arch_name(g->zig_target->arch)));
1930 ret = ErrorSemanticAnalyzeFail;
1931 }
1932 return ret;
1933}
1934
18831935static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, ZigFn *fn_entry,
18841936 CallingConvention cc)
18851937{
......@@ -2014,6 +2066,9 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
20142066 fn_entry->align_bytes = fn_type_id.alignment;
20152067 }
20162068
2069 if ((err = emit_error_unless_callconv_allowed_for_target(g, proto_node->data.fn_proto.callconv_expr, cc)))
2070 return g->builtin_types.entry_invalid;
2071
20172072 if (fn_proto->return_anytype_token != nullptr) {
20182073 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
20192074 add_node_error(g, fn_proto->return_type,
......@@ -3577,9 +3632,13 @@ void add_var_export(CodeGen *g, ZigVar *var, const char *symbol_name, GlobalLink
35773632}
35783633
35793634void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage, CallingConvention cc) {
3635 CallingConvention winapi_cc = g->zig_target->arch == ZigLLVM_x86
3636 ? CallingConventionStdcall
3637 : CallingConventionC;
3638
35803639 if (cc == CallingConventionC && strcmp(symbol_name, "main") == 0 && g->link_libc) {
35813640 g->stage1.have_c_main = true;
3582 } else if (cc == CallingConventionStdcall && g->zig_target->os == OsWindows) {
3641 } else if (cc == winapi_cc && g->zig_target->os == OsWindows) {
35833642 if (strcmp(symbol_name, "WinMain") == 0) {
35843643 g->stage1.have_winmain = true;
35853644 } else if (strcmp(symbol_name, "wWinMain") == 0) {
src/stage1/codegen.cpp+17-23
......@@ -155,6 +155,7 @@ static const char *get_mangled_name(CodeGen *g, const char *original_name) {
155155 }
156156}
157157
158// Sync this with emit_error_unless_callconv_allowed_for_target in analyze.cpp
158159static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
159160 switch (cc) {
160161 case CallingConventionUnspecified:
......@@ -164,38 +165,32 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
164165 case CallingConventionNaked:
165166 zig_unreachable();
166167 case CallingConventionStdcall:
167 if (g->zig_target->arch == ZigLLVM_x86)
168 return ZigLLVM_X86_StdCall;
169 return ZigLLVM_C;
168 assert(g->zig_target->arch == ZigLLVM_x86);
169 return ZigLLVM_X86_StdCall;
170170 case CallingConventionFastcall:
171 if (g->zig_target->arch == ZigLLVM_x86)
172 return ZigLLVM_X86_FastCall;
173 return ZigLLVM_C;
171 assert(g->zig_target->arch == ZigLLVM_x86);
172 return ZigLLVM_X86_FastCall;
174173 case CallingConventionVectorcall:
175174 if (g->zig_target->arch == ZigLLVM_x86)
176175 return ZigLLVM_X86_VectorCall;
177176 if (target_is_arm(g->zig_target) &&
178177 target_arch_pointer_bit_width(g->zig_target->arch) == 64)
179178 return ZigLLVM_AArch64_VectorCall;
180 return ZigLLVM_C;
179 zig_unreachable();
181180 case CallingConventionThiscall:
182 if (g->zig_target->arch == ZigLLVM_x86)
183 return ZigLLVM_X86_ThisCall;
184 return ZigLLVM_C;
181 assert(g->zig_target->arch == ZigLLVM_x86);
182 return ZigLLVM_X86_ThisCall;
185183 case CallingConventionAsync:
186184 return ZigLLVM_Fast;
187185 case CallingConventionAPCS:
188 if (target_is_arm(g->zig_target))
189 return ZigLLVM_ARM_APCS;
190 return ZigLLVM_C;
186 assert(target_is_arm(g->zig_target));
187 return ZigLLVM_ARM_APCS;
191188 case CallingConventionAAPCS:
192 if (target_is_arm(g->zig_target))
193 return ZigLLVM_ARM_AAPCS;
194 return ZigLLVM_C;
189 assert(target_is_arm(g->zig_target));
190 return ZigLLVM_ARM_AAPCS;
195191 case CallingConventionAAPCSVFP:
196 if (target_is_arm(g->zig_target))
197 return ZigLLVM_ARM_AAPCS_VFP;
198 return ZigLLVM_C;
192 assert(target_is_arm(g->zig_target));
193 return ZigLLVM_ARM_AAPCS_VFP;
199194 case CallingConventionInterrupt:
200195 if (g->zig_target->arch == ZigLLVM_x86 ||
201196 g->zig_target->arch == ZigLLVM_x86_64)
......@@ -204,11 +199,10 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
204199 return ZigLLVM_AVR_INTR;
205200 if (g->zig_target->arch == ZigLLVM_msp430)
206201 return ZigLLVM_MSP430_INTR;
207 return ZigLLVM_C;
202 zig_unreachable();
208203 case CallingConventionSignal:
209 if (g->zig_target->arch == ZigLLVM_avr)
210 return ZigLLVM_AVR_SIGNAL;
211 return ZigLLVM_C;
204 assert(g->zig_target->arch == ZigLLVM_avr);
205 return ZigLLVM_AVR_SIGNAL;
212206 }
213207 zig_unreachable();
214208}
test/compile_errors.zig+78
......@@ -57,6 +57,84 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
5757 "tmp.zig:1:22: note: type u2 cannot fit values in range 0...4",
5858 });
5959
60 cases.addCase(x: {
61 var tc = cases.create("callconv(.Interrupt) on unsupported platform",
62 \\export fn entry() callconv(.Interrupt) void {}
63 , &[_][]const u8{
64 "tmp.zig:1:28: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64",
65 });
66 tc.target = std.zig.CrossTarget{
67 .cpu_arch = .aarch64,
68 .os_tag = .linux,
69 .abi = .none,
70 };
71 break :x tc;
72 });
73
74 cases.addCase(x: {
75 var tc = cases.create("callconv(.Signal) on unsupported platform",
76 \\export fn entry() callconv(.Signal) void {}
77 , &[_][]const u8{
78 "tmp.zig:1:28: error: callconv 'Signal' is only available on AVR, not x86_64",
79 });
80 tc.target = std.zig.CrossTarget{
81 .cpu_arch = .x86_64,
82 .os_tag = .linux,
83 .abi = .none,
84 };
85 break :x tc;
86 });
87
88 cases.addCase(x: {
89 var tc = cases.create("callconv(.Stdcall, .Fastcall, .Thiscall) on unsupported platform",
90 \\export fn entry1() callconv(.Stdcall) void {}
91 \\export fn entry2() callconv(.Fastcall) void {}
92 \\export fn entry3() callconv(.Thiscall) void {}
93 , &[_][]const u8{
94 "tmp.zig:1:29: error: callconv 'Stdcall' is only available on x86, not x86_64",
95 "tmp.zig:2:29: error: callconv 'Fastcall' is only available on x86, not x86_64",
96 "tmp.zig:3:29: error: callconv 'Thiscall' is only available on x86, not x86_64",
97 });
98 tc.target = std.zig.CrossTarget{
99 .cpu_arch = .x86_64,
100 .os_tag = .linux,
101 .abi = .none,
102 };
103 break :x tc;
104 });
105
106 cases.addCase(x: {
107 var tc = cases.create("callconv(.Vectorcall) on unsupported platform",
108 \\export fn entry() callconv(.Vectorcall) void {}
109 , &[_][]const u8{
110 "tmp.zig:1:28: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64",
111 });
112 tc.target = std.zig.CrossTarget{
113 .cpu_arch = .x86_64,
114 .os_tag = .linux,
115 .abi = .none,
116 };
117 break :x tc;
118 });
119
120 cases.addCase(x: {
121 var tc = cases.create("callconv(.APCS, .AAPCS, .AAPCSVFP) on unsupported platform",
122 \\export fn entry1() callconv(.APCS) void {}
123 \\export fn entry2() callconv(.AAPCS) void {}
124 \\export fn entry3() callconv(.AAPCSVFP) void {}
125 , &[_][]const u8{
126 "tmp.zig:1:29: error: callconv 'APCS' is only available on ARM, not x86_64",
127 "tmp.zig:2:29: error: callconv 'AAPCS' is only available on ARM, not x86_64",
128 "tmp.zig:3:29: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64",
129 });
130 tc.target = std.zig.CrossTarget{
131 .cpu_arch = .x86_64,
132 .os_tag = .linux,
133 .abi = .none,
134 };
135 break :x tc;
136 });
137
60138 cases.add("unreachable executed at comptime",
61139 \\fn foo(comptime x: i32) i32 {
62140 \\ comptime {
test/stage1/behavior/fn.zig+2-2
......@@ -189,9 +189,9 @@ test "return inner function which references comptime variable of outer function
189189
190190test "extern struct with stdcallcc fn pointer" {
191191 const S = extern struct {
192 ptr: fn () callconv(.Stdcall) i32,
192 ptr: fn () callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32,
193193
194 fn foo() callconv(.Stdcall) i32 {
194 fn foo() callconv(if (std.builtin.arch == .i386) .Stdcall else .C) i32 {
195195 return 1234;
196196 }
197197 };