8 files changed, 1799 insertions, 16 deletions
diff --git a/Modules/clinic/_lzmamodule.c.h b/Modules/clinic/_lzmamodule.c.h
index c1ad882..6364271 100644
--- a/Modules/clinic/_lzmamodule.c.h
+++ b/Modules/clinic/_lzmamodule.c.h
@@ -62,34 +62,43 @@ _lzma_LZMACompressor_flush(Compressor *self, PyObject *Py_UNUSED(ignored))
 }
 
 PyDoc_STRVAR(_lzma_LZMADecompressor_decompress__doc__,
-"decompress($self, data, /)\n"
+"decompress($self, /, data, max_length=-1)\n"
 "--\n"
 "\n"
-"Provide data to the decompressor object.\n"
+"Decompress *data*, returning uncompressed data as bytes.\n"
 "\n"
-"Returns a chunk of decompressed data if possible, or b\'\' otherwise.\n"
+"If *max_length* is nonnegative, returns at most *max_length* bytes of\n"
+"decompressed data. If this limit is reached and further output can be\n"
+"produced, *self.needs_input* will be set to ``False``. In this case, the next\n"
+"call to *decompress()* may provide *data* as b\'\' to obtain more of the output.\n"
 "\n"
-"Attempting to decompress data after the end of stream is reached\n"
-"raises an EOFError.  Any data found after the end of the stream\n"
-"is ignored and saved in the unused_data attribute.");
+"If all of the input data was decompressed and returned (either because this\n"
+"was less than *max_length* bytes, or because *max_length* was negative),\n"
+"*self.needs_input* will be set to True.\n"
+"\n"
+"Attempting to decompress data after the end of stream is reached raises an\n"
+"EOFError.  Any data found after the end of the stream is ignored and saved in\n"
+"the unused_data attribute.");
 
 #define _LZMA_LZMADECOMPRESSOR_DECOMPRESS_METHODDEF    \
-    {"decompress", (PyCFunction)_lzma_LZMADecompressor_decompress, METH_VARARGS, _lzma_LZMADecompressor_decompress__doc__},
+    {"decompress", (PyCFunction)_lzma_LZMADecompressor_decompress, METH_VARARGS|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
 
 static PyObject *
-_lzma_LZMADecompressor_decompress_impl(Decompressor *self, Py_buffer *data);
+_lzma_LZMADecompressor_decompress_impl(Decompressor *self, Py_buffer *data, Py_ssize_t max_length);
 
 static PyObject *
-_lzma_LZMADecompressor_decompress(Decompressor *self, PyObject *args)
+_lzma_LZMADecompressor_decompress(Decompressor *self, PyObject *args, PyObject *kwargs)
 {
     PyObject *return_value = NULL;
+    static char *_keywords[] = {"data", "max_length", NULL};
     Py_buffer data = {NULL, NULL};
+    Py_ssize_t max_length = -1;
 
-    if (!PyArg_ParseTuple(args,
-        "y*:decompress",
-        &data))
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "y*|n:decompress", _keywords,
+        &data, &max_length))
         goto exit;
-    return_value = _lzma_LZMADecompressor_decompress_impl(self, &data);
+    return_value = _lzma_LZMADecompressor_decompress_impl(self, &data, max_length);
 
 exit:
     /* Cleanup for data */
@@ -242,4 +251,4 @@ exit:
 
     return return_value;
 }
