bpo-20179: Convert the _overlapped module to the Argument Clinic (GH-14275)
This commit is contained in:
Zackery Spytz
GitHub
parent
6fc732a211
commit
9650fe0197
|
|
@ -0,0 +1,908 @@
|
|||
/*[clinic input]
|
||||
preserve
|
||||
[clinic start generated code]*/
|
||||
|
||||
PyDoc_STRVAR(_overlapped_CreateIoCompletionPort__doc__,
|
||||
"CreateIoCompletionPort($module, handle, port, key, concurrency, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Create a completion port or register a handle with a port.");
|
||||
|
||||
#define _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF \
|
||||
{"CreateIoCompletionPort", (PyCFunction)(void(*)(void))_overlapped_CreateIoCompletionPort, METH_FASTCALL, _overlapped_CreateIoCompletionPort__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
|
||||
HANDLE ExistingCompletionPort,
|
||||
ULONG_PTR CompletionKey,
|
||||
DWORD NumberOfConcurrentThreads);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_CreateIoCompletionPort(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE FileHandle;
|
||||
HANDLE ExistingCompletionPort;
|
||||
ULONG_PTR CompletionKey;
|
||||
DWORD NumberOfConcurrentThreads;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_ULONG_PTR"k:CreateIoCompletionPort",
|
||||
&FileHandle, &ExistingCompletionPort, &CompletionKey, &NumberOfConcurrentThreads)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_CreateIoCompletionPort_impl(module, FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_GetQueuedCompletionStatus__doc__,
|
||||
"GetQueuedCompletionStatus($module, port, msecs, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Get a message from completion port.\n"
|
||||
"\n"
|
||||
"Wait for up to msecs milliseconds.");
|
||||
|
||||
#define _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF \
|
||||
{"GetQueuedCompletionStatus", (PyCFunction)(void(*)(void))_overlapped_GetQueuedCompletionStatus, METH_FASTCALL, _overlapped_GetQueuedCompletionStatus__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
|
||||
HANDLE CompletionPort,
|
||||
DWORD Milliseconds);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_GetQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE CompletionPort;
|
||||
DWORD Milliseconds;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:GetQueuedCompletionStatus",
|
||||
&CompletionPort, &Milliseconds)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_GetQueuedCompletionStatus_impl(module, CompletionPort, Milliseconds);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_PostQueuedCompletionStatus__doc__,
|
||||
"PostQueuedCompletionStatus($module, port, bytes, key, address, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Post a message to completion port.");
|
||||
|
||||
#define _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF \
|
||||
{"PostQueuedCompletionStatus", (PyCFunction)(void(*)(void))_overlapped_PostQueuedCompletionStatus, METH_FASTCALL, _overlapped_PostQueuedCompletionStatus__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
|
||||
HANDLE CompletionPort,
|
||||
DWORD NumberOfBytes,
|
||||
ULONG_PTR CompletionKey,
|
||||
OVERLAPPED *Overlapped);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_PostQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE CompletionPort;
|
||||
DWORD NumberOfBytes;
|
||||
ULONG_PTR CompletionKey;
|
||||
OVERLAPPED *Overlapped;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k"F_ULONG_PTR""F_POINTER":PostQueuedCompletionStatus",
|
||||
&CompletionPort, &NumberOfBytes, &CompletionKey, &Overlapped)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_PostQueuedCompletionStatus_impl(module, CompletionPort, NumberOfBytes, CompletionKey, Overlapped);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_RegisterWaitWithQueue__doc__,
|
||||
"RegisterWaitWithQueue($module, Object, CompletionPort, Overlapped,\n"
|
||||
" Timeout, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Register wait for Object; when complete CompletionPort is notified.");
|
||||
|
||||
#define _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF \
|
||||
{"RegisterWaitWithQueue", (PyCFunction)(void(*)(void))_overlapped_RegisterWaitWithQueue, METH_FASTCALL, _overlapped_RegisterWaitWithQueue__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
|
||||
HANDLE CompletionPort,
|
||||
OVERLAPPED *Overlapped,
|
||||
DWORD Milliseconds);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_RegisterWaitWithQueue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Object;
|
||||
HANDLE CompletionPort;
|
||||
OVERLAPPED *Overlapped;
|
||||
DWORD Milliseconds;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_POINTER"k:RegisterWaitWithQueue",
|
||||
&Object, &CompletionPort, &Overlapped, &Milliseconds)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_RegisterWaitWithQueue_impl(module, Object, CompletionPort, Overlapped, Milliseconds);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_UnregisterWait__doc__,
|
||||
"UnregisterWait($module, WaitHandle, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Unregister wait handle.");
|
||||
|
||||
#define _OVERLAPPED_UNREGISTERWAIT_METHODDEF \
|
||||
{"UnregisterWait", (PyCFunction)_overlapped_UnregisterWait, METH_O, _overlapped_UnregisterWait__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_UnregisterWait(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE WaitHandle;
|
||||
|
||||
if (!PyArg_Parse(arg, ""F_HANDLE":UnregisterWait", &WaitHandle)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_UnregisterWait_impl(module, WaitHandle);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_UnregisterWaitEx__doc__,
|
||||
"UnregisterWaitEx($module, WaitHandle, Event, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Unregister wait handle.");
|
||||
|
||||
#define _OVERLAPPED_UNREGISTERWAITEX_METHODDEF \
|
||||
{"UnregisterWaitEx", (PyCFunction)(void(*)(void))_overlapped_UnregisterWaitEx, METH_FASTCALL, _overlapped_UnregisterWaitEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
|
||||
HANDLE Event);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_UnregisterWaitEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE WaitHandle;
|
||||
HANDLE Event;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":UnregisterWaitEx",
|
||||
&WaitHandle, &Event)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_UnregisterWaitEx_impl(module, WaitHandle, Event);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_CreateEvent__doc__,
|
||||
"CreateEvent($module, EventAttributes, ManualReset, InitialState, Name,\n"
|
||||
" /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Create an event.\n"
|
||||
"\n"
|
||||
"EventAttributes must be None.");
|
||||
|
||||
#define _OVERLAPPED_CREATEEVENT_METHODDEF \
|
||||
{"CreateEvent", (PyCFunction)(void(*)(void))_overlapped_CreateEvent, METH_FASTCALL, _overlapped_CreateEvent__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
|
||||
BOOL ManualReset, BOOL InitialState,
|
||||
const Py_UNICODE *Name);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_CreateEvent(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *EventAttributes;
|
||||
BOOL ManualReset;
|
||||
BOOL InitialState;
|
||||
const Py_UNICODE *Name;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, "OiiO&:CreateEvent",
|
||||
&EventAttributes, &ManualReset, &InitialState, _PyUnicode_WideCharString_Opt_Converter, &Name)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_CreateEvent_impl(module, EventAttributes, ManualReset, InitialState, Name);
|
||||
|
||||
exit:
|
||||
/* Cleanup for Name */
|
||||
#if !USE_UNICODE_WCHAR_CACHE
|
||||
PyMem_Free((void *)Name);
|
||||
#endif /* USE_UNICODE_WCHAR_CACHE */
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_SetEvent__doc__,
|
||||
"SetEvent($module, Handle, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Set event.");
|
||||
|
||||
#define _OVERLAPPED_SETEVENT_METHODDEF \
|
||||
{"SetEvent", (PyCFunction)_overlapped_SetEvent, METH_O, _overlapped_SetEvent__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_SetEvent_impl(PyObject *module, HANDLE Handle);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_SetEvent(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Handle;
|
||||
|
||||
if (!PyArg_Parse(arg, ""F_HANDLE":SetEvent", &Handle)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_SetEvent_impl(module, Handle);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_ResetEvent__doc__,
|
||||
"ResetEvent($module, Handle, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Reset event.");
|
||||
|
||||
#define _OVERLAPPED_RESETEVENT_METHODDEF \
|
||||
{"ResetEvent", (PyCFunction)_overlapped_ResetEvent, METH_O, _overlapped_ResetEvent__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_ResetEvent(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Handle;
|
||||
|
||||
if (!PyArg_Parse(arg, ""F_HANDLE":ResetEvent", &Handle)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_ResetEvent_impl(module, Handle);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_BindLocal__doc__,
|
||||
"BindLocal($module, handle, family, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Bind a socket handle to an arbitrary local port.\n"
|
||||
"\n"
|
||||
"family should be AF_INET or AF_INET6.");
|
||||
|
||||
#define _OVERLAPPED_BINDLOCAL_METHODDEF \
|
||||
{"BindLocal", (PyCFunction)(void(*)(void))_overlapped_BindLocal, METH_FASTCALL, _overlapped_BindLocal__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_BindLocal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Socket;
|
||||
int Family;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:BindLocal",
|
||||
&Socket, &Family)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_BindLocal_impl(module, Socket, Family);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_FormatMessage__doc__,
|
||||
"FormatMessage($module, error_code, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Return error message for an error code.");
|
||||
|
||||
#define _OVERLAPPED_FORMATMESSAGE_METHODDEF \
|
||||
{"FormatMessage", (PyCFunction)_overlapped_FormatMessage, METH_O, _overlapped_FormatMessage__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_FormatMessage_impl(PyObject *module, DWORD code);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_FormatMessage(PyObject *module, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
DWORD code;
|
||||
|
||||
if (!PyArg_Parse(arg, "k:FormatMessage", &code)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_FormatMessage_impl(module, code);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped__doc__,
|
||||
"Overlapped(event=_overlapped.INVALID_HANDLE_VALUE)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"OVERLAPPED structure wrapper.");
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped(PyTypeObject *type, PyObject *args, PyObject *kwargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
static const char * const _keywords[] = {"event", NULL};
|
||||
static _PyArg_Parser _parser = {"|"F_HANDLE":Overlapped", _keywords, 0};
|
||||
HANDLE event = INVALID_HANDLE_VALUE;
|
||||
|
||||
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
|
||||
&event)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_impl(type, event);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_cancel__doc__,
|
||||
"cancel($self, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Cancel overlapped operation.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF \
|
||||
{"cancel", (PyCFunction)_overlapped_Overlapped_cancel, METH_NOARGS, _overlapped_Overlapped_cancel__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_cancel_impl(OverlappedObject *self);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
|
||||
{
|
||||
return _overlapped_Overlapped_cancel_impl(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_getresult__doc__,
|
||||
"getresult($self, wait=False, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Retrieve result of operation.\n"
|
||||
"\n"
|
||||
"If wait is true then it blocks until the operation is finished. If wait\n"
|
||||
"is false and the operation is still pending then an error is raised.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF \
|
||||
{"getresult", (PyCFunction)(void(*)(void))_overlapped_Overlapped_getresult, METH_FASTCALL, _overlapped_Overlapped_getresult__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_getresult(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
BOOL wait = FALSE;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, "|i:getresult",
|
||||
&wait)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_getresult_impl(self, wait);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_ReadFile__doc__,
|
||||
"ReadFile($self, handle, size, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped read.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF \
|
||||
{"ReadFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ReadFile, METH_FASTCALL, _overlapped_Overlapped_ReadFile__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
|
||||
DWORD size);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ReadFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
DWORD size;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:ReadFile",
|
||||
&handle, &size)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_ReadFile_impl(self, handle, size);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_ReadFileInto__doc__,
|
||||
"ReadFileInto($self, handle, buf, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped receive.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF \
|
||||
{"ReadFileInto", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ReadFileInto, METH_FASTCALL, _overlapped_Overlapped_ReadFileInto__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
|
||||
HANDLE handle, PyObject *bufobj);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ReadFileInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
PyObject *bufobj;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:ReadFileInto",
|
||||
&handle, &bufobj)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_ReadFileInto_impl(self, handle, bufobj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WSARecv__doc__,
|
||||
"WSARecv($self, handle, size, flags=0, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped receive.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF \
|
||||
{"WSARecv", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecv, METH_FASTCALL, _overlapped_Overlapped_WSARecv__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
|
||||
DWORD size, DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecv(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
DWORD size;
|
||||
DWORD flags = 0;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecv",
|
||||
&handle, &size, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WSARecv_impl(self, handle, size, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WSARecvInto__doc__,
|
||||
"WSARecvInto($self, handle, buf, flags, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped receive.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF \
|
||||
{"WSARecvInto", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecvInto, METH_FASTCALL, _overlapped_Overlapped_WSARecvInto__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
|
||||
HANDLE handle, PyObject *bufobj,
|
||||
DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecvInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
PyObject *bufobj;
|
||||
DWORD flags;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"Ok:WSARecvInto",
|
||||
&handle, &bufobj, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WSARecvInto_impl(self, handle, bufobj, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WriteFile__doc__,
|
||||
"WriteFile($self, handle, buf, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped write.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF \
|
||||
{"WriteFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WriteFile, METH_FASTCALL, _overlapped_Overlapped_WriteFile__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
|
||||
PyObject *bufobj);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WriteFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
PyObject *bufobj;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:WriteFile",
|
||||
&handle, &bufobj)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WriteFile_impl(self, handle, bufobj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WSASend__doc__,
|
||||
"WSASend($self, handle, buf, flags, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped send.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF \
|
||||
{"WSASend", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSASend, METH_FASTCALL, _overlapped_Overlapped_WSASend__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
|
||||
PyObject *bufobj, DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSASend(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
PyObject *bufobj;
|
||||
DWORD flags;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"Ok:WSASend",
|
||||
&handle, &bufobj, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WSASend_impl(self, handle, bufobj, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_AcceptEx__doc__,
|
||||
"AcceptEx($self, listen_handle, accept_handle, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped wait for client to connect.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF \
|
||||
{"AcceptEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_AcceptEx, METH_FASTCALL, _overlapped_Overlapped_AcceptEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
|
||||
HANDLE ListenSocket,
|
||||
HANDLE AcceptSocket);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_AcceptEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE ListenSocket;
|
||||
HANDLE AcceptSocket;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":AcceptEx",
|
||||
&ListenSocket, &AcceptSocket)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_AcceptEx_impl(self, ListenSocket, AcceptSocket);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_ConnectEx__doc__,
|
||||
"ConnectEx($self, client_handle, address_as_bytes, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped connect.\n"
|
||||
"\n"
|
||||
"client_handle should be unbound.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF \
|
||||
{"ConnectEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ConnectEx, METH_FASTCALL, _overlapped_Overlapped_ConnectEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
|
||||
HANDLE ConnectSocket,
|
||||
PyObject *AddressObj);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE ConnectSocket;
|
||||
PyObject *AddressObj;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O!:ConnectEx",
|
||||
&ConnectSocket, &PyTuple_Type, &AddressObj)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_ConnectEx_impl(self, ConnectSocket, AddressObj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_DisconnectEx__doc__,
|
||||
"DisconnectEx($self, handle, flags, /)\n"
|
||||
"--\n"
|
||||
"\n");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF \
|
||||
{"DisconnectEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_DisconnectEx, METH_FASTCALL, _overlapped_Overlapped_DisconnectEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
|
||||
HANDLE Socket, DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_DisconnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Socket;
|
||||
DWORD flags;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:DisconnectEx",
|
||||
&Socket, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_DisconnectEx_impl(self, Socket, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_TransmitFile__doc__,
|
||||
"TransmitFile($self, socket, file, offset, offset_high, count_to_write,\n"
|
||||
" count_per_send, flags, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Transmit file data over a connected socket.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF \
|
||||
{"TransmitFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_TransmitFile, METH_FASTCALL, _overlapped_Overlapped_TransmitFile__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
|
||||
HANDLE Socket, HANDLE File,
|
||||
DWORD offset, DWORD offset_high,
|
||||
DWORD count_to_write,
|
||||
DWORD count_per_send, DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_TransmitFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Socket;
|
||||
HANDLE File;
|
||||
DWORD offset;
|
||||
DWORD offset_high;
|
||||
DWORD count_to_write;
|
||||
DWORD count_per_send;
|
||||
DWORD flags;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE"kkkkk:TransmitFile",
|
||||
&Socket, &File, &offset, &offset_high, &count_to_write, &count_per_send, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_TransmitFile_impl(self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_ConnectNamedPipe__doc__,
|
||||
"ConnectNamedPipe($self, handle, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped wait for a client to connect.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF \
|
||||
{"ConnectNamedPipe", (PyCFunction)_overlapped_Overlapped_ConnectNamedPipe, METH_O, _overlapped_Overlapped_ConnectNamedPipe__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
|
||||
HANDLE Pipe);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE Pipe;
|
||||
|
||||
if (!PyArg_Parse(arg, ""F_HANDLE":ConnectNamedPipe", &Pipe)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_ConnectNamedPipe_impl(self, Pipe);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_ConnectPipe__doc__,
|
||||
"ConnectPipe($self, addr, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Connect to the pipe for asynchronous I/O (overlapped).");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF \
|
||||
{"ConnectPipe", (PyCFunction)_overlapped_Overlapped_ConnectPipe, METH_O, _overlapped_Overlapped_ConnectPipe__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
|
||||
const Py_UNICODE *Address);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_ConnectPipe(OverlappedObject *self, PyObject *arg)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
const Py_UNICODE *Address;
|
||||
|
||||
if (!PyUnicode_Check(arg)) {
|
||||
_PyArg_BadArgument("ConnectPipe", "argument", "str", arg);
|
||||
goto exit;
|
||||
}
|
||||
#if USE_UNICODE_WCHAR_CACHE
|
||||
Address = _PyUnicode_AsUnicode(arg);
|
||||
#else /* USE_UNICODE_WCHAR_CACHE */
|
||||
Address = PyUnicode_AsWideCharString(arg, NULL);
|
||||
#endif /* USE_UNICODE_WCHAR_CACHE */
|
||||
if (Address == NULL) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_ConnectPipe_impl(self, Address);
|
||||
|
||||
exit:
|
||||
/* Cleanup for Address */
|
||||
#if !USE_UNICODE_WCHAR_CACHE
|
||||
PyMem_Free((void *)Address);
|
||||
#endif /* USE_UNICODE_WCHAR_CACHE */
|
||||
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_WSAConnect__doc__,
|
||||
"WSAConnect($module, client_handle, address_as_bytes, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Bind a remote address to a connectionless (UDP) socket.");
|
||||
|
||||
#define _OVERLAPPED_WSACONNECT_METHODDEF \
|
||||
{"WSAConnect", (PyCFunction)(void(*)(void))_overlapped_WSAConnect, METH_FASTCALL, _overlapped_WSAConnect__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
|
||||
PyObject *AddressObj);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE ConnectSocket;
|
||||
PyObject *AddressObj;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:WSAConnect",
|
||||
&ConnectSocket, &AddressObj)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WSASendTo__doc__,
|
||||
"WSASendTo($self, handle, buf, flags, address_as_bytes, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped sendto over a connectionless (UDP) socket.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF \
|
||||
{"WSASendTo", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSASendTo, METH_FASTCALL, _overlapped_Overlapped_WSASendTo__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
|
||||
PyObject *bufobj, DWORD flags,
|
||||
PyObject *AddressObj);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSASendTo(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
PyObject *bufobj;
|
||||
DWORD flags;
|
||||
PyObject *AddressObj;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"OkO:WSASendTo",
|
||||
&handle, &bufobj, &flags, &AddressObj)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WSASendTo_impl(self, handle, bufobj, flags, AddressObj);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFrom__doc__,
|
||||
"WSARecvFrom($self, handle, size, flags=0, /)\n"
|
||||
"--\n"
|
||||
"\n"
|
||||
"Start overlapped receive.");
|
||||
|
||||
#define _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF \
|
||||
{"WSARecvFrom", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecvFrom, METH_FASTCALL, _overlapped_Overlapped_WSARecvFrom__doc__},
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
|
||||
HANDLE handle, DWORD size,
|
||||
DWORD flags);
|
||||
|
||||
static PyObject *
|
||||
_overlapped_Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
DWORD size;
|
||||
DWORD flags = 0;
|
||||
|
||||
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecvFrom",
|
||||
&handle, &size, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _overlapped_Overlapped_WSARecvFrom_impl(self, handle, size, flags);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=ee2ec2f93c8d334b input=a9049054013a1b77]*/
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue