bpo-20175: Convert Modules/_multiprocessing to the Argument Clinic (GH-14245)

Modules/_multiprocessing/clinic/multiprocessing.c.h

@@ -0,0 +1,151 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_closesocket__doc__,
+"closesocket($module, handle, /)\n"
+"--\n"
+"\n");
+
+#define _MULTIPROCESSING_CLOSESOCKET_METHODDEF    \
+    {"closesocket", (PyCFunction)_multiprocessing_closesocket, METH_O, _multiprocessing_closesocket__doc__},
+
+static PyObject *
+_multiprocessing_closesocket_impl(PyObject *module, HANDLE handle);
+
+static PyObject *
+_multiprocessing_closesocket(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+
+    if (!PyArg_Parse(arg, ""F_HANDLE":closesocket", &handle)) {
+        goto exit;
+    }
+    return_value = _multiprocessing_closesocket_impl(module, handle);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_recv__doc__,
+"recv($module, handle, size, /)\n"
+"--\n"
+"\n");
+
+#define _MULTIPROCESSING_RECV_METHODDEF    \
+    {"recv", (PyCFunction)(void(*)(void))_multiprocessing_recv, METH_FASTCALL, _multiprocessing_recv__doc__},
+
+static PyObject *
+_multiprocessing_recv_impl(PyObject *module, HANDLE handle, int size);
+
+static PyObject *
+_multiprocessing_recv(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    int size;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:recv",
+        &handle, &size)) {
+        goto exit;
+    }
+    return_value = _multiprocessing_recv_impl(module, handle, size);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_send__doc__,
+"send($module, handle, buf, /)\n"
+"--\n"
+"\n");
+
+#define _MULTIPROCESSING_SEND_METHODDEF    \
+    {"send", (PyCFunction)(void(*)(void))_multiprocessing_send, METH_FASTCALL, _multiprocessing_send__doc__},
+
+static PyObject *
+_multiprocessing_send_impl(PyObject *module, HANDLE handle, Py_buffer *buf);
+
+static PyObject *
+_multiprocessing_send(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    Py_buffer buf = {NULL, NULL};
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:send",
+        &handle, &buf)) {
+        goto exit;
+    }
+    return_value = _multiprocessing_send_impl(module, handle, &buf);
+
+exit:
+    /* Cleanup for buf */
+    if (buf.obj) {
+       PyBuffer_Release(&buf);
+    }
+
+    return return_value;
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+PyDoc_STRVAR(_multiprocessing_sem_unlink__doc__,
+"sem_unlink($module, name, /)\n"
+"--\n"
+"\n");
+
+#define _MULTIPROCESSING_SEM_UNLINK_METHODDEF    \
+    {"sem_unlink", (PyCFunction)_multiprocessing_sem_unlink, METH_O, _multiprocessing_sem_unlink__doc__},
+
+static PyObject *
+_multiprocessing_sem_unlink_impl(PyObject *module, const char *name);
+
+static PyObject *
+_multiprocessing_sem_unlink(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const char *name;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("sem_unlink", "argument", "str", arg);
+        goto exit;
+    }
+    Py_ssize_t name_length;
+    name = PyUnicode_AsUTF8AndSize(arg, &name_length);
+    if (name == NULL) {
+        goto exit;
+    }
+    if (strlen(name) != (size_t)name_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    return_value = _multiprocessing_sem_unlink_impl(module, name);
+
+exit:
+    return return_value;
+}
+
+#ifndef _MULTIPROCESSING_CLOSESOCKET_METHODDEF
+    #define _MULTIPROCESSING_CLOSESOCKET_METHODDEF
+#endif /* !defined(_MULTIPROCESSING_CLOSESOCKET_METHODDEF) */
+
+#ifndef _MULTIPROCESSING_RECV_METHODDEF
+    #define _MULTIPROCESSING_RECV_METHODDEF
+#endif /* !defined(_MULTIPROCESSING_RECV_METHODDEF) */
+
+#ifndef _MULTIPROCESSING_SEND_METHODDEF
+    #define _MULTIPROCESSING_SEND_METHODDEF
+#endif /* !defined(_MULTIPROCESSING_SEND_METHODDEF) */
+/*[clinic end generated code: output=418191c446cd5751 input=a9049054013a1b77]*/

Modules/_multiprocessing/clinic/semaphore.c.h

