#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#include "pycore_long.h" // _PyLong_Size_t_Converter()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(_winapi_Overlapped_GetOverlappedResult__doc__,

"\n");

#define _WINAPI_OVERLAPPED_GETOVERLAPPEDRESULT_METHODDEF \

{"GetOverlappedResult", (PyCFunction)_winapi_Overlapped_GetOverlappedResult, METH_O, _winapi_Overlapped_GetOverlappedResult__doc__},

static PyObject *

_winapi_Overlapped_GetOverlappedResult_impl(OverlappedObject *self, int wait);

static PyObject *

_winapi_Overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *arg)

{

PyObject *return_value = NULL;

int wait;

wait = PyObject_IsTrue(arg);

if (wait < 0) {

goto exit;

}

return_value = _winapi_Overlapped_GetOverlappedResult_impl(self, wait);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_Overlapped_getbuffer__doc__,

"\n");

#define _WINAPI_OVERLAPPED_GETBUFFER_METHODDEF \

{"getbuffer", (PyCFunction)_winapi_Overlapped_getbuffer, METH_NOARGS, _winapi_Overlapped_getbuffer__doc__},

static PyObject *

_winapi_Overlapped_getbuffer_impl(OverlappedObject *self);

static PyObject *

_winapi_Overlapped_getbuffer(OverlappedObject *self, PyObject *Py_UNUSED(ignored))

{

return _winapi_Overlapped_getbuffer_impl(self);

}

PyDoc_STRVAR(_winapi_Overlapped_cancel__doc__,

"\n");

#define _WINAPI_OVERLAPPED_CANCEL_METHODDEF \

{"cancel", (PyCFunction)_winapi_Overlapped_cancel, METH_NOARGS, _winapi_Overlapped_cancel__doc__},

static PyObject *

_winapi_Overlapped_cancel_impl(OverlappedObject *self);

static PyObject *

_winapi_Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))

{

return _winapi_Overlapped_cancel_impl(self);

}

PyDoc_STRVAR(_winapi_CloseHandle__doc__,

"Close handle.");

#define _WINAPI_CLOSEHANDLE_METHODDEF \

{"CloseHandle", (PyCFunction)_winapi_CloseHandle, METH_O, _winapi_CloseHandle__doc__},

static PyObject *

_winapi_CloseHandle_impl(PyObject *module, HANDLE handle);

static PyObject *

_winapi_CloseHandle(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

HANDLE handle;

if (!PyArg_Parse(arg, "" F_HANDLE ":CloseHandle", &handle)) {

goto exit;

}

return_value = _winapi_CloseHandle_impl(module, handle);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_ConnectNamedPipe__doc__,

"\n");

#define _WINAPI_CONNECTNAMEDPIPE_METHODDEF \

{"ConnectNamedPipe", _PyCFunction_CAST(_winapi_ConnectNamedPipe), METH_FASTCALL|METH_KEYWORDS, _winapi_ConnectNamedPipe__doc__},

static PyObject *

_winapi_ConnectNamedPipe_impl(PyObject *module, HANDLE handle,

int use_overlapped);

static PyObject *

_winapi_ConnectNamedPipe(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(handle), &_Py_ID(overlapped), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"handle", "overlapped", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.format = "" F_HANDLE "|p:ConnectNamedPipe",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

HANDLE handle;

int use_overlapped = 0;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

&handle, &use_overlapped)) {

goto exit;

}

return_value = _winapi_ConnectNamedPipe_impl(module, handle, use_overlapped);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_CreateFile__doc__,

"\n");

#define _WINAPI_CREATEFILE_METHODDEF \

{"CreateFile", _PyCFunction_CAST(_winapi_CreateFile), METH_FASTCALL, _winapi_CreateFile__doc__},

static HANDLE

_winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,

DWORD flags_and_attributes, HANDLE template_file);

static PyObject *

_winapi_CreateFile(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

LPCTSTR file_name;

DWORD desired_access;

DWORD share_mode;

LPSECURITY_ATTRIBUTES security_attributes;

DWORD creation_disposition;

DWORD flags_and_attributes;

HANDLE template_file;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "skk" F_POINTER "kk" F_HANDLE ":CreateFile",

&file_name, &desired_access, &share_mode, &security_attributes, &creation_disposition, &flags_and_attributes, &template_file)) {

goto exit;

}

_return_value = _winapi_CreateFile_impl(module, file_name, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_CreateFileMapping__doc__,

"\n");

#define _WINAPI_CREATEFILEMAPPING_METHODDEF \