-/*[clinic end generated code: output=808fec8216ac712b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=dc42b73890609369 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/arraymodule.c.h b/Modules/clinic/arraymodule.c.h
new file mode 100644
index 0000000..57d7690
--- /dev/null
+++ b/Modules/clinic/arraymodule.c.h
@@ -0,0 +1,505 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(array_array___copy____doc__,
+"__copy__($self, /)\n"
+"--\n"
+"\n"
+"Return a copy of the array.");
+
+#define ARRAY_ARRAY___COPY___METHODDEF    \
+    {"__copy__", (PyCFunction)array_array___copy__, METH_NOARGS, array_array___copy____doc__},
+
+static PyObject *
+array_array___copy___impl(arrayobject *self);
+
+static PyObject *
+array_array___copy__(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array___copy___impl(self);
+}
+
+PyDoc_STRVAR(array_array___deepcopy____doc__,
+"__deepcopy__($self, unused, /)\n"
+"--\n"
+"\n"
+"Return a copy of the array.");
+
+#define ARRAY_ARRAY___DEEPCOPY___METHODDEF    \
+    {"__deepcopy__", (PyCFunction)array_array___deepcopy__, METH_O, array_array___deepcopy____doc__},
+
+PyDoc_STRVAR(array_array_count__doc__,
+"count($self, v, /)\n"
+"--\n"
+"\n"
+"Return number of occurrences of v in the array.");
+
+#define ARRAY_ARRAY_COUNT_METHODDEF    \
+    {"count", (PyCFunction)array_array_count, METH_O, array_array_count__doc__},
+
+PyDoc_STRVAR(array_array_index__doc__,
+"index($self, v, /)\n"
+"--\n"
+"\n"
+"Return index of first occurrence of v in the array.");
+
+#define ARRAY_ARRAY_INDEX_METHODDEF    \
+    {"index", (PyCFunction)array_array_index, METH_O, array_array_index__doc__},
+
+PyDoc_STRVAR(array_array_remove__doc__,
+"remove($self, v, /)\n"
+"--\n"
+"\n"
+"Remove the first occurrence of v in the array.");
+
+#define ARRAY_ARRAY_REMOVE_METHODDEF    \
+    {"remove", (PyCFunction)array_array_remove, METH_O, array_array_remove__doc__},
+
+PyDoc_STRVAR(array_array_pop__doc__,
+"pop($self, i=-1, /)\n"
+"--\n"
+"\n"
+"Return the i-th element and delete it from the array.\n"
+"\n"
+"i defaults to -1.");
+
+#define ARRAY_ARRAY_POP_METHODDEF    \
+    {"pop", (PyCFunction)array_array_pop, METH_VARARGS, array_array_pop__doc__},
+
+static PyObject *
+array_array_pop_impl(arrayobject *self, Py_ssize_t i);
+
+static PyObject *
+array_array_pop(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t i = -1;
+
+    if (!PyArg_ParseTuple(args,
+        "|n:pop",
+        &i))
+        goto exit;
+    return_value = array_array_pop_impl(self, i);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_extend__doc__,
+"extend($self, bb, /)\n"
+"--\n"
+"\n"
+"Append items to the end of the array.");
+
+#define ARRAY_ARRAY_EXTEND_METHODDEF    \
+    {"extend", (PyCFunction)array_array_extend, METH_O, array_array_extend__doc__},
+
+PyDoc_STRVAR(array_array_insert__doc__,
+"insert($self, i, v, /)\n"
+"--\n"
+"\n"
+"Insert a new item v into the array before position i.");
+
+#define ARRAY_ARRAY_INSERT_METHODDEF    \
+    {"insert", (PyCFunction)array_array_insert, METH_VARARGS, array_array_insert__doc__},
+
+static PyObject *
+array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
+
+static PyObject *
+array_array_insert(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t i;
+    PyObject *v;
+
+    if (!PyArg_ParseTuple(args,
+        "nO:insert",
+        &i, &v))
+        goto exit;
+    return_value = array_array_insert_impl(self, i, v);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_buffer_info__doc__,
+"buffer_info($self, /)\n"
+"--\n"
+"\n"
+"Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array\'s contents.\n"
+"\n"
+"The length should be multiplied by the itemsize attribute to calculate\n"
+"the buffer length in bytes.");
+
+#define ARRAY_ARRAY_BUFFER_INFO_METHODDEF    \
+    {"buffer_info", (PyCFunction)array_array_buffer_info, METH_NOARGS, array_array_buffer_info__doc__},
+
+static PyObject *
+array_array_buffer_info_impl(arrayobject *self);
+
+static PyObject *
+array_array_buffer_info(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_buffer_info_impl(self);
+}
+
+PyDoc_STRVAR(array_array_append__doc__,
+"append($self, v, /)\n"
+"--\n"
+"\n"
+"Append new value v to the end of the array.");
+
+#define ARRAY_ARRAY_APPEND_METHODDEF    \
+    {"append", (PyCFunction)array_array_append, METH_O, array_array_append__doc__},
+
+PyDoc_STRVAR(array_array_byteswap__doc__,
+"byteswap($self, /)\n"
+"--\n"
+"\n"
+"Byteswap all items of the array.\n"
+"\n"
+"If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is\n"
+"raised.");
+
+#define ARRAY_ARRAY_BYTESWAP_METHODDEF    \
+    {"byteswap", (PyCFunction)array_array_byteswap, METH_NOARGS, array_array_byteswap__doc__},
+
+static PyObject *
+array_array_byteswap_impl(arrayobject *self);
+
+static PyObject *
+array_array_byteswap(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_byteswap_impl(self);
+}
+
+PyDoc_STRVAR(array_array_reverse__doc__,
+"reverse($self, /)\n"
+"--\n"
+"\n"
+"Reverse the order of the items in the array.");
+
+#define ARRAY_ARRAY_REVERSE_METHODDEF    \
+    {"reverse", (PyCFunction)array_array_reverse, METH_NOARGS, array_array_reverse__doc__},
+
+static PyObject *
+array_array_reverse_impl(arrayobject *self);
+
+static PyObject *
+array_array_reverse(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_reverse_impl(self);
+}
+
+PyDoc_STRVAR(array_array_fromfile__doc__,
+"fromfile($self, f, n, /)\n"
+"--\n"
+"\n"
+"Read n objects from the file object f and append them to the end of the array.");
+
+#define ARRAY_ARRAY_FROMFILE_METHODDEF    \
+    {"fromfile", (PyCFunction)array_array_fromfile, METH_VARARGS, array_array_fromfile__doc__},
+
+static PyObject *
+array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n);
+
+static PyObject *
+array_array_fromfile(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *f;
+    Py_ssize_t n;
+
+    if (!PyArg_ParseTuple(args,
+        "On:fromfile",
+        &f, &n))
+        goto exit;
+    return_value = array_array_fromfile_impl(self, f, n);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_tofile__doc__,
+"tofile($self, f, /)\n"
+"--\n"
+"\n"
+"Write all items (as machine values) to the file object f.");
+
+#define ARRAY_ARRAY_TOFILE_METHODDEF    \
+    {"tofile", (PyCFunction)array_array_tofile, METH_O, array_array_tofile__doc__},
+
+PyDoc_STRVAR(array_array_fromlist__doc__,
+"fromlist($self, list, /)\n"
+"--\n"
+"\n"
+"Append items to array from list.");
+
+#define ARRAY_ARRAY_FROMLIST_METHODDEF    \
+    {"fromlist", (PyCFunction)array_array_fromlist, METH_O, array_array_fromlist__doc__},
+
+PyDoc_STRVAR(array_array_tolist__doc__,
+"tolist($self, /)\n"
+"--\n"
+"\n"
+"Convert array to an ordinary list with the same items.");
+
+#define ARRAY_ARRAY_TOLIST_METHODDEF    \
+    {"tolist", (PyCFunction)array_array_tolist, METH_NOARGS, array_array_tolist__doc__},
+
+static PyObject *
+array_array_tolist_impl(arrayobject *self);
+
+static PyObject *
+array_array_tolist(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_tolist_impl(self);
+}
+
+PyDoc_STRVAR(array_array_fromstring__doc__,
+"fromstring($self, buffer, /)\n"
+"--\n"
+"\n"
+"Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method).\n"
+"\n"
+"This method is deprecated. Use frombytes instead.");
+
+#define ARRAY_ARRAY_FROMSTRING_METHODDEF    \
+    {"fromstring", (PyCFunction)array_array_fromstring, METH_VARARGS, array_array_fromstring__doc__},
+
+static PyObject *
+array_array_fromstring_impl(arrayobject *self, Py_buffer *buffer);
+
+static PyObject *
+array_array_fromstring(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_buffer buffer = {NULL, NULL};
+
+    if (!PyArg_ParseTuple(args,
+        "s*:fromstring",
+        &buffer))
+        goto exit;
+    return_value = array_array_fromstring_impl(self, &buffer);
+
+exit:
+    /* Cleanup for buffer */
+    if (buffer.obj)
+       PyBuffer_Release(&buffer);
+
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_frombytes__doc__,
+"frombytes($self, buffer, /)\n"
+"--\n"
+"\n"
+"Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method).");
+
+#define ARRAY_ARRAY_FROMBYTES_METHODDEF    \
+    {"frombytes", (PyCFunction)array_array_frombytes, METH_VARARGS, array_array_frombytes__doc__},
+
+static PyObject *
+array_array_frombytes_impl(arrayobject *self, Py_buffer *buffer);
+
+static PyObject *
+array_array_frombytes(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_buffer buffer = {NULL, NULL};
+
+    if (!PyArg_ParseTuple(args,
+        "y*:frombytes",
+        &buffer))
+        goto exit;
+    return_value = array_array_frombytes_impl(self, &buffer);
+
+exit:
+    /* Cleanup for buffer */
+    if (buffer.obj)
+       PyBuffer_Release(&buffer);
+
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_tobytes__doc__,
+"tobytes($self, /)\n"
+"--\n"
+"\n"
+"Convert the array to an array of machine values and return the bytes representation.");
+
+#define ARRAY_ARRAY_TOBYTES_METHODDEF    \
+    {"tobytes", (PyCFunction)array_array_tobytes, METH_NOARGS, array_array_tobytes__doc__},
+
+static PyObject *
+array_array_tobytes_impl(arrayobject *self);
+
+static PyObject *
+array_array_tobytes(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_tobytes_impl(self);
+}
+
+PyDoc_STRVAR(array_array_tostring__doc__,
+"tostring($self, /)\n"
+"--\n"
+"\n"
+"Convert the array to an array of machine values and return the bytes representation.\n"
+"\n"
+"This method is deprecated. Use tobytes instead.");
+
+#define ARRAY_ARRAY_TOSTRING_METHODDEF    \
+    {"tostring", (PyCFunction)array_array_tostring, METH_NOARGS, array_array_tostring__doc__},
+
+static PyObject *
+array_array_tostring_impl(arrayobject *self);
+
+static PyObject *
+array_array_tostring(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_tostring_impl(self);
+}
+
+PyDoc_STRVAR(array_array_fromunicode__doc__,
+"fromunicode($self, ustr, /)\n"
+"--\n"
+"\n"
+"Extends this array with data from the unicode string ustr.\n"
+"\n"
+"The array must be a unicode type array; otherwise a ValueError is raised.\n"
+"Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of\n"
+"some other type.");
+
+#define ARRAY_ARRAY_FROMUNICODE_METHODDEF    \
+    {"fromunicode", (PyCFunction)array_array_fromunicode, METH_VARARGS, array_array_fromunicode__doc__},
+
+static PyObject *
+array_array_fromunicode_impl(arrayobject *self, Py_UNICODE *ustr, Py_ssize_clean_t ustr_length);
+
+static PyObject *
+array_array_fromunicode(arrayobject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_UNICODE *ustr;
+    Py_ssize_clean_t ustr_length;
+
+    if (!PyArg_ParseTuple(args,
+        "u#:fromunicode",
+        &ustr, &ustr_length))
+        goto exit;
+    return_value = array_array_fromunicode_impl(self, ustr, ustr_length);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array_tounicode__doc__,
+"tounicode($self, /)\n"
+"--\n"
+"\n"
+"Extends this array with data from the unicode string ustr.\n"
+"\n"
+"Convert the array to a unicode string.  The array must be a unicode type array;\n"
+"otherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a\n"
+"unicode string from an array of some other type.");
+
+#define ARRAY_ARRAY_TOUNICODE_METHODDEF    \
+    {"tounicode", (PyCFunction)array_array_tounicode, METH_NOARGS, array_array_tounicode__doc__},
+
+static PyObject *
+array_array_tounicode_impl(arrayobject *self);
+
+static PyObject *
+array_array_tounicode(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array_tounicode_impl(self);
+}
+
+PyDoc_STRVAR(array_array___sizeof____doc__,
+"__sizeof__($self, /)\n"
+"--\n"
+"\n"
+"Size of the array in memory, in bytes.");
+
+#define ARRAY_ARRAY___SIZEOF___METHODDEF    \
+    {"__sizeof__", (PyCFunction)array_array___sizeof__, METH_NOARGS, array_array___sizeof____doc__},
+
+static PyObject *
+array_array___sizeof___impl(arrayobject *self);
+
+static PyObject *
+array_array___sizeof__(arrayobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_array___sizeof___impl(self);
+}
+
+PyDoc_STRVAR(array__array_reconstructor__doc__,
+"_array_reconstructor($module, arraytype, typecode, mformat_code, items,\n"
+"                     /)\n"
+"--\n"
+"\n"
+"Internal. Used for pickling support.");
+
+#define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF    \
+    {"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_VARARGS, array__array_reconstructor__doc__},
+
+static PyObject *
+array__array_reconstructor_impl(PyModuleDef *module, PyTypeObject *arraytype, int typecode, enum machine_format_code mformat_code, PyObject *items);
+
+static PyObject *
+array__array_reconstructor(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyTypeObject *arraytype;
+    int typecode;
+    enum machine_format_code mformat_code;
+    PyObject *items;
+
+    if (!PyArg_ParseTuple(args,
+        "OCiO:_array_reconstructor",
+        &arraytype, &typecode, &mformat_code, &items))
+        goto exit;
+    return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(array_array___reduce_ex____doc__,
+"__reduce_ex__($self, value, /)\n"
+"--\n"
+"\n"
+"Return state information for pickling.");
+
+#define ARRAY_ARRAY___REDUCE_EX___METHODDEF    \
+    {"__reduce_ex__", (PyCFunction)array_array___reduce_ex__, METH_O, array_array___reduce_ex____doc__},
+
+PyDoc_STRVAR(array_arrayiterator___reduce____doc__,
+"__reduce__($self, /)\n"
+"--\n"
+"\n"
+"Return state information for pickling.");
+
+#define ARRAY_ARRAYITERATOR___REDUCE___METHODDEF    \
+    {"__reduce__", (PyCFunction)array_arrayiterator___reduce__, METH_NOARGS, array_arrayiterator___reduce____doc__},
+
+static PyObject *
+array_arrayiterator___reduce___impl(arrayiterobject *self);
+
+static PyObject *
+array_arrayiterator___reduce__(arrayiterobject *self, PyObject *Py_UNUSED(ignored))
+{
+    return array_arrayiterator___reduce___impl(self);
+}
+
+PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
+"__setstate__($self, state, /)\n"
+"--\n"
+"\n"
+"Set state information for unpickling.");
+
+#define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF    \
+    {"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
+/*[clinic end generated code: output=e1deb61c6a3bc8c8 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/binascii.c.h b/Modules/clinic/binascii.c.h
index f647032..b2b6e6b 100644
--- a/Modules/clinic/binascii.c.h
+++ b/Modules/clinic/binascii.c.h
@@ -320,7 +320,7 @@ binascii_crc32(PyModuleDef *module, PyObject *args)
         &data, &crc))
         goto exit;
     _return_value = binascii_crc32_impl(module, &data, crc);
-    if ((_return_value == -1) && PyErr_Occurred())
+    if ((_return_value == (unsigned int)-1) && PyErr_Occurred())
         goto exit;
     return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
 
@@ -543,4 +543,4 @@ exit:
 
     return return_value;
 }
-/*[clinic end generated code: output=e46d29f8c9adae7e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=771126f8f53e84e7 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/cmathmodule.c.h b/Modules/clinic/cmathmodule.c.h
new file mode 100644
index 0000000..d0c48d3
--- /dev/null
+++ b/Modules/clinic/cmathmodule.c.h
@@ -0,0 +1,851 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(cmath_acos__doc__,
+"acos($module, z, /)\n"
+"--\n"
+"\n"
+"Return the arc cosine of z.");
+
+#define CMATH_ACOS_METHODDEF    \
+    {"acos", (PyCFunction)cmath_acos, METH_VARARGS, cmath_acos__doc__},
+
+static Py_complex
+cmath_acos_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_acos(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:acos",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_acos_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_acosh__doc__,
+"acosh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the inverse hyperbolic cosine of z.");
+
+#define CMATH_ACOSH_METHODDEF    \
+    {"acosh", (PyCFunction)cmath_acosh, METH_VARARGS, cmath_acosh__doc__},
+
+static Py_complex
+cmath_acosh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_acosh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:acosh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_acosh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_asin__doc__,
+"asin($module, z, /)\n"
+"--\n"
+"\n"
+"Return the arc sine of z.");
+
+#define CMATH_ASIN_METHODDEF    \
+    {"asin", (PyCFunction)cmath_asin, METH_VARARGS, cmath_asin__doc__},
+
+static Py_complex
+cmath_asin_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_asin(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:asin",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_asin_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_asinh__doc__,
+"asinh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the inverse hyperbolic sine of z.");
+
+#define CMATH_ASINH_METHODDEF    \
+    {"asinh", (PyCFunction)cmath_asinh, METH_VARARGS, cmath_asinh__doc__},
+
+static Py_complex
+cmath_asinh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_asinh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:asinh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_asinh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_atan__doc__,
+"atan($module, z, /)\n"
+"--\n"
+"\n"
+"Return the arc tangent of z.");
+
+#define CMATH_ATAN_METHODDEF    \
+    {"atan", (PyCFunction)cmath_atan, METH_VARARGS, cmath_atan__doc__},
+
+static Py_complex
+cmath_atan_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_atan(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:atan",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_atan_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_atanh__doc__,
+"atanh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the inverse hyperbolic tangent of z.");
+
+#define CMATH_ATANH_METHODDEF    \
+    {"atanh", (PyCFunction)cmath_atanh, METH_VARARGS, cmath_atanh__doc__},
+
+static Py_complex
+cmath_atanh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_atanh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:atanh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_atanh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_cos__doc__,
+"cos($module, z, /)\n"
+"--\n"
+"\n"
+"Return the cosine of z.");
+
+#define CMATH_COS_METHODDEF    \
+    {"cos", (PyCFunction)cmath_cos, METH_VARARGS, cmath_cos__doc__},
+
+static Py_complex
+cmath_cos_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_cos(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:cos",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_cos_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_cosh__doc__,
+"cosh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the hyperbolic cosine of z.");
+
+#define CMATH_COSH_METHODDEF    \
+    {"cosh", (PyCFunction)cmath_cosh, METH_VARARGS, cmath_cosh__doc__},
+
+static Py_complex
+cmath_cosh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_cosh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:cosh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_cosh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_exp__doc__,
+"exp($module, z, /)\n"
+"--\n"
+"\n"
+"Return the exponential value e**z.");
+
+#define CMATH_EXP_METHODDEF    \
+    {"exp", (PyCFunction)cmath_exp, METH_VARARGS, cmath_exp__doc__},
+
+static Py_complex
+cmath_exp_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_exp(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:exp",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_exp_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_log10__doc__,
+"log10($module, z, /)\n"
+"--\n"
+"\n"
+"Return the base-10 logarithm of z.");
+
+#define CMATH_LOG10_METHODDEF    \
+    {"log10", (PyCFunction)cmath_log10, METH_VARARGS, cmath_log10__doc__},
+
+static Py_complex
+cmath_log10_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_log10(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:log10",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_log10_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_sin__doc__,
+"sin($module, z, /)\n"
+"--\n"
+"\n"
+"Return the sine of z.");
+
+#define CMATH_SIN_METHODDEF    \
+    {"sin", (PyCFunction)cmath_sin, METH_VARARGS, cmath_sin__doc__},
+
+static Py_complex
+cmath_sin_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_sin(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:sin",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_sin_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_sinh__doc__,
+"sinh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the hyperbolic sine of z.");
+
+#define CMATH_SINH_METHODDEF    \
+    {"sinh", (PyCFunction)cmath_sinh, METH_VARARGS, cmath_sinh__doc__},
+
+static Py_complex
+cmath_sinh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_sinh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:sinh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_sinh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_sqrt__doc__,
+"sqrt($module, z, /)\n"
+"--\n"
+"\n"
+"Return the square root of z.");
+
+#define CMATH_SQRT_METHODDEF    \
+    {"sqrt", (PyCFunction)cmath_sqrt, METH_VARARGS, cmath_sqrt__doc__},
+
+static Py_complex
+cmath_sqrt_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_sqrt(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:sqrt",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_sqrt_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_tan__doc__,
+"tan($module, z, /)\n"
+"--\n"
+"\n"
+"Return the tangent of z.");
+
+#define CMATH_TAN_METHODDEF    \
+    {"tan", (PyCFunction)cmath_tan, METH_VARARGS, cmath_tan__doc__},
+
+static Py_complex
+cmath_tan_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_tan(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:tan",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_tan_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_tanh__doc__,
+"tanh($module, z, /)\n"
+"--\n"
+"\n"
+"Return the hyperbolic tangent of z.");
+
+#define CMATH_TANH_METHODDEF    \
+    {"tanh", (PyCFunction)cmath_tanh, METH_VARARGS, cmath_tanh__doc__},
+
+static Py_complex
+cmath_tanh_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_tanh(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+    Py_complex _return_value;
+
+    if (!PyArg_ParseTuple(args,
+        "D:tanh",
+        &z))
+        goto exit;
+    /* modifications for z */
+    errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
+    _return_value = cmath_tanh_impl(module, z);
+    PyFPE_END_PROTECT(_return_value);
+    if (errno == EDOM) {
+        PyErr_SetString(PyExc_ValueError, "math domain error");
+        goto exit;
+    }
+    else if (errno == ERANGE) {
+        PyErr_SetString(PyExc_OverflowError, "math range error");
+        goto exit;
+    }
+    else {
+        return_value = PyComplex_FromCComplex(_return_value);
+    }
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_log__doc__,
+"log($module, x, y_obj=None, /)\n"
+"--\n"
+"\n"
+"The logarithm of z to the given base.\n"
+"\n"
+"If the base not specified, returns the natural logarithm (base e) of z.");
+
+#define CMATH_LOG_METHODDEF    \
+    {"log", (PyCFunction)cmath_log, METH_VARARGS, cmath_log__doc__},
+
+static PyObject *
+cmath_log_impl(PyModuleDef *module, Py_complex x, PyObject *y_obj);
+
+static PyObject *
+cmath_log(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex x;
+    PyObject *y_obj = NULL;
+
+    if (!PyArg_ParseTuple(args,
+        "D|O:log",
+        &x, &y_obj))
+        goto exit;
+    return_value = cmath_log_impl(module, x, y_obj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_phase__doc__,
+"phase($module, z, /)\n"
+"--\n"
+"\n"
+"Return argument, also known as the phase angle, of a complex.");
+
+#define CMATH_PHASE_METHODDEF    \
+    {"phase", (PyCFunction)cmath_phase, METH_VARARGS, cmath_phase__doc__},
+
+static PyObject *
+cmath_phase_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_phase(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+
+    if (!PyArg_ParseTuple(args,
+        "D:phase",
+        &z))
+        goto exit;
+    return_value = cmath_phase_impl(module, z);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_polar__doc__,
+"polar($module, z, /)\n"
+"--\n"
+"\n"
+"Convert a complex from rectangular coordinates to polar coordinates.\n"
+"\n"
+"r is the distance from 0 and phi the phase angle.");
+
+#define CMATH_POLAR_METHODDEF    \
+    {"polar", (PyCFunction)cmath_polar, METH_VARARGS, cmath_polar__doc__},
+
+static PyObject *
+cmath_polar_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_polar(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+
+    if (!PyArg_ParseTuple(args,
+        "D:polar",
+        &z))
+        goto exit;
+    return_value = cmath_polar_impl(module, z);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_rect__doc__,
+"rect($module, r, phi, /)\n"
+"--\n"
+"\n"
+"Convert from polar coordinates to rectangular coordinates.");
+
+#define CMATH_RECT_METHODDEF    \
+    {"rect", (PyCFunction)cmath_rect, METH_VARARGS, cmath_rect__doc__},
+
+static PyObject *
+cmath_rect_impl(PyModuleDef *module, double r, double phi);
+
+static PyObject *
+cmath_rect(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    double r;
+    double phi;
+
+    if (!PyArg_ParseTuple(args,
+        "dd:rect",
+        &r, &phi))
+        goto exit;
+    return_value = cmath_rect_impl(module, r, phi);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_isfinite__doc__,
+"isfinite($module, z, /)\n"
+"--\n"
+"\n"
+"Return True if both the real and imaginary parts of z are finite, else False.");
+
+#define CMATH_ISFINITE_METHODDEF    \
+    {"isfinite", (PyCFunction)cmath_isfinite, METH_VARARGS, cmath_isfinite__doc__},
+
+static PyObject *
+cmath_isfinite_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_isfinite(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+
+    if (!PyArg_ParseTuple(args,
+        "D:isfinite",
+        &z))
+        goto exit;
+    return_value = cmath_isfinite_impl(module, z);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_isnan__doc__,
+"isnan($module, z, /)\n"
+"--\n"
+"\n"
+"Checks if the real or imaginary part of z not a number (NaN).");
+
+#define CMATH_ISNAN_METHODDEF    \
+    {"isnan", (PyCFunction)cmath_isnan, METH_VARARGS, cmath_isnan__doc__},
+
+static PyObject *
+cmath_isnan_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_isnan(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+
+    if (!PyArg_ParseTuple(args,
+        "D:isnan",
+        &z))
+        goto exit;
+    return_value = cmath_isnan_impl(module, z);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(cmath_isinf__doc__,
+"isinf($module, z, /)\n"
+"--\n"
+"\n"
+"Checks if the real or imaginary part of z is infinite.");
+
+#define CMATH_ISINF_METHODDEF    \
+    {"isinf", (PyCFunction)cmath_isinf, METH_VARARGS, cmath_isinf__doc__},
+
+static PyObject *
+cmath_isinf_impl(PyModuleDef *module, Py_complex z);
+
+static PyObject *
+cmath_isinf(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_complex z;
+
+    if (!PyArg_ParseTuple(args,
+        "D:isinf",
+        &z))
+        goto exit;
+    return_value = cmath_isinf_impl(module, z);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=9b6d81711e4e3c4b input=a9049054013a1b77]*/
diff --git a/Modules/clinic/fcntlmodule.c.h b/Modules/clinic/fcntlmodule.c.h
new file mode 100644
index 0000000..377e55d
--- /dev/null
+++ b/Modules/clinic/fcntlmodule.c.h
@@ -0,0 +1,188 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(fcntl_fcntl__doc__,
+"fcntl($module, fd, code, arg=None, /)\n"
+"--\n"
+"\n"
+"Perform the operation `code` on file descriptor fd.\n"
+"\n"
+"The values used for `code` are operating system dependent, and are available\n"
+"as constants in the fcntl module, using the same names as used in\n"
+"the relevant C header files.  The argument arg is optional, and\n"
+"defaults to 0; it may be an int or a string.  If arg is given as a string,\n"
+"the return value of fcntl is a string of that length, containing the\n"
+"resulting value put in the arg buffer by the operating system.  The length\n"
+"of the arg string is not allowed to exceed 1024 bytes.  If the arg given\n"
+"is an integer or if none is specified, the result value is an integer\n"
+"corresponding to the return value of the fcntl call in the C code.");
+
+#define FCNTL_FCNTL_METHODDEF    \
+    {"fcntl", (PyCFunction)fcntl_fcntl, METH_VARARGS, fcntl_fcntl__doc__},
+
+static PyObject *
+fcntl_fcntl_impl(PyModuleDef *module, int fd, int code, PyObject *arg);
+
+static PyObject *
+fcntl_fcntl(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int fd;
+    int code;
+    PyObject *arg = NULL;
+
+    if (!PyArg_ParseTuple(args,
+        "O&i|O:fcntl",
+        conv_descriptor, &fd, &code, &arg))
+        goto exit;
+    return_value = fcntl_fcntl_impl(module, fd, code, arg);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(fcntl_ioctl__doc__,
+"ioctl($module, fd, op, arg=None, mutate_flag=True, /)\n"
+"--\n"
+"\n"
+"Perform the operation op on file descriptor fd.\n"
+"\n"
+"The values used for op are operating system dependent, and are available as\n"
+"constants in the fcntl or termios library modules, using the same names as\n"
+"used in the relevant C header files.\n"
+"\n"
+"The argument `arg` is optional, and defaults to 0; it may be an int or a\n"
+"buffer containing character data (most likely a string or an array).\n"
+"\n"
+"If the argument is a mutable buffer (such as an array) and if the\n"
+"mutate_flag argument (which is only allowed in this case) is true then the\n"
+"buffer is (in effect) passed to the operating system and changes made by\n"
+"the OS will be reflected in the contents of the buffer after the call has\n"
+"returned.  The return value is the integer returned by the ioctl system\n"
+"call.\n"
+"\n"
+"If the argument is a mutable buffer and the mutable_flag argument is not\n"
+"passed or is false, the behavior is as if a string had been passed.  This\n"
+"behavior will change in future releases of Python.\n"
+"\n"
+"If the argument is an immutable buffer (most likely a string) then a copy\n"
+"of the buffer is passed to the operating system and the return value is a\n"
+"string of the same length containing whatever the operating system put in\n"
+"the buffer.  The length of the arg buffer in this case is not allowed to\n"
+"exceed 1024 bytes.\n"
+"\n"
+"If the arg given is an integer or if none is specified, the result value is\n"
+"an integer corresponding to the return value of the ioctl call in the C\n"
+"code.");
+
+#define FCNTL_IOCTL_METHODDEF    \
+    {"ioctl", (PyCFunction)fcntl_ioctl, METH_VARARGS, fcntl_ioctl__doc__},
+
+static PyObject *
+fcntl_ioctl_impl(PyModuleDef *module, int fd, unsigned int code, PyObject *ob_arg, int mutate_arg);
+
+static PyObject *
+fcntl_ioctl(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int fd;
+    unsigned int code;
+    PyObject *ob_arg = NULL;
+    int mutate_arg = 1;
+
+    if (!PyArg_ParseTuple(args,
+        "O&I|Op:ioctl",
+        conv_descriptor, &fd, &code, &ob_arg, &mutate_arg))
+        goto exit;
+    return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(fcntl_flock__doc__,
+"flock($module, fd, code, /)\n"
+"--\n"
+"\n"
+"Perform the lock operation op on file descriptor fd.\n"
+"\n"
+"See the Unix manual page for flock(2) for details (On some systems, this\n"
+"function is emulated using fcntl()).");
+
+#define FCNTL_FLOCK_METHODDEF    \
+    {"flock", (PyCFunction)fcntl_flock, METH_VARARGS, fcntl_flock__doc__},
+
+static PyObject *
+fcntl_flock_impl(PyModuleDef *module, int fd, int code);
+
+static PyObject *
+fcntl_flock(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int fd;
+    int code;
+
+    if (!PyArg_ParseTuple(args,
+        "O&i:flock",
+        conv_descriptor, &fd, &code))
+        goto exit;
+    return_value = fcntl_flock_impl(module, fd, code);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(fcntl_lockf__doc__,
+"lockf($module, fd, code, lenobj=None, startobj=None, whence=0, /)\n"
+"--\n"
+"\n"
+"A wrapper around the fcntl() locking calls.\n"
+"\n"
+"fd is the file descriptor of the file to lock or unlock, and operation is one\n"
+"of the following values:\n"
+"\n"
+"    LOCK_UN - unlock\n"
+"    LOCK_SH - acquire a shared lock\n"
+"    LOCK_EX - acquire an exclusive lock\n"
+"\n"
+"When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\n"
+"LOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the\n"
+"lock cannot be acquired, an IOError will be raised and the exception will\n"
+"have an errno attribute set to EACCES or EAGAIN (depending on the operating\n"
+"system -- for portability, check for either value).\n"
+"\n"
+"length is the number of bytes to lock, with the default meaning to lock to\n"
+"EOF.  start is the byte offset, relative to whence, to that the lock\n"
+"starts.  whence is as with fileobj.seek(), specifically:\n"
+"\n"
+"    0 - relative to the start of the file (SEEK_SET)\n"
+"    1 - relative to the current buffer position (SEEK_CUR)\n"
+"    2 - relative to the end of the file (SEEK_END)");
+
+#define FCNTL_LOCKF_METHODDEF    \
+    {"lockf", (PyCFunction)fcntl_lockf, METH_VARARGS, fcntl_lockf__doc__},
+
+static PyObject *
+fcntl_lockf_impl(PyModuleDef *module, int fd, int code, PyObject *lenobj, PyObject *startobj, int whence);
+
+static PyObject *
+fcntl_lockf(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int fd;
+    int code;
+    PyObject *lenobj = NULL;
+    PyObject *startobj = NULL;
+    int whence = 0;
+
+    if (!PyArg_ParseTuple(args,
+        "O&i|OOi:lockf",
+        conv_descriptor, &fd, &code, &lenobj, &startobj, &whence))
+        goto exit;
+    return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=84bdde73a92f7c61 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/grpmodule.c.h b/Modules/clinic/grpmodule.c.h
new file mode 100644
index 0000000..6818309
--- /dev/null
+++ b/Modules/clinic/grpmodule.c.h
@@ -0,0 +1,87 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(grp_getgrgid__doc__,
+"getgrgid($module, /, id)\n"
+"--\n"
+"\n"
+"Return the group database entry for the given numeric group ID.\n"
+"\n"
+"If id is not valid, raise KeyError.");
+
+#define GRP_GETGRGID_METHODDEF    \
+    {"getgrgid", (PyCFunction)grp_getgrgid, METH_VARARGS|METH_KEYWORDS, grp_getgrgid__doc__},
+
+static PyObject *
+grp_getgrgid_impl(PyModuleDef *module, PyObject *id);
+
+static PyObject *
+grp_getgrgid(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"id", NULL};
+    PyObject *id;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O:getgrgid", _keywords,
+        &id))
+        goto exit;
+    return_value = grp_getgrgid_impl(module, id);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(grp_getgrnam__doc__,
+"getgrnam($module, /, name)\n"
+"--\n"
+"\n"
+"Return the group database entry for the given group name.\n"
+"\n"
+"If name is not valid, raise KeyError.");
+
+#define GRP_GETGRNAM_METHODDEF    \
+    {"getgrnam", (PyCFunction)grp_getgrnam, METH_VARARGS|METH_KEYWORDS, grp_getgrnam__doc__},
+
+static PyObject *
+grp_getgrnam_impl(PyModuleDef *module, PyObject *name);
+
+static PyObject *
+grp_getgrnam(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"name", NULL};
+    PyObject *name;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "U:getgrnam", _keywords,
+        &name))
+        goto exit;
+    return_value = grp_getgrnam_impl(module, name);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(grp_getgrall__doc__,
+"getgrall($module, /)\n"
+"--\n"
+"\n"
+"Return a list of all available group entries, in arbitrary order.\n"
+"\n"
+"An entry whose name starts with \'+\' or \'-\' represents an instruction\n"
+"to use YP/NIS and may not be accessible via getgrnam or getgrgid.");
+
+#define GRP_GETGRALL_METHODDEF    \
+    {"getgrall", (PyCFunction)grp_getgrall, METH_NOARGS, grp_getgrall__doc__},
+
+static PyObject *
+grp_getgrall_impl(PyModuleDef *module);
+
+static PyObject *
+grp_getgrall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    return grp_getgrall_impl(module);
+}
+/*[clinic end generated code: output=4709a6ba40bb8df9 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/pwdmodule.c.h b/Modules/clinic/pwdmodule.c.h
new file mode 100644
index 0000000..6a40042
--- /dev/null
+++ b/Modules/clinic/pwdmodule.c.h
@@ -0,0 +1,73 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(pwd_getpwuid__doc__,
+"getpwuid($module, uidobj, /)\n"
+"--\n"
+"\n"
+"Return the password database entry for the given numeric user ID.\n"
+"\n"
+"See `help(pwd)` for more on password database entries.");
+
+#define PWD_GETPWUID_METHODDEF    \
+    {"getpwuid", (PyCFunction)pwd_getpwuid, METH_O, pwd_getpwuid__doc__},
+
+PyDoc_STRVAR(pwd_getpwnam__doc__,
+"getpwnam($module, arg, /)\n"
+"--\n"
+"\n"
+"Return the password database entry for the given user name.\n"
+"\n"
+"See `help(pwd)` for more on password database entries.");
+
+#define PWD_GETPWNAM_METHODDEF    \
+    {"getpwnam", (PyCFunction)pwd_getpwnam, METH_VARARGS, pwd_getpwnam__doc__},
+
+static PyObject *
+pwd_getpwnam_impl(PyModuleDef *module, PyObject *arg);
+
+static PyObject *
+pwd_getpwnam(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *arg;
+
+    if (!PyArg_ParseTuple(args,
+        "U:getpwnam",
+        &arg))
+        goto exit;
+    return_value = pwd_getpwnam_impl(module, arg);
+
+exit:
+    return return_value;
+}
+
+#if defined(HAVE_GETPWENT)
+
+PyDoc_STRVAR(pwd_getpwall__doc__,
+"getpwall($module, /)\n"
+"--\n"
+"\n"
+"Return a list of all available password database entries, in arbitrary order.\n"
+"\n"
+"See help(pwd) for more on password database entries.");
+
+#define PWD_GETPWALL_METHODDEF    \
+    {"getpwall", (PyCFunction)pwd_getpwall, METH_NOARGS, pwd_getpwall__doc__},
+
+static PyObject *
+pwd_getpwall_impl(PyModuleDef *module);
+
+static PyObject *
+pwd_getpwall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    return pwd_getpwall_impl(module);
+}
+
+#endif /* defined(HAVE_GETPWENT) */
+
+#ifndef PWD_GETPWALL_METHODDEF
+    #define PWD_GETPWALL_METHODDEF
+#endif /* !defined(PWD_GETPWALL_METHODDEF) */
+/*[clinic end generated code: output=2e23f920020a750a input=a9049054013a1b77]*/
diff --git a/Modules/clinic/spwdmodule.c.h b/Modules/clinic/spwdmodule.c.h
new file mode 100644
index 0000000..b091fc9
--- /dev/null
+++ b/Modules/clinic/spwdmodule.c.h
@@ -0,0 +1,70 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(HAVE_GETSPNAM)
+
+PyDoc_STRVAR(spwd_getspnam__doc__,
+"getspnam($module, arg, /)\n"
+"--\n"
+"\n"
+"Return the shadow password database entry for the given user name.\n"
+"\n"
+"See `help(spwd)` for more on shadow password database entries.");
+
+#define SPWD_GETSPNAM_METHODDEF    \
+    {"getspnam", (PyCFunction)spwd_getspnam, METH_VARARGS, spwd_getspnam__doc__},
+
+static PyObject *
+spwd_getspnam_impl(PyModuleDef *module, PyObject *arg);
+
+static PyObject *
+spwd_getspnam(PyModuleDef *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *arg;
+
+    if (!PyArg_ParseTuple(args,
+        "U:getspnam",
+        &arg))
+        goto exit;
+    return_value = spwd_getspnam_impl(module, arg);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_GETSPNAM) */
+
+#ifndef SPWD_GETSPNAM_METHODDEF
+    #define SPWD_GETSPNAM_METHODDEF
+#endif /* !defined(SPWD_GETSPNAM_METHODDEF) */
+
+#if defined(HAVE_GETSPENT)
+
+PyDoc_STRVAR(spwd_getspall__doc__,
+"getspall($module, /)\n"
+"--\n"
+"\n"
+"Return a list of all available shadow password database entries, in arbitrary order.\n"
+"\n"
+"See `help(spwd)` for more on shadow password database entries.");
+
+#define SPWD_GETSPALL_METHODDEF    \
+    {"getspall", (PyCFunction)spwd_getspall, METH_NOARGS, spwd_getspall__doc__},
+
+static PyObject *
+spwd_getspall_impl(PyModuleDef *module);
+
+static PyObject *
+spwd_getspall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    return spwd_getspall_impl(module);
+}
+
+#endif /* defined(HAVE_GETSPENT) */
+
+#ifndef SPWD_GETSPALL_METHODDEF
+    #define SPWD_GETSPALL_METHODDEF
+#endif /* !defined(SPWD_GETSPALL_METHODDEF) */
+/*[clinic end generated code: output=41fec4a15b0cd2a0 input=a9049054013a1b77]*/