@@ -0,0 +1,402 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
+"acquire($self, /, block=True, timeout=None)\n"
+"--\n"
+"\n"
+"Acquire the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF    \
+    {"acquire", (PyCFunction)(void(*)(void))_multiprocessing_SemLock_acquire, METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
+
+static PyObject *
+_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
+                                      PyObject *timeout_obj);
+
+static PyObject *
+_multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    static const char * const _keywords[] = {"block", "timeout", NULL};
+    static _PyArg_Parser _parser = {NULL, _keywords, "acquire", 0};
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    int blocking = 1;
+    PyObject *timeout_obj = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        blocking = _PyLong_AsInt(args[0]);
+        if (blocking == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    timeout_obj = args[1];
+skip_optional_pos:
+    return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
+"release($self, /)\n"
+"--\n"
+"\n"
+"Release the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF    \
+    {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
+
+static PyObject *
+_multiprocessing_SemLock_release_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock_release_impl(self);
+}
+
+#endif /* defined(MS_WINDOWS) */
+
+#if !defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
+"acquire($self, /, block=True, timeout=None)\n"
+"--\n"
+"\n"
+"Acquire the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF    \
+    {"acquire", (PyCFunction)(void(*)(void))_multiprocessing_SemLock_acquire, METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
+
+static PyObject *
+_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
+                                      PyObject *timeout_obj);
+
+static PyObject *
+_multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    static const char * const _keywords[] = {"block", "timeout", NULL};
+    static _PyArg_Parser _parser = {NULL, _keywords, "acquire", 0};
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    int blocking = 1;
+    PyObject *timeout_obj = Py_None;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        blocking = _PyLong_AsInt(args[0]);
+        if (blocking == -1 && PyErr_Occurred()) {
+            goto exit;
+        }
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+    timeout_obj = args[1];
+skip_optional_pos:
+    return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
+
+exit:
+    return return_value;
+}
+
+#endif /* !defined(MS_WINDOWS) */
+
+#if !defined(MS_WINDOWS)
+
+PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
+"release($self, /)\n"
+"--\n"
+"\n"
+"Release the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF    \
+    {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
+
+static PyObject *
+_multiprocessing_SemLock_release_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock_release_impl(self);
+}
+
+#endif /* !defined(MS_WINDOWS) */
+
+static PyObject *
+_multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
+                              int maxvalue, const char *name, int unlink);
+
+static PyObject *
+_multiprocessing_SemLock(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static const char * const _keywords[] = {"kind", "value", "maxvalue", "name", "unlink", NULL};
+    static _PyArg_Parser _parser = {NULL, _keywords, "SemLock", 0};
+    PyObject *argsbuf[5];
+    PyObject * const *fastargs;
+    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+    int kind;
+    int value;
+    int maxvalue;
+    const char *name;
+    int unlink;
+
+    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 5, 5, 0, argsbuf);
+    if (!fastargs) {
+        goto exit;
+    }
+    kind = _PyLong_AsInt(fastargs[0]);
+    if (kind == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    value = _PyLong_AsInt(fastargs[1]);
+    if (value == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    maxvalue = _PyLong_AsInt(fastargs[2]);
+    if (maxvalue == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    if (!PyUnicode_Check(fastargs[3])) {
+        _PyArg_BadArgument("SemLock", "argument 'name'", "str", fastargs[3]);
+        goto exit;
+    }
+    Py_ssize_t name_length;
+    name = PyUnicode_AsUTF8AndSize(fastargs[3], &name_length);
+    if (name == NULL) {
+        goto exit;
+    }
+    if (strlen(name) != (size_t)name_length) {
+        PyErr_SetString(PyExc_ValueError, "embedded null character");
+        goto exit;
+    }
+    unlink = _PyLong_AsInt(fastargs[4]);
+    if (unlink == -1 && PyErr_Occurred()) {
+        goto exit;
+    }
+    return_value = _multiprocessing_SemLock_impl(type, kind, value, maxvalue, name, unlink);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__rebuild__doc__,
+"_rebuild($type, handle, kind, maxvalue, name, /)\n"
+"--\n"
+"\n");
+
+#define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF    \
+    {"_rebuild", (PyCFunction)(void(*)(void))_multiprocessing_SemLock__rebuild, METH_FASTCALL|METH_CLASS, _multiprocessing_SemLock__rebuild__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle,
+                                       int kind, int maxvalue,
+                                       const char *name);
+
+static PyObject *
+_multiprocessing_SemLock__rebuild(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    SEM_HANDLE handle;
+    int kind;
+    int maxvalue;
+    const char *name;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_SEM_HANDLE"iiz:_rebuild",
+        &handle, &kind, &maxvalue, &name)) {
+        goto exit;
+    }
+    return_value = _multiprocessing_SemLock__rebuild_impl(type, handle, kind, maxvalue, name);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__count__doc__,
+"_count($self, /)\n"
+"--\n"
+"\n"
+"Num of `acquire()`s minus num of `release()`s for this process.");
+
+#define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF    \
+    {"_count", (PyCFunction)_multiprocessing_SemLock__count, METH_NOARGS, _multiprocessing_SemLock__count__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__count_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock__count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock__count_impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__is_mine__doc__,
+"_is_mine($self, /)\n"
+"--\n"
+"\n"
+"Whether the lock is owned by this thread.");
+
+#define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF    \
+    {"_is_mine", (PyCFunction)_multiprocessing_SemLock__is_mine, METH_NOARGS, _multiprocessing_SemLock__is_mine__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__is_mine_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock__is_mine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock__is_mine_impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__get_value__doc__,
+"_get_value($self, /)\n"
+"--\n"
+"\n"
+"Get the value of the semaphore.");
+
+#define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF    \
+    {"_get_value", (PyCFunction)_multiprocessing_SemLock__get_value, METH_NOARGS, _multiprocessing_SemLock__get_value__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__get_value_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock__get_value(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock__get_value_impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__is_zero__doc__,
+"_is_zero($self, /)\n"
+"--\n"
+"\n"
+"Return whether semaphore has value zero.");
+
+#define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF    \
+    {"_is_zero", (PyCFunction)_multiprocessing_SemLock__is_zero, METH_NOARGS, _multiprocessing_SemLock__is_zero__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__is_zero_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock__is_zero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock__is_zero_impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock__after_fork__doc__,
+"_after_fork($self, /)\n"
+"--\n"
+"\n"
+"Rezero the net acquisition count after fork().");
+
+#define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF    \
+    {"_after_fork", (PyCFunction)_multiprocessing_SemLock__after_fork, METH_NOARGS, _multiprocessing_SemLock__after_fork__doc__},
+
+static PyObject *
+_multiprocessing_SemLock__after_fork_impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock__after_fork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock__after_fork_impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock___enter____doc__,
+"__enter__($self, /)\n"
+"--\n"
+"\n"
+"Enter the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF    \
+    {"__enter__", (PyCFunction)_multiprocessing_SemLock___enter__, METH_NOARGS, _multiprocessing_SemLock___enter____doc__},
+
+static PyObject *
+_multiprocessing_SemLock___enter___impl(SemLockObject *self);
+
+static PyObject *
+_multiprocessing_SemLock___enter__(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _multiprocessing_SemLock___enter___impl(self);
+}
+
+PyDoc_STRVAR(_multiprocessing_SemLock___exit____doc__,
+"__exit__($self, exc_type=None, exc_value=None, exc_tb=None, /)\n"
+"--\n"
+"\n"
+"Exit the semaphore/lock.");
+
+#define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF    \
+    {"__exit__", (PyCFunction)(void(*)(void))_multiprocessing_SemLock___exit__, METH_FASTCALL, _multiprocessing_SemLock___exit____doc__},
+
+static PyObject *
+_multiprocessing_SemLock___exit___impl(SemLockObject *self,
+                                       PyObject *exc_type,
+                                       PyObject *exc_value, PyObject *exc_tb);
+
+static PyObject *
+_multiprocessing_SemLock___exit__(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *exc_type = Py_None;
+    PyObject *exc_value = Py_None;
+    PyObject *exc_tb = Py_None;
+
+    if (!_PyArg_CheckPositional("__exit__", nargs, 0, 3)) {
+        goto exit;
+    }
+    if (nargs < 1) {
+        goto skip_optional;
+    }
+    exc_type = args[0];
+    if (nargs < 2) {
+        goto skip_optional;
+    }
+    exc_value = args[1];
+    if (nargs < 3) {
+        goto skip_optional;
+    }
+    exc_tb = args[2];
+skip_optional:
+    return_value = _multiprocessing_SemLock___exit___impl(self, exc_type, exc_value, exc_tb);
+
+exit:
+    return return_value;
+}
+
+#ifndef _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
+    #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
+#endif /* !defined(_MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF) */
+
+#ifndef _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
+    #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
+#endif /* !defined(_MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF) */
+/*[clinic end generated code: output=e7fd938150601fe5 input=a9049054013a1b77]*/

Modules/_multiprocessing/multiprocessing.c

@@ -9,6 +9,20 @@
 
 #include "multiprocessing.h"
 
+/*[python input]
+class HANDLE_converter(CConverter):
+    type = "HANDLE"
+    format_unit = '"F_HANDLE"'
+
+[python start generated code]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=9fad6080b79ace91]*/
+
+/*[clinic input]
+module _multiprocessing
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=01e0745f380ac6e3]*/
+
+#include "clinic/multiprocessing.c.h"
 
 /*
  * Function which raises exceptions based on error codes
@@ -50,14 +64,19 @@ _PyMp_SetError(PyObject *Type, int num)
 }
 
 #ifdef MS_WINDOWS
-static PyObject *
+/*[clinic input]
-multiprocessing_closesocket(PyObject *self, PyObject *args)
+_multiprocessing.closesocket
-{
-    HANDLE handle;
-    int ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle))
+    handle: HANDLE
-        return NULL;
+    /
+
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_closesocket_impl(PyObject *module, HANDLE handle)
+/*[clinic end generated code: output=214f359f900966f4 input=8a20706dd386c6cc]*/
+{
+    int ret;
 
     Py_BEGIN_ALLOW_THREADS
     ret = closesocket((SOCKET) handle);
@@ -68,15 +87,21 @@ multiprocessing_closesocket(PyObject *self, PyObject *args)
     Py_RETURN_NONE;
 }
 
-static PyObject *
+/*[clinic input]
-multiprocessing_recv(PyObject *self, PyObject *args)
+_multiprocessing.recv
-{
-    HANDLE handle;
-    int size, nread;
-    PyObject *buf;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size))
+    handle: HANDLE
-        return NULL;
+    size: int
+    /
+
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_recv_impl(PyObject *module, HANDLE handle, int size)
+/*[clinic end generated code: output=92322781ba9ff598 input=6a5b0834372cee5b]*/
+{
+    int nread;
+    PyObject *buf;
 
     buf = PyBytes_FromStringAndSize(NULL, size);
     if (!buf)
@@ -94,23 +119,27 @@ multiprocessing_recv(PyObject *self, PyObject *args)
     return buf;
 }
 
+/*[clinic input]
+_multiprocessing.send
+
+    handle: HANDLE
+    buf: Py_buffer
+    /
+
+[clinic start generated code]*/
+
 static PyObject *
-multiprocessing_send(PyObject *self, PyObject *args)
+_multiprocessing_send_impl(PyObject *module, HANDLE handle, Py_buffer *buf)
+/*[clinic end generated code: output=52d7df0519c596cb input=41dce742f98d2210]*/
 {
-    HANDLE handle;
-    Py_buffer buf;
     int ret, length;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf))
+    length = (int)Py_MIN(buf->len, INT_MAX);
-        return NULL;
-
-    length = (int)Py_MIN(buf.len, INT_MAX);
 
     Py_BEGIN_ALLOW_THREADS
-    ret = send((SOCKET) handle, buf.buf, length, 0);
+    ret = send((SOCKET) handle, buf->buf, length, 0);
     Py_END_ALLOW_THREADS
 
-    PyBuffer_Release(&buf);
     if (ret < 0)
         return PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
     return PyLong_FromLong(ret);
@@ -118,18 +147,33 @@ multiprocessing_send(PyObject *self, PyObject *args)
 
 #endif
 
+/*[clinic input]
+_multiprocessing.sem_unlink
+
+    name: str
+    /
+
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_sem_unlink_impl(PyObject *module, const char *name)
+/*[clinic end generated code: output=fcbfeb1ed255e647 input=bf939aff9564f1d5]*/
+{
+    return _PyMp_sem_unlink(name);
+}
+
 /*
  * Function table
  */
 
 static PyMethodDef module_methods[] = {
 #ifdef MS_WINDOWS
-    {"closesocket", multiprocessing_closesocket, METH_VARARGS, ""},
+    _MULTIPROCESSING_CLOSESOCKET_METHODDEF
-    {"recv", multiprocessing_recv, METH_VARARGS, ""},
+    _MULTIPROCESSING_RECV_METHODDEF
-    {"send", multiprocessing_send, METH_VARARGS, ""},
+    _MULTIPROCESSING_SEND_METHODDEF
 #endif
 #if !defined(POSIX_SEMAPHORES_NOT_ENABLED) && !defined(__ANDROID__)
-    {"sem_unlink", _PyMp_sem_unlink, METH_VARARGS, ""},
+    _MULTIPROCESSING_SEM_UNLINK_METHODDEF
 #endif
     {NULL}
 };

Modules/_multiprocessing/multiprocessing.h

@@ -88,6 +88,6 @@ PyObject *_PyMp_SetError(PyObject *Type, int num);
  */
 
 extern PyTypeObject _PyMp_SemLockType;
-extern PyObject *_PyMp_sem_unlink(PyObject *ignore, PyObject *args);
+extern PyObject *_PyMp_sem_unlink(const char *name);
 
 #endif /* MULTIPROCESSING_H */

Modules/_multiprocessing/semaphore.c

@@ -21,6 +21,22 @@ typedef struct {
     char *name;
 } SemLockObject;
 
+/*[python input]
+class SEM_HANDLE_converter(CConverter):
+    type = "SEM_HANDLE"
+    format_unit = '"F_SEM_HANDLE"'
+
+[python start generated code]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=3e0ad43e482d8716]*/
+
+/*[clinic input]
+module _multiprocessing
+class _multiprocessing.SemLock "SemLockObject *" "&_PyMp_SemLockType"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=935fb41b7d032599]*/
+
+#include "clinic/semaphore.c.h"
+
 #define ISMINE(o) (o->count > 0 && PyThread_get_thread_ident() == o->last_tid)
 
 
@@ -58,21 +74,24 @@ _GetSemaphoreValue(HANDLE handle, long *value)
     }
 }
 