{"CreateFileMapping", _PyCFunction_CAST(_winapi_CreateFileMapping), METH_FASTCALL, _winapi_CreateFileMapping__doc__},

static HANDLE

_winapi_CreateFileMapping_impl(PyObject *module, HANDLE file_handle,

LPSECURITY_ATTRIBUTES security_attributes,

DWORD protect, DWORD max_size_high,

DWORD max_size_low, LPCWSTR name);

static PyObject *

_winapi_CreateFileMapping(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HANDLE file_handle;

LPSECURITY_ATTRIBUTES security_attributes;

DWORD protect;

DWORD max_size_high;

DWORD max_size_low;

LPCWSTR name = NULL;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "" F_POINTER "kkkO&:CreateFileMapping",

&file_handle, &security_attributes, &protect, &max_size_high, &max_size_low, _PyUnicode_WideCharString_Converter, &name)) {

goto exit;

}

_return_value = _winapi_CreateFileMapping_impl(module, file_handle, security_attributes, protect, max_size_high, max_size_low, name);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

/* Cleanup for name */

PyMem_Free((void *)name);

return return_value;

}

PyDoc_STRVAR(_winapi_CreateJunction__doc__,

"\n");

#define _WINAPI_CREATEJUNCTION_METHODDEF \

{"CreateJunction", _PyCFunction_CAST(_winapi_CreateJunction), METH_FASTCALL, _winapi_CreateJunction__doc__},

static PyObject *

_winapi_CreateJunction_impl(PyObject *module, LPCWSTR src_path,

LPCWSTR dst_path);

static PyObject *

_winapi_CreateJunction(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

LPCWSTR src_path = NULL;

LPCWSTR dst_path = NULL;

if (!_PyArg_CheckPositional("CreateJunction", nargs, 2, 2)) {

goto exit;

}

if (!PyUnicode_Check(args[0])) {

_PyArg_BadArgument("CreateJunction", "argument 1", "str", args[0]);

goto exit;

}

src_path = PyUnicode_AsWideCharString(args[0], NULL);

if (src_path == NULL) {

goto exit;

}

if (!PyUnicode_Check(args[1])) {

_PyArg_BadArgument("CreateJunction", "argument 2", "str", args[1]);

goto exit;

}

dst_path = PyUnicode_AsWideCharString(args[1], NULL);

if (dst_path == NULL) {

goto exit;

}

return_value = _winapi_CreateJunction_impl(module, src_path, dst_path);

exit:

/* Cleanup for src_path */

PyMem_Free((void *)src_path);

/* Cleanup for dst_path */

PyMem_Free((void *)dst_path);

return return_value;

}

PyDoc_STRVAR(_winapi_CreateNamedPipe__doc__,

"\n");

#define _WINAPI_CREATENAMEDPIPE_METHODDEF \

{"CreateNamedPipe", _PyCFunction_CAST(_winapi_CreateNamedPipe), METH_FASTCALL, _winapi_CreateNamedPipe__doc__},

static HANDLE

_winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,

LPSECURITY_ATTRIBUTES security_attributes);

static PyObject *

_winapi_CreateNamedPipe(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

LPCTSTR name;

DWORD open_mode;

DWORD pipe_mode;

DWORD max_instances;

DWORD out_buffer_size;

DWORD in_buffer_size;

DWORD default_timeout;

LPSECURITY_ATTRIBUTES security_attributes;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "skkkkkk" F_POINTER ":CreateNamedPipe",

&name, &open_mode, &pipe_mode, &max_instances, &out_buffer_size, &in_buffer_size, &default_timeout, &security_attributes)) {

goto exit;

}

_return_value = _winapi_CreateNamedPipe_impl(module, name, open_mode, pipe_mode, max_instances, out_buffer_size, in_buffer_size, default_timeout, security_attributes);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_CreatePipe__doc__,

"Returns a 2-tuple of handles, to the read and write ends of the pipe.");

#define _WINAPI_CREATEPIPE_METHODDEF \

{"CreatePipe", _PyCFunction_CAST(_winapi_CreatePipe), METH_FASTCALL, _winapi_CreatePipe__doc__},

static PyObject *

_winapi_CreatePipe_impl(PyObject *module, PyObject *pipe_attrs, DWORD size);

static PyObject *

_winapi_CreatePipe(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *pipe_attrs;

DWORD size;

if (!_PyArg_ParseStack(args, nargs, "Ok:CreatePipe",

&pipe_attrs, &size)) {

goto exit;

}

return_value = _winapi_CreatePipe_impl(module, pipe_attrs, size);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_CreateProcess__doc__,

"process ID, and thread ID.");

#define _WINAPI_CREATEPROCESS_METHODDEF \

{"CreateProcess", _PyCFunction_CAST(_winapi_CreateProcess), METH_FASTCALL, _winapi_CreateProcess__doc__},

static PyObject *

_winapi_CreateProcess_impl(PyObject *module, const wchar_t *application_name,

PyObject *startup_info);

static PyObject *

_winapi_CreateProcess(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

const wchar_t *application_name = NULL;

PyObject *command_line;

PyObject *proc_attrs;

PyObject *thread_attrs;

BOOL inherit_handles;

DWORD creation_flags;

PyObject *env_mapping;

const wchar_t *current_directory = NULL;

PyObject *startup_info;

if (!_PyArg_ParseStack(args, nargs, "O&OOOikOO&O:CreateProcess",

_PyUnicode_WideCharString_Opt_Converter, &application_name, &command_line, &proc_attrs, &thread_attrs, &inherit_handles, &creation_flags, &env_mapping, _PyUnicode_WideCharString_Opt_Converter, &current_directory, &startup_info)) {

goto exit;

}

return_value = _winapi_CreateProcess_impl(module, application_name, command_line, proc_attrs, thread_attrs, inherit_handles, creation_flags, env_mapping, current_directory, startup_info);

exit:

/* Cleanup for application_name */

PyMem_Free((void *)application_name);

/* Cleanup for current_directory */

PyMem_Free((void *)current_directory);

return return_value;

}

PyDoc_STRVAR(_winapi_DuplicateHandle__doc__,

"through both handles.");

#define _WINAPI_DUPLICATEHANDLE_METHODDEF \

{"DuplicateHandle", _PyCFunction_CAST(_winapi_DuplicateHandle), METH_FASTCALL, _winapi_DuplicateHandle__doc__},

static HANDLE

_winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,

DWORD options);

static PyObject *

_winapi_DuplicateHandle(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HANDLE source_process_handle;

HANDLE source_handle;

HANDLE target_process_handle;

DWORD desired_access;

BOOL inherit_handle;

DWORD options = 0;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "" F_HANDLE "" F_HANDLE "ki|k:DuplicateHandle",

&source_process_handle, &source_handle, &target_process_handle, &desired_access, &inherit_handle, &options)) {

goto exit;

}

_return_value = _winapi_DuplicateHandle_impl(module, source_process_handle, source_handle, target_process_handle, desired_access, inherit_handle, options);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_ExitProcess__doc__,

"\n");

#define _WINAPI_EXITPROCESS_METHODDEF \

{"ExitProcess", (PyCFunction)_winapi_ExitProcess, METH_O, _winapi_ExitProcess__doc__},

static PyObject *

_winapi_ExitProcess_impl(PyObject *module, UINT ExitCode);

static PyObject *

_winapi_ExitProcess(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

UINT ExitCode;

if (!PyArg_Parse(arg, "I:ExitProcess", &ExitCode)) {

goto exit;

}

return_value = _winapi_ExitProcess_impl(module, ExitCode);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetCurrentProcess__doc__,

"Return a handle object for the current process.");

#define _WINAPI_GETCURRENTPROCESS_METHODDEF \

{"GetCurrentProcess", (PyCFunction)_winapi_GetCurrentProcess, METH_NOARGS, _winapi_GetCurrentProcess__doc__},

static HANDLE

_winapi_GetCurrentProcess_impl(PyObject *module);

static PyObject *

_winapi_GetCurrentProcess(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

HANDLE _return_value;

_return_value = _winapi_GetCurrentProcess_impl(module);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetExitCodeProcess__doc__,

"Return the termination status of the specified process.");

#define _WINAPI_GETEXITCODEPROCESS_METHODDEF \

{"GetExitCodeProcess", (PyCFunction)_winapi_GetExitCodeProcess, METH_O, _winapi_GetExitCodeProcess__doc__},

static DWORD

_winapi_GetExitCodeProcess_impl(PyObject *module, HANDLE process);

static PyObject *

