[Python-checkins] bpo-20179: Convert the _overlapped module to the Argument Clinic (GH-14275)
Zackery Spytz
webhook-mailer at python.org
Fri Jul 10 13:43:46 EDT 2020
https://github.com/python/cpython/commit/9650fe0197779b4dfded94be111e39c5810f098f
commit: 9650fe0197779b4dfded94be111e39c5810f098f
branch: master
author: Zackery Spytz <zspytz at gmail.com>
committer: GitHub <noreply at github.com>
date: 2020-07-10T20:43:37+03:00
summary:
bpo-20179: Convert the _overlapped module to the Argument Clinic (GH-14275)
files:
A Modules/clinic/overlapped.c.h
M Modules/overlapped.c
diff --git a/Modules/clinic/overlapped.c.h b/Modules/clinic/overlapped.c.h
new file mode 100644
index 0000000000000..efecd9028b776
--- /dev/null
+++ b/Modules/clinic/overlapped.c.h
@@ -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]*/
diff --git a/Modules/overlapped.c b/Modules/overlapped.c
index eed8fbf039300..9c4e2da9dfbd3 100644
--- a/Modules/overlapped.c
+++ b/Modules/overlapped.c
@@ -37,6 +37,36 @@
#define T_HANDLE T_POINTER
+/*[python input]
+class OVERLAPPED_converter(CConverter):
+ type = 'OVERLAPPED *'
+ format_unit = '"F_POINTER"'
+
+class HANDLE_converter(CConverter):
+ type = 'HANDLE'
+ format_unit = '"F_HANDLE"'
+
+class ULONG_PTR_converter(CConverter):
+ type = 'ULONG_PTR'
+ format_unit = '"F_ULONG_PTR"'
+
+class DWORD_converter(CConverter):
+ type = 'DWORD'
+ format_unit = 'k'
+
+class BOOL_converter(CConverter):
+ type = 'BOOL'
+ format_unit = 'i'
+[python start generated code]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=83bb8c2c2514f2a8]*/
+
+/*[clinic input]
+module _overlapped
+class _overlapped.Overlapped "OverlappedObject *" "&OverlappedType"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=92e5a799db35b96c]*/
+
+
enum {TYPE_NONE, TYPE_NOT_STARTED, TYPE_READ, TYPE_READINTO, TYPE_WRITE,
TYPE_ACCEPT, TYPE_CONNECT, TYPE_DISCONNECT, TYPE_CONNECT_NAMED_PIPE,
TYPE_WAIT_NAMED_PIPE_AND_CONNECT, TYPE_TRANSMIT_FILE, TYPE_READ_FROM,
@@ -150,25 +180,27 @@ initialize_function_pointers(void)
* Completion port stuff
*/
-PyDoc_STRVAR(
- CreateIoCompletionPort_doc,
- "CreateIoCompletionPort(handle, port, key, concurrency) -> port\n\n"
- "Create a completion port or register a handle with a port.");
+/*[clinic input]
+_overlapped.CreateIoCompletionPort
+
+ handle as FileHandle: HANDLE
+ port as ExistingCompletionPort: HANDLE
+ key as CompletionKey: ULONG_PTR
+ concurrency as NumberOfConcurrentThreads: DWORD
+ /
+
+Create a completion port or register a handle with a port.
+[clinic start generated code]*/
static PyObject *
-overlapped_CreateIoCompletionPort(PyObject *self, PyObject *args)
+_overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
+ HANDLE ExistingCompletionPort,
+ ULONG_PTR CompletionKey,
+ DWORD NumberOfConcurrentThreads)
+/*[clinic end generated code: output=24ede2b0f05e5433 input=847bae4d0efe1976]*/
{
- HANDLE FileHandle;
- HANDLE ExistingCompletionPort;
- ULONG_PTR CompletionKey;
- DWORD NumberOfConcurrentThreads;
HANDLE ret;
- if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE F_ULONG_PTR F_DWORD,
- &FileHandle, &ExistingCompletionPort, &CompletionKey,
- &NumberOfConcurrentThreads))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = CreateIoCompletionPort(FileHandle, ExistingCompletionPort,
CompletionKey, NumberOfConcurrentThreads);
@@ -179,26 +211,30 @@ overlapped_CreateIoCompletionPort(PyObject *self, PyObject *args)
return Py_BuildValue(F_HANDLE, ret);
}
-PyDoc_STRVAR(
- GetQueuedCompletionStatus_doc,
- "GetQueuedCompletionStatus(port, msecs) -> (err, bytes, key, address)\n\n"
- "Get a message from completion port. Wait for up to msecs milliseconds.");
+/*[clinic input]
+_overlapped.GetQueuedCompletionStatus
+
+ port as CompletionPort: HANDLE
+ msecs as Milliseconds: DWORD
+ /
+
+Get a message from completion port.
+
+Wait for up to msecs milliseconds.
+[clinic start generated code]*/
static PyObject *
-overlapped_GetQueuedCompletionStatus(PyObject *self, PyObject *args)
+_overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
+ HANDLE CompletionPort,
+ DWORD Milliseconds)
+/*[clinic end generated code: output=68314171628dddb7 input=94a042d14c4f6410]*/
{
- HANDLE CompletionPort = NULL;
DWORD NumberOfBytes = 0;
ULONG_PTR CompletionKey = 0;
OVERLAPPED *Overlapped = NULL;
- DWORD Milliseconds;
DWORD err;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD,
- &CompletionPort, &Milliseconds))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = GetQueuedCompletionStatus(CompletionPort, &NumberOfBytes,
&CompletionKey, &Overlapped, Milliseconds);
@@ -215,25 +251,28 @@ overlapped_GetQueuedCompletionStatus(PyObject *self, PyObject *args)
err, NumberOfBytes, CompletionKey, Overlapped);
}
-PyDoc_STRVAR(
- PostQueuedCompletionStatus_doc,
- "PostQueuedCompletionStatus(port, bytes, key, address) -> None\n\n"
- "Post a message to completion port.");
+/*[clinic input]
+_overlapped.PostQueuedCompletionStatus
+
+ port as CompletionPort: HANDLE
+ bytes as NumberOfBytes: DWORD
+ key as CompletionKey: ULONG_PTR
+ address as Overlapped: OVERLAPPED
+ /
+
+Post a message to completion port.
+[clinic start generated code]*/
static PyObject *
-overlapped_PostQueuedCompletionStatus(PyObject *self, PyObject *args)
+_overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
+ HANDLE CompletionPort,
+ DWORD NumberOfBytes,
+ ULONG_PTR CompletionKey,
+ OVERLAPPED *Overlapped)
+/*[clinic end generated code: output=93e73f2933a43e9e input=e936202d87937aca]*/
{
- HANDLE CompletionPort;
- DWORD NumberOfBytes;
- ULONG_PTR CompletionKey;
- OVERLAPPED *Overlapped;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD F_ULONG_PTR F_POINTER,
- &CompletionPort, &NumberOfBytes, &CompletionKey,
- &Overlapped))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = PostQueuedCompletionStatus(CompletionPort, NumberOfBytes,
CompletionKey, Overlapped);
@@ -264,26 +303,27 @@ PostToQueueCallback(PVOID lpParameter, BOOL TimerOrWaitFired)
PyMem_RawFree(p);
}
-PyDoc_STRVAR(
- RegisterWaitWithQueue_doc,
- "RegisterWaitWithQueue(Object, CompletionPort, Overlapped, Timeout)\n"
- " -> WaitHandle\n\n"
- "Register wait for Object; when complete CompletionPort is notified.\n");
+/*[clinic input]
+_overlapped.RegisterWaitWithQueue
+
+ Object: HANDLE
+ CompletionPort: HANDLE
+ Overlapped: OVERLAPPED
+ Timeout as Milliseconds: DWORD
+ /
+
+Register wait for Object; when complete CompletionPort is notified.
+[clinic start generated code]*/
static PyObject *
-overlapped_RegisterWaitWithQueue(PyObject *self, PyObject *args)
+_overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
+ HANDLE CompletionPort,
+ OVERLAPPED *Overlapped,
+ DWORD Milliseconds)
+/*[clinic end generated code: output=c2ace732e447fe45 input=2dd4efee44abe8ee]*/
{
HANDLE NewWaitObject;
- HANDLE Object;
- ULONG Milliseconds;
- struct PostCallbackData data, *pdata;
-
- if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE F_POINTER F_DWORD,
- &Object,
- &data.CompletionPort,
- &data.Overlapped,
- &Milliseconds))
- return NULL;
+ struct PostCallbackData data = {CompletionPort, Overlapped}, *pdata;
/* Use PyMem_RawMalloc() rather than PyMem_Malloc(), since
PostToQueueCallback() will call PyMem_Free() from a new C thread
@@ -306,20 +346,21 @@ overlapped_RegisterWaitWithQueue(PyObject *self, PyObject *args)
return Py_BuildValue(F_HANDLE, NewWaitObject);
}
-PyDoc_STRVAR(
- UnregisterWait_doc,
- "UnregisterWait(WaitHandle) -> None\n\n"
- "Unregister wait handle.\n");
+/*[clinic input]
+_overlapped.UnregisterWait
+
+ WaitHandle: HANDLE
+ /
+
+Unregister wait handle.
+[clinic start generated code]*/
static PyObject *
-overlapped_UnregisterWait(PyObject *self, PyObject *args)
+_overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle)
+/*[clinic end generated code: output=ec90cd955a9a617d input=a56709544cb2df0f]*/
{
- HANDLE WaitHandle;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE, &WaitHandle))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = UnregisterWait(WaitHandle);
Py_END_ALLOW_THREADS
@@ -329,20 +370,23 @@ overlapped_UnregisterWait(PyObject *self, PyObject *args)
Py_RETURN_NONE;
}
-PyDoc_STRVAR(
- UnregisterWaitEx_doc,
- "UnregisterWaitEx(WaitHandle, Event) -> None\n\n"
- "Unregister wait handle.\n");
+/*[clinic input]
+_overlapped.UnregisterWaitEx
+
+ WaitHandle: HANDLE
+ Event: HANDLE
+ /
+
+Unregister wait handle.
+[clinic start generated code]*/
static PyObject *
-overlapped_UnregisterWaitEx(PyObject *self, PyObject *args)
+_overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
+ HANDLE Event)
+/*[clinic end generated code: output=2e3d84c1d5f65b92 input=953cddc1de50fab9]*/
{
- HANDLE WaitHandle, Event;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE, &WaitHandle, &Event))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = UnregisterWaitEx(WaitHandle, Event);
Py_END_ALLOW_THREADS
@@ -356,26 +400,28 @@ overlapped_UnregisterWaitEx(PyObject *self, PyObject *args)
* Event functions -- currently only used by tests
*/
-PyDoc_STRVAR(
- CreateEvent_doc,
- "CreateEvent(EventAttributes, ManualReset, InitialState, Name)"
- " -> Handle\n\n"
- "Create an event. EventAttributes must be None.\n");
+/*[clinic input]
+_overlapped.CreateEvent
+
+ EventAttributes: object
+ ManualReset: BOOL
+ InitialState: BOOL
+ Name: Py_UNICODE(accept={str, NoneType})
+ /
+
+Create an event.
+
+EventAttributes must be None.
+[clinic start generated code]*/
static PyObject *
-overlapped_CreateEvent(PyObject *self, PyObject *args)
+_overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
+ BOOL ManualReset, BOOL InitialState,
+ const Py_UNICODE *Name)
+/*[clinic end generated code: output=8e04f0916c17b13d input=dbc36ae14375ba24]*/
{
- PyObject *EventAttributes;
- BOOL ManualReset;
- BOOL InitialState;
- Py_UNICODE *Name;
HANDLE Event;
- if (!PyArg_ParseTuple(args, "O" F_BOOL F_BOOL "Z",
- &EventAttributes, &ManualReset,
- &InitialState, &Name))
- return NULL;
-
if (EventAttributes != Py_None) {
PyErr_SetString(PyExc_ValueError, "EventAttributes must be None");
return NULL;
@@ -390,20 +436,21 @@ overlapped_CreateEvent(PyObject *self, PyObject *args)
return Py_BuildValue(F_HANDLE, Event);
}
-PyDoc_STRVAR(
- SetEvent_doc,
- "SetEvent(Handle) -> None\n\n"
- "Set event.\n");
+/*[clinic input]
+_overlapped.SetEvent
+
+ Handle: HANDLE
+ /
+
+Set event.
+[clinic start generated code]*/
static PyObject *
-overlapped_SetEvent(PyObject *self, PyObject *args)
+_overlapped_SetEvent_impl(PyObject *module, HANDLE Handle)
+/*[clinic end generated code: output=5b8d974216b0e569 input=d8b0d26eb7391e80]*/
{
- HANDLE Handle;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE, &Handle))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = SetEvent(Handle);
Py_END_ALLOW_THREADS
@@ -413,20 +460,21 @@ overlapped_SetEvent(PyObject *self, PyObject *args)
Py_RETURN_NONE;
}
-PyDoc_STRVAR(
- ResetEvent_doc,
- "ResetEvent(Handle) -> None\n\n"
- "Reset event.\n");
+/*[clinic input]
+_overlapped.ResetEvent
+
+ Handle: HANDLE
+ /
+
+Reset event.
+[clinic start generated code]*/
static PyObject *
-overlapped_ResetEvent(PyObject *self, PyObject *args)
+_overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle)
+/*[clinic end generated code: output=066537a8405cddb2 input=d4e089c9ba84ff2f]*/
{
- HANDLE Handle;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE, &Handle))
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
ret = ResetEvent(Handle);
Py_END_ALLOW_THREADS
@@ -440,36 +488,40 @@ overlapped_ResetEvent(PyObject *self, PyObject *args)
* Bind socket handle to local port without doing slow getaddrinfo()
*/
-PyDoc_STRVAR(
- BindLocal_doc,
- "BindLocal(handle, family) -> None\n\n"
- "Bind a socket handle to an arbitrary local port.\n"
- "family should AF_INET or AF_INET6.\n");
+/*[clinic input]
+_overlapped.BindLocal
+
+ handle as Socket: HANDLE
+ family as Family: int
+ /
+
+Bind a socket handle to an arbitrary local port.
+
+family should be AF_INET or AF_INET6.
+[clinic start generated code]*/
static PyObject *
-overlapped_BindLocal(PyObject *self, PyObject *args)
+_overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family)
+/*[clinic end generated code: output=edb93862697aed9c input=a0e7b5c2f541170c]*/
{
- SOCKET Socket;
- int Family;
BOOL ret;
- if (!PyArg_ParseTuple(args, F_HANDLE "i", &Socket, &Family))
- return NULL;
-
if (Family == AF_INET) {
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.S_un.S_addr = INADDR_ANY;
- ret = bind(Socket, (SOCKADDR*)&addr, sizeof(addr)) != SOCKET_ERROR;
+ ret = bind((SOCKET)Socket, (SOCKADDR*)&addr, sizeof(addr))
+ != SOCKET_ERROR;
} else if (Family == AF_INET6) {
struct sockaddr_in6 addr;
memset(&addr, 0, sizeof(addr));
addr.sin6_family = AF_INET6;
addr.sin6_port = 0;
addr.sin6_addr = in6addr_any;
- ret = bind(Socket, (SOCKADDR*)&addr, sizeof(addr)) != SOCKET_ERROR;
+ ret = bind((SOCKET)Socket, (SOCKADDR*)&addr, sizeof(addr))
+ != SOCKET_ERROR;
} else {
PyErr_SetString(PyExc_ValueError, "expected tuple of length 2 or 4");
return NULL;
@@ -484,21 +536,23 @@ overlapped_BindLocal(PyObject *self, PyObject *args)
* Windows equivalent of os.strerror() -- compare _ctypes/callproc.c
*/
-PyDoc_STRVAR(
- FormatMessage_doc,
- "FormatMessage(error_code) -> error_message\n\n"
- "Return error message for an error code.");
+/*[clinic input]
+_overlapped.FormatMessage
+
+ error_code as code: DWORD
+ /
+
+Return error message for an error code.
+[clinic start generated code]*/
static PyObject *
-overlapped_FormatMessage(PyObject *ignore, PyObject *args)
+_overlapped_FormatMessage_impl(PyObject *module, DWORD code)
+/*[clinic end generated code: output=02c964ff22407c6b input=644bb5b80326179e]*/
{
- DWORD code, n;
+ DWORD n;
WCHAR *lpMsgBuf;
PyObject *res;
- if (!PyArg_ParseTuple(args, F_DWORD, &code))
- return NULL;
-
n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -538,19 +592,20 @@ mark_as_completed(OVERLAPPED *ov)
* for overlapped I/O
*/
-PyDoc_STRVAR(
- Overlapped_doc,
- "Overlapped object");
+/*[clinic input]
+ at classmethod
+_overlapped.Overlapped.__new__
+
+ event: HANDLE(c_default='INVALID_HANDLE_VALUE') = _overlapped.INVALID_HANDLE_VALUE
+
+OVERLAPPED structure wrapper.
+[clinic start generated code]*/
static PyObject *
-Overlapped_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+_overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event)
+/*[clinic end generated code: output=6da60504a18eb421 input=26b8a7429e629e95]*/
{
OverlappedObject *self;
- HANDLE event = INVALID_HANDLE_VALUE;
- static char *kwlist[] = {"event", NULL};
-
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "|" F_HANDLE, kwlist, &event))
- return NULL;
if (event == INVALID_HANDLE_VALUE) {
event = CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -720,13 +775,15 @@ unparse_address(LPSOCKADDR Address, DWORD Length)
}
}
-PyDoc_STRVAR(
- Overlapped_cancel_doc,
- "cancel() -> None\n\n"
- "Cancel overlapped operation");
+/*[clinic input]
+_overlapped.Overlapped.cancel
+
+Cancel overlapped operation.
+[clinic start generated code]*/
static PyObject *
-Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
+_overlapped_Overlapped_cancel_impl(OverlappedObject *self)
+/*[clinic end generated code: output=54ad7aeece89901c input=80eb67c7b57dbcf1]*/
{
BOOL ret = TRUE;
@@ -749,25 +806,27 @@ Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
Py_RETURN_NONE;
}
-PyDoc_STRVAR(
- Overlapped_getresult_doc,
- "getresult(wait=False) -> result\n\n"
- "Retrieve result of operation. If wait is true then it blocks\n"
- "until the operation is finished. If wait is false and the\n"
- "operation is still pending then an error is raised.");
+/*[clinic input]
+_overlapped.Overlapped.getresult
+
+ wait: BOOL(c_default='FALSE') = False
+ /
+
+Retrieve result of operation.
+
+If wait is true then it blocks until the operation is finished. If wait
+is false and the operation is still pending then an error is raised.
+[clinic start generated code]*/
static PyObject *
-Overlapped_getresult(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
+/*[clinic end generated code: output=8c9bd04d08994f6c input=aa5b03e9897ca074]*/
{
- BOOL wait = FALSE;
DWORD transferred = 0;
BOOL ret;
DWORD err;
PyObject *addr;
- if (!PyArg_ParseTuple(args, "|" F_BOOL, &wait))
- return NULL;
-
if (self->type == TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation not yet attempted");
return NULL;
@@ -879,21 +938,23 @@ do_ReadFile(OverlappedObject *self, HANDLE handle,
}
}
-PyDoc_STRVAR(
- Overlapped_ReadFile_doc,
- "ReadFile(handle, size) -> Overlapped[message]\n\n"
- "Start overlapped read");
+/*[clinic input]
+_overlapped.Overlapped.ReadFile
+
+ handle: HANDLE
+ size: DWORD
+ /
+
+Start overlapped read.
+[clinic start generated code]*/
static PyObject *
-Overlapped_ReadFile(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
+ DWORD size)
+/*[clinic end generated code: output=4c8557e16941e4ae input=98c495baa0342425]*/
{
- HANDLE handle;
- DWORD size;
PyObject *buf;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD, &handle, &size))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -913,20 +974,21 @@ Overlapped_ReadFile(OverlappedObject *self, PyObject *args)
return do_ReadFile(self, handle, PyBytes_AS_STRING(buf), size);
}
-PyDoc_STRVAR(
- Overlapped_ReadFileInto_doc,
- "ReadFileInto(handle, buf) -> Overlapped[bytes_transferred]\n\n"
- "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.ReadFileInto
-static PyObject *
-Overlapped_ReadFileInto(OverlappedObject *self, PyObject *args)
-{
- HANDLE handle;
- PyObject *bufobj;
+ handle: HANDLE
+ buf as bufobj: object
+ /
- if (!PyArg_ParseTuple(args, F_HANDLE "O", &handle, &bufobj))
- return NULL;
+Start overlapped receive.
+[clinic start generated code]*/
+static PyObject *
+_overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
+ HANDLE handle, PyObject *bufobj)
+/*[clinic end generated code: output=1e9e712e742e5b2a input=16f6cc268d1d0387]*/
+{
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -982,23 +1044,24 @@ do_WSARecv(OverlappedObject *self, HANDLE handle,
}
}
-PyDoc_STRVAR(
- Overlapped_WSARecv_doc,
- "RecvFile(handle, size, flags) -> Overlapped[message]\n\n"
- "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.WSARecv
+
+ handle: HANDLE
+ size: DWORD
+ flags: DWORD = 0
+ /
+
+Start overlapped receive.
+[clinic start generated code]*/
static PyObject *
-Overlapped_WSARecv(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
+ DWORD size, DWORD flags)
+/*[clinic end generated code: output=3a5e9c61ff040906 input=8c04e506cc3d741a]*/
{
- HANDLE handle;
- DWORD size;
- DWORD flags = 0;
PyObject *buf;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD "|" F_DWORD,
- &handle, &size, &flags))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1018,22 +1081,23 @@ Overlapped_WSARecv(OverlappedObject *self, PyObject *args)
return do_WSARecv(self, handle, PyBytes_AS_STRING(buf), size, flags);
}
-PyDoc_STRVAR(
- Overlapped_WSARecvInto_doc,
- "WSARecvInto(handle, buf, flags) -> Overlapped[bytes_transferred]\n\n"
- "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.WSARecvInto
-static PyObject *
-Overlapped_WSARecvInto(OverlappedObject *self, PyObject *args)
-{
- HANDLE handle;
- PyObject *bufobj;
- DWORD flags;
+ handle: HANDLE
+ buf as bufobj: object
+ flags: DWORD
+ /
- if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD,
- &handle, &bufobj, &flags))
- return NULL;
+Start overlapped receive.
+[clinic start generated code]*/
+static PyObject *
+_overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
+ HANDLE handle, PyObject *bufobj,
+ DWORD flags)
+/*[clinic end generated code: output=9a438abc436fe87c input=4f87c38fc381d525]*/
+{
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1057,23 +1121,25 @@ Overlapped_WSARecvInto(OverlappedObject *self, PyObject *args)
(DWORD)self->user_buffer.len, flags);
}
-PyDoc_STRVAR(
- Overlapped_WriteFile_doc,
- "WriteFile(handle, buf) -> Overlapped[bytes_transferred]\n\n"
- "Start overlapped write");
+/*[clinic input]
+_overlapped.Overlapped.WriteFile
+
+ handle: HANDLE
+ buf as bufobj: object
+ /
+
+Start overlapped write.
+[clinic start generated code]*/
static PyObject *
-Overlapped_WriteFile(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
+ PyObject *bufobj)
+/*[clinic end generated code: output=c376230b6120d877 input=b8d9a7608d8a1e72]*/
{
- HANDLE handle;
- PyObject *bufobj;
DWORD written;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE "O", &handle, &bufobj))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1110,26 +1176,27 @@ Overlapped_WriteFile(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_WSASend_doc,
- "WSASend(handle, buf, flags) -> Overlapped[bytes_transferred]\n\n"
- "Start overlapped send");
+/*[clinic input]
+_overlapped.Overlapped.WSASend
+
+ handle: HANDLE
+ buf as bufobj: object
+ flags: DWORD
+ /
+
+Start overlapped send.
+[clinic start generated code]*/
static PyObject *
-Overlapped_WSASend(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
+ PyObject *bufobj, DWORD flags)
+/*[clinic end generated code: output=316031c7467040cc input=932e7cba6d18f708]*/
{
- HANDLE handle;
- PyObject *bufobj;
- DWORD flags;
DWORD written;
WSABUF wsabuf;
int ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD,
- &handle, &bufobj, &flags))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1167,26 +1234,28 @@ Overlapped_WSASend(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_AcceptEx_doc,
- "AcceptEx(listen_handle, accept_handle) -> Overlapped[address_as_bytes]\n\n"
- "Start overlapped wait for client to connect");
+/*[clinic input]
+_overlapped.Overlapped.AcceptEx
+
+ listen_handle as ListenSocket: HANDLE
+ accept_handle as AcceptSocket: HANDLE
+ /
+
+Start overlapped wait for client to connect.
+[clinic start generated code]*/
static PyObject *
-Overlapped_AcceptEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
+ HANDLE ListenSocket,
+ HANDLE AcceptSocket)
+/*[clinic end generated code: output=9a7381d4232af889 input=b83473224fc3a1c5]*/
{
- SOCKET ListenSocket;
- SOCKET AcceptSocket;
DWORD BytesReceived;
DWORD size;
PyObject *buf;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE,
- &ListenSocket, &AcceptSocket))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1198,12 +1267,13 @@ Overlapped_AcceptEx(OverlappedObject *self, PyObject *args)
return NULL;
self->type = TYPE_ACCEPT;
- self->handle = (HANDLE)ListenSocket;
+ self->handle = ListenSocket;
self->allocated_buffer = buf;
Py_BEGIN_ALLOW_THREADS
- ret = Py_AcceptEx(ListenSocket, AcceptSocket, PyBytes_AS_STRING(buf),
- 0, size, size, &BytesReceived, &self->overlapped);
+ ret = Py_AcceptEx((SOCKET)ListenSocket, (SOCKET)AcceptSocket,
+ PyBytes_AS_STRING(buf), 0, size, size, &BytesReceived,
+ &self->overlapped);
Py_END_ALLOW_THREADS
self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1257,28 +1327,30 @@ parse_address(PyObject *obj, SOCKADDR *Address, int Length)
return -1;
}
-PyDoc_STRVAR(
- Overlapped_ConnectEx_doc,
- "ConnectEx(client_handle, address_as_bytes) -> Overlapped[None]\n\n"
- "Start overlapped connect. client_handle should be unbound.");
+/*[clinic input]
+_overlapped.Overlapped.ConnectEx
+
+ client_handle as ConnectSocket: HANDLE
+ address_as_bytes as AddressObj: object(subclass_of='&PyTuple_Type')
+ /
+
+Start overlapped connect.
+
+client_handle should be unbound.
+[clinic start generated code]*/
static PyObject *
-Overlapped_ConnectEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
+ HANDLE ConnectSocket,
+ PyObject *AddressObj)
+/*[clinic end generated code: output=5aebbbdb4f022833 input=d6bbd2d84b156fc1]*/
{
- SOCKET ConnectSocket;
- PyObject *AddressObj;
char AddressBuf[sizeof(struct sockaddr_in6)];
SOCKADDR *Address = (SOCKADDR*)AddressBuf;
int Length;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE "O!:ConnectEx",
- &ConnectSocket, &PyTuple_Type, &AddressObj))
- {
- return NULL;
- }
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1290,10 +1362,10 @@ Overlapped_ConnectEx(OverlappedObject *self, PyObject *args)
return NULL;
self->type = TYPE_CONNECT;
- self->handle = (HANDLE)ConnectSocket;
+ self->handle = ConnectSocket;
Py_BEGIN_ALLOW_THREADS
- ret = Py_ConnectEx(ConnectSocket, Address, Length,
+ ret = Py_ConnectEx((SOCKET)ConnectSocket, Address, Length,
NULL, 0, NULL, &self->overlapped);
Py_END_ALLOW_THREADS
@@ -1308,32 +1380,33 @@ Overlapped_ConnectEx(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_DisconnectEx_doc,
- "DisconnectEx(handle, flags) -> Overlapped[None]\n\n"
- "Start overlapped connect. client_handle should be unbound.");
+/*[clinic input]
+_overlapped.Overlapped.DisconnectEx
+
+ handle as Socket: HANDLE
+ flags: DWORD
+ /
+
+[clinic start generated code]*/
static PyObject *
-Overlapped_DisconnectEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
+ HANDLE Socket, DWORD flags)
+/*[clinic end generated code: output=8d64ddb8c93c2126 input=680845cdcdf820eb]*/
{
- SOCKET Socket;
- DWORD flags;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD, &Socket, &flags))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
}
self->type = TYPE_DISCONNECT;
- self->handle = (HANDLE)Socket;
+ self->handle = Socket;
Py_BEGIN_ALLOW_THREADS
- ret = Py_DisconnectEx(Socket, &self->overlapped, flags, 0);
+ ret = Py_DisconnectEx((SOCKET)Socket, &self->overlapped, flags, 0);
Py_END_ALLOW_THREADS
self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1347,48 +1420,45 @@ Overlapped_DisconnectEx(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_TransmitFile_doc,
- "TransmitFile(socket, file, offset, offset_high, "
- "count_to_write, count_per_send, flags) "
- "-> Overlapped[None]\n\n"
- "Transmit file data over a connected socket.");
+/*[clinic input]
+_overlapped.Overlapped.TransmitFile
+
+ socket as Socket: HANDLE
+ file as File: HANDLE
+ offset: DWORD
+ offset_high: DWORD
+ count_to_write: DWORD
+ count_per_send: DWORD
+ flags: DWORD
+ /
+
+Transmit file data over a connected socket.
+[clinic start generated code]*/
static PyObject *
-Overlapped_TransmitFile(OverlappedObject *self, PyObject *args)
+_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)
+/*[clinic end generated code: output=03f3ca5512e678fd input=7e6f97b391f60e8c]*/
{
- SOCKET Socket;
- HANDLE File;
- DWORD offset;
- DWORD offset_high;
- DWORD count_to_write;
- DWORD count_per_send;
- DWORD flags;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args,
- F_HANDLE F_HANDLE F_DWORD F_DWORD
- F_DWORD F_DWORD F_DWORD,
- &Socket, &File, &offset, &offset_high,
- &count_to_write, &count_per_send,
- &flags))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
}
self->type = TYPE_TRANSMIT_FILE;
- self->handle = (HANDLE)Socket;
+ self->handle = Socket;
self->overlapped.Offset = offset;
self->overlapped.OffsetHigh = offset_high;
Py_BEGIN_ALLOW_THREADS
- ret = Py_TransmitFile(Socket, File, count_to_write, count_per_send,
- &self->overlapped,
- NULL, flags);
+ ret = Py_TransmitFile((SOCKET)Socket, File, count_to_write,
+ count_per_send, &self->overlapped, NULL, flags);
Py_END_ALLOW_THREADS
self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1402,21 +1472,23 @@ Overlapped_TransmitFile(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_ConnectNamedPipe_doc,
- "ConnectNamedPipe(handle) -> Overlapped[None]\n\n"
- "Start overlapped wait for a client to connect.");
+/*[clinic input]
+_overlapped.Overlapped.ConnectNamedPipe
+
+ handle as Pipe: HANDLE
+ /
+
+Start overlapped wait for a client to connect.
+[clinic start generated code]*/
static PyObject *
-Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
+ HANDLE Pipe)
+/*[clinic end generated code: output=3e69adfe55818abe input=8b0d4cef8a72f7bc]*/
{
- HANDLE Pipe;
BOOL ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE, &Pipe))
- return NULL;
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1443,25 +1515,22 @@ Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- ConnectPipe_doc,
- "ConnectPipe(addr) -> pipe_handle\n\n"
- "Connect to the pipe for asynchronous I/O (overlapped).");
+/*[clinic input]
+_overlapped.Overlapped.ConnectPipe
+
+ addr as Address: Py_UNICODE
+ /
+
+Connect to the pipe for asynchronous I/O (overlapped).
+[clinic start generated code]*/
static PyObject *
-overlapped_ConnectPipe(PyObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
+ const Py_UNICODE *Address)
+/*[clinic end generated code: output=3cc9661667d459d4 input=167c06a274efcefc]*/
{
- PyObject *AddressObj;
- wchar_t *Address;
HANDLE PipeHandle;
- if (!PyArg_ParseTuple(args, "U", &AddressObj))
- return NULL;
-
- Address = PyUnicode_AsWideCharString(AddressObj, NULL);
- if (Address == NULL)
- return NULL;
-
Py_BEGIN_ALLOW_THREADS
PipeHandle = CreateFileW(Address,
GENERIC_READ | GENERIC_WRITE,
@@ -1469,7 +1538,6 @@ overlapped_ConnectPipe(PyObject *self, PyObject *args)
FILE_FLAG_OVERLAPPED, NULL);
Py_END_ALLOW_THREADS
- PyMem_Free(Address);
if (PipeHandle == INVALID_HANDLE_VALUE)
return SetFromWindowsErr(0);
return Py_BuildValue(F_HANDLE, PipeHandle);
@@ -1512,29 +1580,31 @@ Overlapped_traverse(OverlappedObject *self, visitproc visit, void *arg)
// UDP functions
-PyDoc_STRVAR(
- WSAConnect_doc,
- "WSAConnect(client_handle, address_as_bytes) -> Overlapped[None]\n\n"
- "Bind a remote address to a connectionless (UDP) socket");
-
/*
* Note: WSAConnect does not support Overlapped I/O so this function should
* _only_ be used for connectionless sockets (UDP).
*/
+
+/*[clinic input]
+_overlapped.WSAConnect
+
+ client_handle as ConnectSocket: HANDLE
+ address_as_bytes as AddressObj: object
+ /
+
+Bind a remote address to a connectionless (UDP) socket.
+[clinic start generated code]*/
+
static PyObject *
-overlapped_WSAConnect(PyObject *self, PyObject *args)
+_overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
+ PyObject *AddressObj)
+/*[clinic end generated code: output=ea0b4391e94dad63 input=169f8075e9ae7fa4]*/
{
- SOCKET ConnectSocket;
- PyObject *AddressObj;
char AddressBuf[sizeof(struct sockaddr_in6)];
SOCKADDR *Address = (SOCKADDR*)AddressBuf;
int Length;
int err;
- if (!PyArg_ParseTuple(args, F_HANDLE "O", &ConnectSocket, &AddressObj)) {
- return NULL;
- }
-
Length = sizeof(AddressBuf);
Length = parse_address(AddressObj, Address, Length);
if (Length < 0) {
@@ -1544,7 +1614,7 @@ overlapped_WSAConnect(PyObject *self, PyObject *args)
Py_BEGIN_ALLOW_THREADS
// WSAConnect does not support overlapped I/O so this call will
// successfully complete immediately.
- err = WSAConnect(ConnectSocket, Address, Length,
+ err = WSAConnect((SOCKET)ConnectSocket, Address, Length,
NULL, NULL, NULL, NULL);
Py_END_ALLOW_THREADS
@@ -1556,19 +1626,24 @@ overlapped_WSAConnect(PyObject *self, PyObject *args)
}
}
-PyDoc_STRVAR(
- Overlapped_WSASendTo_doc,
- "WSASendTo(handle, buf, flags, address_as_bytes) -> "
- "Overlapped[bytes_transferred]\n\n"
- "Start overlapped sendto over a connectionless (UDP) socket");
+/*[clinic input]
+_overlapped.Overlapped.WSASendTo
+
+ handle: HANDLE
+ buf as bufobj: object
+ flags: DWORD
+ address_as_bytes as AddressObj: object
+ /
+
+Start overlapped sendto over a connectionless (UDP) socket.
+[clinic start generated code]*/
static PyObject *
-Overlapped_WSASendTo(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
+ PyObject *bufobj, DWORD flags,
+ PyObject *AddressObj)
+/*[clinic end generated code: output=fe0ff55eb60d65e1 input=f709e6ecebd9bc18]*/
{
- HANDLE handle;
- PyObject *bufobj;
- DWORD flags;
- PyObject *AddressObj;
char AddressBuf[sizeof(struct sockaddr_in6)];
SOCKADDR *Address = (SOCKADDR*)AddressBuf;
int AddressLength;
@@ -1577,12 +1652,6 @@ Overlapped_WSASendTo(OverlappedObject *self, PyObject *args)
int ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD "O",
- &handle, &bufobj, &flags, &AddressObj))
- {
- return NULL;
- }
-
// Parse the "to" address
AddressLength = sizeof(AddressBuf);
AddressLength = parse_address(AddressObj, Address, AddressLength);
@@ -1637,24 +1706,29 @@ PyDoc_STRVAR(
"RecvFile(handle, size, flags) -> Overlapped[(message, (host, port))]\n\n"
"Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.WSARecvFrom
+
+ handle: HANDLE
+ size: DWORD
+ flags: DWORD = 0
+ /
+
+Start overlapped receive.
+[clinic start generated code]*/
+
static PyObject *
-Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
+ HANDLE handle, DWORD size,
+ DWORD flags)
+/*[clinic end generated code: output=13832a2025b86860 input=1b2663fa130e0286]*/
{
- HANDLE handle;
- DWORD size;
- DWORD flags = 0;
DWORD nread;
PyObject *buf;
WSABUF wsabuf;
int ret;
DWORD err;
- if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD "|" F_DWORD,
- &handle, &size, &flags))
- {
- return NULL;
- }
-
if (self->type != TYPE_NONE) {
PyErr_SetString(PyExc_ValueError, "operation already attempted");
return NULL;
@@ -1700,38 +1774,24 @@ Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *args)
}
}
+#include "clinic/overlapped.c.h"
static PyMethodDef Overlapped_methods[] = {
- {"getresult", (PyCFunction) Overlapped_getresult,
- METH_VARARGS, Overlapped_getresult_doc},
- {"cancel", (PyCFunction) Overlapped_cancel,
- METH_NOARGS, Overlapped_cancel_doc},
- {"ReadFile", (PyCFunction) Overlapped_ReadFile,
- METH_VARARGS, Overlapped_ReadFile_doc},
- {"ReadFileInto", (PyCFunction) Overlapped_ReadFileInto,
- METH_VARARGS, Overlapped_ReadFileInto_doc},
- {"WSARecv", (PyCFunction) Overlapped_WSARecv,
- METH_VARARGS, Overlapped_WSARecv_doc},
- {"WSARecvInto", (PyCFunction) Overlapped_WSARecvInto,
- METH_VARARGS, Overlapped_WSARecvInto_doc},
- {"WriteFile", (PyCFunction) Overlapped_WriteFile,
- METH_VARARGS, Overlapped_WriteFile_doc},
- {"WSASend", (PyCFunction) Overlapped_WSASend,
- METH_VARARGS, Overlapped_WSASend_doc},
- {"AcceptEx", (PyCFunction) Overlapped_AcceptEx,
- METH_VARARGS, Overlapped_AcceptEx_doc},
- {"ConnectEx", (PyCFunction) Overlapped_ConnectEx,
- METH_VARARGS, Overlapped_ConnectEx_doc},
- {"DisconnectEx", (PyCFunction) Overlapped_DisconnectEx,
- METH_VARARGS, Overlapped_DisconnectEx_doc},
- {"TransmitFile", (PyCFunction) Overlapped_TransmitFile,
- METH_VARARGS, Overlapped_TransmitFile_doc},
- {"ConnectNamedPipe", (PyCFunction) Overlapped_ConnectNamedPipe,
- METH_VARARGS, Overlapped_ConnectNamedPipe_doc},
- {"WSARecvFrom", (PyCFunction) Overlapped_WSARecvFrom,
- METH_VARARGS, Overlapped_WSARecvFrom_doc },
- {"WSASendTo", (PyCFunction) Overlapped_WSASendTo,
- METH_VARARGS, Overlapped_WSASendTo_doc },
+ _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF
+ _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF
+ _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF
+ _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF
+ _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF
+ _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF
+ _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF
+ _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF
+ _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF
+ _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF
{NULL}
};
@@ -1774,7 +1834,7 @@ PyTypeObject OverlappedType = {
/* tp_setattro */ 0,
/* tp_as_buffer */ 0,
/* tp_flags */ Py_TPFLAGS_DEFAULT,
- /* tp_doc */ "OVERLAPPED structure wrapper",
+ /* tp_doc */ _overlapped_Overlapped__doc__,
/* tp_traverse */ (traverseproc)Overlapped_traverse,
/* tp_clear */ 0,
/* tp_richcompare */ 0,
@@ -1791,36 +1851,23 @@ PyTypeObject OverlappedType = {
/* tp_dictoffset */ 0,
/* tp_init */ 0,
/* tp_alloc */ 0,
- /* tp_new */ Overlapped_new,
+ /* tp_new */ _overlapped_Overlapped,
};
static PyMethodDef overlapped_functions[] = {
- {"CreateIoCompletionPort", overlapped_CreateIoCompletionPort,
- METH_VARARGS, CreateIoCompletionPort_doc},
- {"GetQueuedCompletionStatus", overlapped_GetQueuedCompletionStatus,
- METH_VARARGS, GetQueuedCompletionStatus_doc},
- {"PostQueuedCompletionStatus", overlapped_PostQueuedCompletionStatus,
- METH_VARARGS, PostQueuedCompletionStatus_doc},
- {"FormatMessage", overlapped_FormatMessage,
- METH_VARARGS, FormatMessage_doc},
- {"BindLocal", overlapped_BindLocal,
- METH_VARARGS, BindLocal_doc},
- {"RegisterWaitWithQueue", overlapped_RegisterWaitWithQueue,
- METH_VARARGS, RegisterWaitWithQueue_doc},
- {"UnregisterWait", overlapped_UnregisterWait,
- METH_VARARGS, UnregisterWait_doc},
- {"UnregisterWaitEx", overlapped_UnregisterWaitEx,
- METH_VARARGS, UnregisterWaitEx_doc},
- {"CreateEvent", overlapped_CreateEvent,
- METH_VARARGS, CreateEvent_doc},
- {"SetEvent", overlapped_SetEvent,
- METH_VARARGS, SetEvent_doc},
- {"ResetEvent", overlapped_ResetEvent,
- METH_VARARGS, ResetEvent_doc},
- {"ConnectPipe", overlapped_ConnectPipe,
- METH_VARARGS, ConnectPipe_doc},
- {"WSAConnect", overlapped_WSAConnect,
- METH_VARARGS, WSAConnect_doc},
+ _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF
+ _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF
+ _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF
+ _OVERLAPPED_FORMATMESSAGE_METHODDEF
+ _OVERLAPPED_BINDLOCAL_METHODDEF
+ _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF
+ _OVERLAPPED_UNREGISTERWAIT_METHODDEF
+ _OVERLAPPED_UNREGISTERWAITEX_METHODDEF
+ _OVERLAPPED_CREATEEVENT_METHODDEF
+ _OVERLAPPED_SETEVENT_METHODDEF
+ _OVERLAPPED_RESETEVENT_METHODDEF
+ _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF
+ _OVERLAPPED_WSACONNECT_METHODDEF
{NULL}
};
More information about the Python-checkins
mailing list