+/*[clinic input]
+_multiprocessing.SemLock.acquire
+
+    block as blocking: bool(accept={int}) = True
+    timeout as timeout_obj: object = None
+
+Acquire the semaphore/lock.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
+_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
+                                      PyObject *timeout_obj)
+/*[clinic end generated code: output=f9998f0b6b0b0872 input=86f05662cf753eb4]*/
 {
-    int blocking = 1;
     double timeout;
-    PyObject *timeout_obj = Py_None;
     DWORD res, full_msecs, nhandles;
     HANDLE handles[2], sigint_event;
 
-    static char *kwlist[] = {"block", "timeout", NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
-                                     &blocking, &timeout_obj))
-        return NULL;
-
     /* calculate timeout */
     if (!blocking) {
         full_msecs = 0;
@@ -146,8 +165,15 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
     }
 }
 
+/*[clinic input]
+_multiprocessing.SemLock.release
+
+Release the semaphore/lock.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_release(SemLockObject *self, PyObject *args)
+_multiprocessing_SemLock_release_impl(SemLockObject *self)
+/*[clinic end generated code: output=b22f53ba96b0d1db input=ba7e63a961885d3d]*/
 {
     if (self->kind == RECURSIVE_MUTEX) {
         if (!ISMINE(self)) {
@@ -264,19 +290,23 @@ sem_timedwait_save(sem_t *sem, struct timespec *deadline, PyThreadState *_save)
 
 #endif /* !HAVE_SEM_TIMEDWAIT */
 
+/*[clinic input]
+_multiprocessing.SemLock.acquire
+
+    block as blocking: bool(accept={int}) = True
+    timeout as timeout_obj: object = None
+
+Acquire the semaphore/lock.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
+_multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
+                                      PyObject *timeout_obj)
+/*[clinic end generated code: output=f9998f0b6b0b0872 input=86f05662cf753eb4]*/
 {
-    int blocking = 1, res, err = 0;
+    int res, err = 0;
-    PyObject *timeout_obj = Py_None;
     struct timespec deadline = {0};
 
-    static char *kwlist[] = {"block", "timeout", NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
-                                     &blocking, &timeout_obj))
-        return NULL;
-
     if (self->kind == RECURSIVE_MUTEX && ISMINE(self)) {
         ++self->count;
         Py_RETURN_TRUE;
@@ -345,8 +375,15 @@ semlock_acquire(SemLockObject *self, PyObject *args, PyObject *kwds)
     Py_RETURN_TRUE;
 }
 
+/*[clinic input]
+_multiprocessing.SemLock.release
+
+Release the semaphore/lock.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_release(SemLockObject *self, PyObject *args)
+_multiprocessing_SemLock_release_impl(SemLockObject *self)
+/*[clinic end generated code: output=b22f53ba96b0d1db input=ba7e63a961885d3d]*/
 {
     if (self->kind == RECURSIVE_MUTEX) {
         if (!ISMINE(self)) {
@@ -429,19 +466,26 @@ newsemlockobject(PyTypeObject *type, SEM_HANDLE handle, int kind, int maxvalue,
     return (PyObject*)self;
 }
 
+/*[clinic input]
+@classmethod
+_multiprocessing.SemLock.__new__
+
+    kind: int
+    value: int
+    maxvalue: int
+    name: str
+    unlink: bool(accept={int})
+
+[clinic start generated code]*/
+
 static PyObject *
-semlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+_multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
+                              int maxvalue, const char *name, int unlink)
+/*[clinic end generated code: output=30727e38f5f7577a input=b378c3ee27d3a0fa]*/
 {
     SEM_HANDLE handle = SEM_FAILED;
-    int kind, maxvalue, value, unlink;
     PyObject *result;
-    char *name, *name_copy = NULL;
+    char *name_copy = NULL;
-    static char *kwlist[] = {"kind", "value", "maxvalue", "name", "unlink",
-                             NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "iiisi", kwlist,
-                                     &kind, &value, &maxvalue, &name, &unlink))
-        return NULL;
 
     if (kind != RECURSIVE_MUTEX && kind != SEMAPHORE) {
         PyErr_SetString(PyExc_ValueError, "unrecognized kind");
@@ -481,16 +525,25 @@ semlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     return NULL;
 }
 
-static PyObject *
+/*[clinic input]
-semlock_rebuild(PyTypeObject *type, PyObject *args)
+@classmethod
-{
+_multiprocessing.SemLock._rebuild
-    SEM_HANDLE handle;
-    int kind, maxvalue;
-    char *name, *name_copy = NULL;
 
-    if (!PyArg_ParseTuple(args, F_SEM_HANDLE "iiz",
+    handle: SEM_HANDLE
-                          &handle, &kind, &maxvalue, &name))
+    kind: int
-        return NULL;
+    maxvalue: int
+    name: str(accept={str, NoneType})
+    /
+
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle,
+                                       int kind, int maxvalue,
+                                       const char *name)
+/*[clinic end generated code: output=2aaee14f063f3bd9 input=f7040492ac6d9962]*/
+{
+    char *name_copy = NULL;
 
     if (name != NULL) {
         name_copy = PyMem_Malloc(strlen(name) + 1);
@@ -521,21 +574,42 @@ semlock_dealloc(SemLockObject* self)
     PyObject_Del(self);
 }
 
+/*[clinic input]
+_multiprocessing.SemLock._count
+
+Num of `acquire()`s minus num of `release()`s for this process.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+_multiprocessing_SemLock__count_impl(SemLockObject *self)
+/*[clinic end generated code: output=5ba8213900e517bb input=36fc59b1cd1025ab]*/
 {
     return PyLong_FromLong((long)self->count);
 }
 
+/*[clinic input]
+_multiprocessing.SemLock._is_mine
+
+Whether the lock is owned by this thread.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_ismine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+_multiprocessing_SemLock__is_mine_impl(SemLockObject *self)
+/*[clinic end generated code: output=92dc98863f4303be input=a96664cb2f0093ba]*/
 {
     /* only makes sense for a lock */
     return PyBool_FromLong(ISMINE(self));
 }
 
+/*[clinic input]
+_multiprocessing.SemLock._get_value
+
+Get the value of the semaphore.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_getvalue(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+_multiprocessing_SemLock__get_value_impl(SemLockObject *self)
+/*[clinic end generated code: output=64bc1b89bda05e36 input=cb10f9a769836203]*/
 {
 #ifdef HAVE_BROKEN_SEM_GETVALUE
     PyErr_SetNone(PyExc_NotImplementedError);
@@ -552,8 +626,15 @@ semlock_getvalue(SemLockObject *self, PyObject *Py_UNUSED(ignored))
 #endif
 }
 
+/*[clinic input]
+_multiprocessing.SemLock._is_zero
+
+Return whether semaphore has value zero.
+[clinic start generated code]*/
+
 static PyObject *
-semlock_iszero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+_multiprocessing_SemLock__is_zero_impl(SemLockObject *self)
+/*[clinic end generated code: output=815d4c878c806ed7 input=294a446418d31347]*/
 {
 #ifdef HAVE_BROKEN_SEM_GETVALUE
     if (sem_trywait(self->handle) < 0) {
@@ -573,38 +654,68 @@ semlock_iszero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
 #endif
 }
 
+/*[clinic input]
+_multiprocessing.SemLock._after_fork
+
+Rezero the net acquisition count after fork().
+[clinic start generated code]*/
+
 static PyObject *
-semlock_afterfork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
+_multiprocessing_SemLock__after_fork_impl(SemLockObject *self)
+/*[clinic end generated code: output=718bb27914c6a6c1 input=190991008a76621e]*/
 {
     self->count = 0;
     Py_RETURN_NONE;
 }
 
+/*[clinic input]
+_multiprocessing.SemLock.__enter__
+
+Enter the semaphore/lock.
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_SemLock___enter___impl(SemLockObject *self)
+/*[clinic end generated code: output=beeb2f07c858511f input=c5e27d594284690b]*/
+{
+    return _multiprocessing_SemLock_acquire_impl(self, 1, Py_None);
+}
+
+/*[clinic input]
+_multiprocessing.SemLock.__exit__
+
+    exc_type: object = None
+    exc_value: object = None
+    exc_tb: object = None
+    /
+
+Exit the semaphore/lock.
+[clinic start generated code]*/
+
+static PyObject *
+_multiprocessing_SemLock___exit___impl(SemLockObject *self,
+                                       PyObject *exc_type,
+                                       PyObject *exc_value, PyObject *exc_tb)
+/*[clinic end generated code: output=3b37c1a9f8b91a03 input=7d644b64a89903f8]*/
+{
+    return _multiprocessing_SemLock_release_impl(self);
+}
+
 /*
  * Semaphore methods
  */
 
 static PyMethodDef semlock_methods[] = {
-    {"acquire", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
+    _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
-     "acquire the semaphore/lock"},
+    _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
-    {"release", (PyCFunction)semlock_release, METH_NOARGS,
+    _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
-     "release the semaphore/lock"},
+    _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
-    {"__enter__", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
+    _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
-     "enter the semaphore/lock"},
+    _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
-    {"__exit__", (PyCFunction)semlock_release, METH_VARARGS,
+    _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
-     "exit the semaphore/lock"},
+    _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
-    {"_count", (PyCFunction)semlock_count, METH_NOARGS,
+    _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
-     "num of `acquire()`s minus num of `release()`s for this process"},
+    _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
-    {"_is_mine", (PyCFunction)semlock_ismine, METH_NOARGS,
-     "whether the lock is owned by this thread"},
-    {"_get_value", (PyCFunction)semlock_getvalue, METH_NOARGS,
-     "get the value of the semaphore"},
-    {"_is_zero", (PyCFunction)semlock_iszero, METH_NOARGS,
-     "returns whether semaphore has value zero"},
-    {"_rebuild", (PyCFunction)semlock_rebuild, METH_VARARGS | METH_CLASS,
-     ""},
-    {"_after_fork", (PyCFunction)semlock_afterfork, METH_NOARGS,
-     "rezero the net acquisition count after fork()"},
     {NULL}
 };
 
@@ -666,7 +777,7 @@ PyTypeObject _PyMp_SemLockType = {
     /* tp_dictoffset     */ 0,
     /* tp_init           */ 0,
     /* tp_alloc          */ 0,
-    /* tp_new            */ semlock_new,
+    /* tp_new            */ _multiprocessing_SemLock,
 };
 
 /*
@@ -674,13 +785,8 @@ PyTypeObject _PyMp_SemLockType = {
  */
 
 PyObject *
-_PyMp_sem_unlink(PyObject *ignore, PyObject *args)
+_PyMp_sem_unlink(const char *name)
 {
-    char *name;
-
-    if (!PyArg_ParseTuple(args, "s", &name))
-        return NULL;
-
     if (SEM_UNLINK(name) < 0) {
         _PyMp_SetError(NULL, MP_STANDARD_ERROR);
         return NULL;