_winapi_GetExitCodeProcess(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

HANDLE process;

DWORD _return_value;

if (!PyArg_Parse(arg, "" F_HANDLE ":GetExitCodeProcess", &process)) {

goto exit;

}

_return_value = _winapi_GetExitCodeProcess_impl(module, process);

if ((_return_value == PY_DWORD_MAX) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromUnsignedLong(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetLastError__doc__,

"\n");

#define _WINAPI_GETLASTERROR_METHODDEF \

{"GetLastError", (PyCFunction)_winapi_GetLastError, METH_NOARGS, _winapi_GetLastError__doc__},

static DWORD

_winapi_GetLastError_impl(PyObject *module);

static PyObject *

_winapi_GetLastError(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

DWORD _return_value;

_return_value = _winapi_GetLastError_impl(module);

if ((_return_value == PY_DWORD_MAX) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromUnsignedLong(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetModuleFileName__doc__,

"of the current process.");

#define _WINAPI_GETMODULEFILENAME_METHODDEF \

{"GetModuleFileName", (PyCFunction)_winapi_GetModuleFileName, METH_O, _winapi_GetModuleFileName__doc__},

static PyObject *

_winapi_GetModuleFileName_impl(PyObject *module, HMODULE module_handle);

static PyObject *

_winapi_GetModuleFileName(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

HMODULE module_handle;

if (!PyArg_Parse(arg, "" F_HANDLE ":GetModuleFileName", &module_handle)) {

goto exit;

}

return_value = _winapi_GetModuleFileName_impl(module, module_handle);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetStdHandle__doc__,

"The integer associated with the handle object is returned.");

#define _WINAPI_GETSTDHANDLE_METHODDEF \

{"GetStdHandle", (PyCFunction)_winapi_GetStdHandle, METH_O, _winapi_GetStdHandle__doc__},

static HANDLE

_winapi_GetStdHandle_impl(PyObject *module, DWORD std_handle);

static PyObject *

_winapi_GetStdHandle(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

DWORD std_handle;

HANDLE _return_value;

if (!PyArg_Parse(arg, "k:GetStdHandle", &std_handle)) {

goto exit;

}

_return_value = _winapi_GetStdHandle_impl(module, std_handle);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_GetVersion__doc__,

"Return the version number of the current operating system.");

#define _WINAPI_GETVERSION_METHODDEF \

{"GetVersion", (PyCFunction)_winapi_GetVersion, METH_NOARGS, _winapi_GetVersion__doc__},

static long

_winapi_GetVersion_impl(PyObject *module);

static PyObject *

_winapi_GetVersion(PyObject *module, PyObject *Py_UNUSED(ignored))

{

PyObject *return_value = NULL;

long _return_value;

_return_value = _winapi_GetVersion_impl(module);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyLong_FromLong(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_MapViewOfFile__doc__,

"\n");

#define _WINAPI_MAPVIEWOFFILE_METHODDEF \

{"MapViewOfFile", _PyCFunction_CAST(_winapi_MapViewOfFile), METH_FASTCALL, _winapi_MapViewOfFile__doc__},

static LPVOID

_winapi_MapViewOfFile_impl(PyObject *module, HANDLE file_map,

DWORD desired_access, DWORD file_offset_high,

DWORD file_offset_low, size_t number_bytes);

static PyObject *

_winapi_MapViewOfFile(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HANDLE file_map;

DWORD desired_access;

DWORD file_offset_high;

DWORD file_offset_low;

size_t number_bytes;

LPVOID _return_value;

if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "kkkO&:MapViewOfFile",

&file_map, &desired_access, &file_offset_high, &file_offset_low, _PyLong_Size_t_Converter, &number_bytes)) {

goto exit;

}

_return_value = _winapi_MapViewOfFile_impl(module, file_map, desired_access, file_offset_high, file_offset_low, number_bytes);

if ((_return_value == NULL) && PyErr_Occurred()) {

goto exit;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_UnmapViewOfFile__doc__,

"\n");

#define _WINAPI_UNMAPVIEWOFFILE_METHODDEF \

{"UnmapViewOfFile", (PyCFunction)_winapi_UnmapViewOfFile, METH_O, _winapi_UnmapViewOfFile__doc__},

static PyObject *

_winapi_UnmapViewOfFile_impl(PyObject *module, LPCVOID address);

static PyObject *

_winapi_UnmapViewOfFile(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

LPCVOID address;

if (!PyArg_Parse(arg, "" F_POINTER ":UnmapViewOfFile", &address)) {

goto exit;

}

return_value = _winapi_UnmapViewOfFile_impl(module, address);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_OpenFileMapping__doc__,

"\n");

#define _WINAPI_OPENFILEMAPPING_METHODDEF \

{"OpenFileMapping", _PyCFunction_CAST(_winapi_OpenFileMapping), METH_FASTCALL, _winapi_OpenFileMapping__doc__},

static HANDLE

_winapi_OpenFileMapping_impl(PyObject *module, DWORD desired_access,

BOOL inherit_handle, LPCWSTR name);

static PyObject *

_winapi_OpenFileMapping(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

DWORD desired_access;

BOOL inherit_handle;

LPCWSTR name = NULL;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "kiO&:OpenFileMapping",

&desired_access, &inherit_handle, _PyUnicode_WideCharString_Converter, &name)) {

goto exit;

}

_return_value = _winapi_OpenFileMapping_impl(module, desired_access, inherit_handle, name);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

/* Cleanup for name */

PyMem_Free((void *)name);

return return_value;

}

PyDoc_STRVAR(_winapi_OpenProcess__doc__,

"\n");

#define _WINAPI_OPENPROCESS_METHODDEF \

{"OpenProcess", _PyCFunction_CAST(_winapi_OpenProcess), METH_FASTCALL, _winapi_OpenProcess__doc__},

static HANDLE

_winapi_OpenProcess_impl(PyObject *module, DWORD desired_access,

BOOL inherit_handle, DWORD process_id);

static PyObject *

_winapi_OpenProcess(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

DWORD desired_access;

BOOL inherit_handle;

DWORD process_id;

HANDLE _return_value;

if (!_PyArg_ParseStack(args, nargs, "kik:OpenProcess",

&desired_access, &inherit_handle, &process_id)) {

goto exit;

}

_return_value = _winapi_OpenProcess_impl(module, desired_access, inherit_handle, process_id);

if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {

goto exit;

}

if (_return_value == NULL) {

Py_RETURN_NONE;

}

return_value = HANDLE_TO_PYNUM(_return_value);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_PeekNamedPipe__doc__,

"\n");

#define _WINAPI_PEEKNAMEDPIPE_METHODDEF \

{"PeekNamedPipe", _PyCFunction_CAST(_winapi_PeekNamedPipe), METH_FASTCALL, _winapi_PeekNamedPipe__doc__},

static PyObject *

_winapi_PeekNamedPipe_impl(PyObject *module, HANDLE handle, int size);

static PyObject *

_winapi_PeekNamedPipe(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HANDLE handle;

int size = 0;

if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "|i:PeekNamedPipe",

&handle, &size)) {

goto exit;

}

return_value = _winapi_PeekNamedPipe_impl(module, handle, size);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_LCMapStringEx__doc__,

"\n");

#define _WINAPI_LCMAPSTRINGEX_METHODDEF \

{"LCMapStringEx", _PyCFunction_CAST(_winapi_LCMapStringEx), METH_FASTCALL|METH_KEYWORDS, _winapi_LCMapStringEx__doc__},

static PyObject *

_winapi_LCMapStringEx_impl(PyObject *module, LPCWSTR locale, DWORD flags,

PyObject *src);

static PyObject *

_winapi_LCMapStringEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(locale), &_Py_ID(flags), &_Py_ID(src), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"locale", "flags", "src", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.format = "O&kU:LCMapStringEx",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

LPCWSTR locale = NULL;

DWORD flags;

PyObject *src;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

_PyUnicode_WideCharString_Converter, &locale, &flags, &src)) {

goto exit;

}

return_value = _winapi_LCMapStringEx_impl(module, locale, flags, src);

exit:

/* Cleanup for locale */

PyMem_Free((void *)locale);

return return_value;

}

PyDoc_STRVAR(_winapi_ReadFile__doc__,

"\n");

#define _WINAPI_READFILE_METHODDEF \

{"ReadFile", _PyCFunction_CAST(_winapi_ReadFile), METH_FASTCALL|METH_KEYWORDS, _winapi_ReadFile__doc__},

static PyObject *

_winapi_ReadFile_impl(PyObject *module, HANDLE handle, DWORD size,

int use_overlapped);

static PyObject *

_winapi_ReadFile(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(handle), &_Py_ID(size), &_Py_ID(overlapped), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"handle", "size", "overlapped", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.format = "" F_HANDLE "k|p:ReadFile",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

HANDLE handle;

DWORD size;

int use_overlapped = 0;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

&handle, &size, &use_overlapped)) {

goto exit;

}

return_value = _winapi_ReadFile_impl(module, handle, size, use_overlapped);

exit:

return return_value;

}

PyDoc_STRVAR(_winapi_SetNamedPipeHandleState__doc__,

"\n");

#define _WINAPI_SETNAMEDPIPEHANDLESTATE_METHODDEF \

{"SetNamedPipeHandleState", _PyCFunction_CAST(_winapi_SetNamedPipeHandleState), METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},

static PyObject *