diff -r da4eeba6ba20 Modules/_codecsmodule.c --- a/Modules/_codecsmodule.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/_codecsmodule.c Fri Feb 20 16:26:18 2015 +0200 @@ -160,18 +160,18 @@ PyDoc_STRVAR(_codecs__forget_codec__doc_ "Purge the named codec from the internal codec lookup cache"); #define _CODECS__FORGET_CODEC_METHODDEF \ - {"_forget_codec", (PyCFunction)_codecs__forget_codec, METH_VARARGS, _codecs__forget_codec__doc__}, + {"_forget_codec", (PyCFunction)_codecs__forget_codec, METH_O, _codecs__forget_codec__doc__}, static PyObject * _codecs__forget_codec_impl(PyModuleDef *module, const char *encoding); static PyObject * -_codecs__forget_codec(PyModuleDef *module, PyObject *args) +_codecs__forget_codec(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; const char *encoding; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "s:_forget_codec", &encoding)) goto exit; @@ -183,7 +183,7 @@ exit: static PyObject * _codecs__forget_codec_impl(PyModuleDef *module, const char *encoding) -/*[clinic end generated code: output=a75e631591702a5c input=18d5d92d0e386c38]*/ +/*[clinic end generated code: output=a66f5e48d752e7fe input=18d5d92d0e386c38]*/ { if (_PyCodec_Forget(encoding) < 0) { return NULL; diff -r da4eeba6ba20 Modules/clinic/_bz2module.c.h --- a/Modules/clinic/_bz2module.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/_bz2module.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -14,18 +14,18 @@ PyDoc_STRVAR(_bz2_BZ2Compressor_compress "flush() method to finish the compression process."); #define _BZ2_BZ2COMPRESSOR_COMPRESS_METHODDEF \ - {"compress", (PyCFunction)_bz2_BZ2Compressor_compress, METH_VARARGS, _bz2_BZ2Compressor_compress__doc__}, + {"compress", (PyCFunction)_bz2_BZ2Compressor_compress, METH_O, _bz2_BZ2Compressor_compress__doc__}, static PyObject * _bz2_BZ2Compressor_compress_impl(BZ2Compressor *self, Py_buffer *data); static PyObject * -_bz2_BZ2Compressor_compress(BZ2Compressor *self, PyObject *args) +_bz2_BZ2Compressor_compress(BZ2Compressor *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:compress", &data)) goto exit; @@ -107,18 +107,18 @@ PyDoc_STRVAR(_bz2_BZ2Decompressor_decomp "is ignored and saved in the unused_data attribute."); #define _BZ2_BZ2DECOMPRESSOR_DECOMPRESS_METHODDEF \ - {"decompress", (PyCFunction)_bz2_BZ2Decompressor_decompress, METH_VARARGS, _bz2_BZ2Decompressor_decompress__doc__}, + {"decompress", (PyCFunction)_bz2_BZ2Decompressor_decompress, METH_O, _bz2_BZ2Decompressor_decompress__doc__}, static PyObject * _bz2_BZ2Decompressor_decompress_impl(BZ2Decompressor *self, Py_buffer *data); static PyObject * -_bz2_BZ2Decompressor_decompress(BZ2Decompressor *self, PyObject *args) +_bz2_BZ2Decompressor_decompress(BZ2Decompressor *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:decompress", &data)) goto exit; @@ -159,4 +159,4 @@ static int exit: return return_value; } -/*[clinic end generated code: output=21ca4405519a0931 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=b799cbb6527acf1d input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/_lzmamodule.c.h --- a/Modules/clinic/_lzmamodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/_lzmamodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -14,18 +14,18 @@ PyDoc_STRVAR(_lzma_LZMACompressor_compre "flush() method to finish the compression process."); #define _LZMA_LZMACOMPRESSOR_COMPRESS_METHODDEF \ - {"compress", (PyCFunction)_lzma_LZMACompressor_compress, METH_VARARGS, _lzma_LZMACompressor_compress__doc__}, + {"compress", (PyCFunction)_lzma_LZMACompressor_compress, METH_O, _lzma_LZMACompressor_compress__doc__}, static PyObject * _lzma_LZMACompressor_compress_impl(Compressor *self, Py_buffer *data); static PyObject * -_lzma_LZMACompressor_compress(Compressor *self, PyObject *args) +_lzma_LZMACompressor_compress(Compressor *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:compress", &data)) goto exit; @@ -162,18 +162,18 @@ PyDoc_STRVAR(_lzma_is_check_supported__d "Always returns True for CHECK_NONE and CHECK_CRC32."); #define _LZMA_IS_CHECK_SUPPORTED_METHODDEF \ - {"is_check_supported", (PyCFunction)_lzma_is_check_supported, METH_VARARGS, _lzma_is_check_supported__doc__}, + {"is_check_supported", (PyCFunction)_lzma_is_check_supported, METH_O, _lzma_is_check_supported__doc__}, static PyObject * _lzma_is_check_supported_impl(PyModuleDef *module, int check_id); static PyObject * -_lzma_is_check_supported(PyModuleDef *module, PyObject *args) +_lzma_is_check_supported(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int check_id; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:is_check_supported", &check_id)) goto exit; @@ -192,18 +192,18 @@ PyDoc_STRVAR(_lzma__encode_filter_proper "The result does not include the filter ID itself, only the options."); #define _LZMA__ENCODE_FILTER_PROPERTIES_METHODDEF \ - {"_encode_filter_properties", (PyCFunction)_lzma__encode_filter_properties, METH_VARARGS, _lzma__encode_filter_properties__doc__}, + {"_encode_filter_properties", (PyCFunction)_lzma__encode_filter_properties, METH_O, _lzma__encode_filter_properties__doc__}, static PyObject * _lzma__encode_filter_properties_impl(PyModuleDef *module, lzma_filter filter); static PyObject * -_lzma__encode_filter_properties(PyModuleDef *module, PyObject *args) +_lzma__encode_filter_properties(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; lzma_filter filter = {LZMA_VLI_UNKNOWN, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:_encode_filter_properties", lzma_filter_converter, &filter)) goto exit; @@ -251,4 +251,4 @@ exit: return return_value; } -/*[clinic end generated code: output=dc42b73890609369 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=ea7f2b2c4019fe86 input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/arraymodule.c.h --- a/Modules/clinic/arraymodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/arraymodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -267,18 +267,18 @@ PyDoc_STRVAR(array_array_fromstring__doc "This method is deprecated. Use frombytes instead."); #define ARRAY_ARRAY_FROMSTRING_METHODDEF \ - {"fromstring", (PyCFunction)array_array_fromstring, METH_VARARGS, array_array_fromstring__doc__}, + {"fromstring", (PyCFunction)array_array_fromstring, METH_O, array_array_fromstring__doc__}, static PyObject * array_array_fromstring_impl(arrayobject *self, Py_buffer *buffer); static PyObject * -array_array_fromstring(arrayobject *self, PyObject *args) +array_array_fromstring(arrayobject *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer buffer = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "s*:fromstring", &buffer)) goto exit; @@ -299,18 +299,18 @@ PyDoc_STRVAR(array_array_frombytes__doc_ "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__}, + {"frombytes", (PyCFunction)array_array_frombytes, METH_O, array_array_frombytes__doc__}, static PyObject * array_array_frombytes_impl(arrayobject *self, Py_buffer *buffer); static PyObject * -array_array_frombytes(arrayobject *self, PyObject *args) +array_array_frombytes(arrayobject *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer buffer = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:frombytes", &buffer)) goto exit; @@ -373,19 +373,19 @@ PyDoc_STRVAR(array_array_fromunicode__do "some other type."); #define ARRAY_ARRAY_FROMUNICODE_METHODDEF \ - {"fromunicode", (PyCFunction)array_array_fromunicode, METH_VARARGS, array_array_fromunicode__doc__}, + {"fromunicode", (PyCFunction)array_array_fromunicode, METH_O, 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) +array_array_fromunicode(arrayobject *self, PyObject *arg) { PyObject *return_value = NULL; Py_UNICODE *ustr; Py_ssize_clean_t ustr_length; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "u#:fromunicode", &ustr, &ustr_length)) goto exit; @@ -502,4 +502,4 @@ PyDoc_STRVAR(array_arrayiterator___setst #define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF \ {"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__}, -/*[clinic end generated code: output=e1deb61c6a3bc8c8 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=a8fbe83c2026fa83 input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/binascii.c.h --- a/Modules/clinic/binascii.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/binascii.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -9,18 +9,18 @@ PyDoc_STRVAR(binascii_a2b_uu__doc__, "Decode a line of uuencoded data."); #define BINASCII_A2B_UU_METHODDEF \ - {"a2b_uu", (PyCFunction)binascii_a2b_uu, METH_VARARGS, binascii_a2b_uu__doc__}, + {"a2b_uu", (PyCFunction)binascii_a2b_uu, METH_O, binascii_a2b_uu__doc__}, static PyObject * binascii_a2b_uu_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_a2b_uu(PyModuleDef *module, PyObject *args) +binascii_a2b_uu(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:a2b_uu", ascii_buffer_converter, &data)) goto exit; @@ -41,18 +41,18 @@ PyDoc_STRVAR(binascii_b2a_uu__doc__, "Uuencode line of data."); #define BINASCII_B2A_UU_METHODDEF \ - {"b2a_uu", (PyCFunction)binascii_b2a_uu, METH_VARARGS, binascii_b2a_uu__doc__}, + {"b2a_uu", (PyCFunction)binascii_b2a_uu, METH_O, binascii_b2a_uu__doc__}, static PyObject * binascii_b2a_uu_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_b2a_uu(PyModuleDef *module, PyObject *args) +binascii_b2a_uu(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:b2a_uu", &data)) goto exit; @@ -73,18 +73,18 @@ PyDoc_STRVAR(binascii_a2b_base64__doc__, "Decode a line of base64 data."); #define BINASCII_A2B_BASE64_METHODDEF \ - {"a2b_base64", (PyCFunction)binascii_a2b_base64, METH_VARARGS, binascii_a2b_base64__doc__}, + {"a2b_base64", (PyCFunction)binascii_a2b_base64, METH_O, binascii_a2b_base64__doc__}, static PyObject * binascii_a2b_base64_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_a2b_base64(PyModuleDef *module, PyObject *args) +binascii_a2b_base64(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:a2b_base64", ascii_buffer_converter, &data)) goto exit; @@ -105,18 +105,18 @@ PyDoc_STRVAR(binascii_b2a_base64__doc__, "Base64-code line of data."); #define BINASCII_B2A_BASE64_METHODDEF \ - {"b2a_base64", (PyCFunction)binascii_b2a_base64, METH_VARARGS, binascii_b2a_base64__doc__}, + {"b2a_base64", (PyCFunction)binascii_b2a_base64, METH_O, binascii_b2a_base64__doc__}, static PyObject * binascii_b2a_base64_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_b2a_base64(PyModuleDef *module, PyObject *args) +binascii_b2a_base64(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:b2a_base64", &data)) goto exit; @@ -137,18 +137,18 @@ PyDoc_STRVAR(binascii_a2b_hqx__doc__, "Decode .hqx coding."); #define BINASCII_A2B_HQX_METHODDEF \ - {"a2b_hqx", (PyCFunction)binascii_a2b_hqx, METH_VARARGS, binascii_a2b_hqx__doc__}, + {"a2b_hqx", (PyCFunction)binascii_a2b_hqx, METH_O, binascii_a2b_hqx__doc__}, static PyObject * binascii_a2b_hqx_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_a2b_hqx(PyModuleDef *module, PyObject *args) +binascii_a2b_hqx(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:a2b_hqx", ascii_buffer_converter, &data)) goto exit; @@ -169,18 +169,18 @@ PyDoc_STRVAR(binascii_rlecode_hqx__doc__ "Binhex RLE-code binary data."); #define BINASCII_RLECODE_HQX_METHODDEF \ - {"rlecode_hqx", (PyCFunction)binascii_rlecode_hqx, METH_VARARGS, binascii_rlecode_hqx__doc__}, + {"rlecode_hqx", (PyCFunction)binascii_rlecode_hqx, METH_O, binascii_rlecode_hqx__doc__}, static PyObject * binascii_rlecode_hqx_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_rlecode_hqx(PyModuleDef *module, PyObject *args) +binascii_rlecode_hqx(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:rlecode_hqx", &data)) goto exit; @@ -201,18 +201,18 @@ PyDoc_STRVAR(binascii_b2a_hqx__doc__, "Encode .hqx data."); #define BINASCII_B2A_HQX_METHODDEF \ - {"b2a_hqx", (PyCFunction)binascii_b2a_hqx, METH_VARARGS, binascii_b2a_hqx__doc__}, + {"b2a_hqx", (PyCFunction)binascii_b2a_hqx, METH_O, binascii_b2a_hqx__doc__}, static PyObject * binascii_b2a_hqx_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_b2a_hqx(PyModuleDef *module, PyObject *args) +binascii_b2a_hqx(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:b2a_hqx", &data)) goto exit; @@ -233,18 +233,18 @@ PyDoc_STRVAR(binascii_rledecode_hqx__doc "Decode hexbin RLE-coded string."); #define BINASCII_RLEDECODE_HQX_METHODDEF \ - {"rledecode_hqx", (PyCFunction)binascii_rledecode_hqx, METH_VARARGS, binascii_rledecode_hqx__doc__}, + {"rledecode_hqx", (PyCFunction)binascii_rledecode_hqx, METH_O, binascii_rledecode_hqx__doc__}, static PyObject * binascii_rledecode_hqx_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_rledecode_hqx(PyModuleDef *module, PyObject *args) +binascii_rledecode_hqx(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:rledecode_hqx", &data)) goto exit; @@ -342,18 +342,18 @@ PyDoc_STRVAR(binascii_b2a_hex__doc__, "available as \"hexlify()\"."); #define BINASCII_B2A_HEX_METHODDEF \ - {"b2a_hex", (PyCFunction)binascii_b2a_hex, METH_VARARGS, binascii_b2a_hex__doc__}, + {"b2a_hex", (PyCFunction)binascii_b2a_hex, METH_O, binascii_b2a_hex__doc__}, static PyObject * binascii_b2a_hex_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_b2a_hex(PyModuleDef *module, PyObject *args) +binascii_b2a_hex(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:b2a_hex", &data)) goto exit; @@ -376,18 +376,18 @@ PyDoc_STRVAR(binascii_hexlify__doc__, "The return value is a bytes object."); #define BINASCII_HEXLIFY_METHODDEF \ - {"hexlify", (PyCFunction)binascii_hexlify, METH_VARARGS, binascii_hexlify__doc__}, + {"hexlify", (PyCFunction)binascii_hexlify, METH_O, binascii_hexlify__doc__}, static PyObject * binascii_hexlify_impl(PyModuleDef *module, Py_buffer *data); static PyObject * -binascii_hexlify(PyModuleDef *module, PyObject *args) +binascii_hexlify(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:hexlify", &data)) goto exit; @@ -411,18 +411,18 @@ PyDoc_STRVAR(binascii_a2b_hex__doc__, "This function is also available as \"unhexlify()\"."); #define BINASCII_A2B_HEX_METHODDEF \ - {"a2b_hex", (PyCFunction)binascii_a2b_hex, METH_VARARGS, binascii_a2b_hex__doc__}, + {"a2b_hex", (PyCFunction)binascii_a2b_hex, METH_O, binascii_a2b_hex__doc__}, static PyObject * binascii_a2b_hex_impl(PyModuleDef *module, Py_buffer *hexstr); static PyObject * -binascii_a2b_hex(PyModuleDef *module, PyObject *args) +binascii_a2b_hex(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer hexstr = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:a2b_hex", ascii_buffer_converter, &hexstr)) goto exit; @@ -445,18 +445,18 @@ PyDoc_STRVAR(binascii_unhexlify__doc__, "hexstr must contain an even number of hex digits (upper or lower case)."); #define BINASCII_UNHEXLIFY_METHODDEF \ - {"unhexlify", (PyCFunction)binascii_unhexlify, METH_VARARGS, binascii_unhexlify__doc__}, + {"unhexlify", (PyCFunction)binascii_unhexlify, METH_O, binascii_unhexlify__doc__}, static PyObject * binascii_unhexlify_impl(PyModuleDef *module, Py_buffer *hexstr); static PyObject * -binascii_unhexlify(PyModuleDef *module, PyObject *args) +binascii_unhexlify(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_buffer hexstr = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:unhexlify", ascii_buffer_converter, &hexstr)) goto exit; @@ -543,4 +543,4 @@ exit: return return_value; } -/*[clinic end generated code: output=771126f8f53e84e7 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=31ccbd5fddc8fd75 input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/cmathmodule.c.h --- a/Modules/clinic/cmathmodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/cmathmodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -9,19 +9,19 @@ PyDoc_STRVAR(cmath_acos__doc__, "Return the arc cosine of z."); #define CMATH_ACOS_METHODDEF \ - {"acos", (PyCFunction)cmath_acos, METH_VARARGS, cmath_acos__doc__}, + {"acos", (PyCFunction)cmath_acos, METH_O, cmath_acos__doc__}, static Py_complex cmath_acos_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_acos(PyModuleDef *module, PyObject *args) +cmath_acos(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:acos", &z)) goto exit; @@ -52,19 +52,19 @@ PyDoc_STRVAR(cmath_acosh__doc__, "Return the inverse hyperbolic cosine of z."); #define CMATH_ACOSH_METHODDEF \ - {"acosh", (PyCFunction)cmath_acosh, METH_VARARGS, cmath_acosh__doc__}, + {"acosh", (PyCFunction)cmath_acosh, METH_O, cmath_acosh__doc__}, static Py_complex cmath_acosh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_acosh(PyModuleDef *module, PyObject *args) +cmath_acosh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:acosh", &z)) goto exit; @@ -95,19 +95,19 @@ PyDoc_STRVAR(cmath_asin__doc__, "Return the arc sine of z."); #define CMATH_ASIN_METHODDEF \ - {"asin", (PyCFunction)cmath_asin, METH_VARARGS, cmath_asin__doc__}, + {"asin", (PyCFunction)cmath_asin, METH_O, cmath_asin__doc__}, static Py_complex cmath_asin_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_asin(PyModuleDef *module, PyObject *args) +cmath_asin(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:asin", &z)) goto exit; @@ -138,19 +138,19 @@ PyDoc_STRVAR(cmath_asinh__doc__, "Return the inverse hyperbolic sine of z."); #define CMATH_ASINH_METHODDEF \ - {"asinh", (PyCFunction)cmath_asinh, METH_VARARGS, cmath_asinh__doc__}, + {"asinh", (PyCFunction)cmath_asinh, METH_O, cmath_asinh__doc__}, static Py_complex cmath_asinh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_asinh(PyModuleDef *module, PyObject *args) +cmath_asinh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:asinh", &z)) goto exit; @@ -181,19 +181,19 @@ PyDoc_STRVAR(cmath_atan__doc__, "Return the arc tangent of z."); #define CMATH_ATAN_METHODDEF \ - {"atan", (PyCFunction)cmath_atan, METH_VARARGS, cmath_atan__doc__}, + {"atan", (PyCFunction)cmath_atan, METH_O, cmath_atan__doc__}, static Py_complex cmath_atan_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_atan(PyModuleDef *module, PyObject *args) +cmath_atan(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:atan", &z)) goto exit; @@ -224,19 +224,19 @@ PyDoc_STRVAR(cmath_atanh__doc__, "Return the inverse hyperbolic tangent of z."); #define CMATH_ATANH_METHODDEF \ - {"atanh", (PyCFunction)cmath_atanh, METH_VARARGS, cmath_atanh__doc__}, + {"atanh", (PyCFunction)cmath_atanh, METH_O, cmath_atanh__doc__}, static Py_complex cmath_atanh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_atanh(PyModuleDef *module, PyObject *args) +cmath_atanh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:atanh", &z)) goto exit; @@ -267,19 +267,19 @@ PyDoc_STRVAR(cmath_cos__doc__, "Return the cosine of z."); #define CMATH_COS_METHODDEF \ - {"cos", (PyCFunction)cmath_cos, METH_VARARGS, cmath_cos__doc__}, + {"cos", (PyCFunction)cmath_cos, METH_O, cmath_cos__doc__}, static Py_complex cmath_cos_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_cos(PyModuleDef *module, PyObject *args) +cmath_cos(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:cos", &z)) goto exit; @@ -310,19 +310,19 @@ PyDoc_STRVAR(cmath_cosh__doc__, "Return the hyperbolic cosine of z."); #define CMATH_COSH_METHODDEF \ - {"cosh", (PyCFunction)cmath_cosh, METH_VARARGS, cmath_cosh__doc__}, + {"cosh", (PyCFunction)cmath_cosh, METH_O, cmath_cosh__doc__}, static Py_complex cmath_cosh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_cosh(PyModuleDef *module, PyObject *args) +cmath_cosh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:cosh", &z)) goto exit; @@ -353,19 +353,19 @@ PyDoc_STRVAR(cmath_exp__doc__, "Return the exponential value e**z."); #define CMATH_EXP_METHODDEF \ - {"exp", (PyCFunction)cmath_exp, METH_VARARGS, cmath_exp__doc__}, + {"exp", (PyCFunction)cmath_exp, METH_O, cmath_exp__doc__}, static Py_complex cmath_exp_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_exp(PyModuleDef *module, PyObject *args) +cmath_exp(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:exp", &z)) goto exit; @@ -396,19 +396,19 @@ PyDoc_STRVAR(cmath_log10__doc__, "Return the base-10 logarithm of z."); #define CMATH_LOG10_METHODDEF \ - {"log10", (PyCFunction)cmath_log10, METH_VARARGS, cmath_log10__doc__}, + {"log10", (PyCFunction)cmath_log10, METH_O, cmath_log10__doc__}, static Py_complex cmath_log10_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_log10(PyModuleDef *module, PyObject *args) +cmath_log10(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:log10", &z)) goto exit; @@ -439,19 +439,19 @@ PyDoc_STRVAR(cmath_sin__doc__, "Return the sine of z."); #define CMATH_SIN_METHODDEF \ - {"sin", (PyCFunction)cmath_sin, METH_VARARGS, cmath_sin__doc__}, + {"sin", (PyCFunction)cmath_sin, METH_O, cmath_sin__doc__}, static Py_complex cmath_sin_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_sin(PyModuleDef *module, PyObject *args) +cmath_sin(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:sin", &z)) goto exit; @@ -482,19 +482,19 @@ PyDoc_STRVAR(cmath_sinh__doc__, "Return the hyperbolic sine of z."); #define CMATH_SINH_METHODDEF \ - {"sinh", (PyCFunction)cmath_sinh, METH_VARARGS, cmath_sinh__doc__}, + {"sinh", (PyCFunction)cmath_sinh, METH_O, cmath_sinh__doc__}, static Py_complex cmath_sinh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_sinh(PyModuleDef *module, PyObject *args) +cmath_sinh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:sinh", &z)) goto exit; @@ -525,19 +525,19 @@ PyDoc_STRVAR(cmath_sqrt__doc__, "Return the square root of z."); #define CMATH_SQRT_METHODDEF \ - {"sqrt", (PyCFunction)cmath_sqrt, METH_VARARGS, cmath_sqrt__doc__}, + {"sqrt", (PyCFunction)cmath_sqrt, METH_O, cmath_sqrt__doc__}, static Py_complex cmath_sqrt_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_sqrt(PyModuleDef *module, PyObject *args) +cmath_sqrt(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:sqrt", &z)) goto exit; @@ -568,19 +568,19 @@ PyDoc_STRVAR(cmath_tan__doc__, "Return the tangent of z."); #define CMATH_TAN_METHODDEF \ - {"tan", (PyCFunction)cmath_tan, METH_VARARGS, cmath_tan__doc__}, + {"tan", (PyCFunction)cmath_tan, METH_O, cmath_tan__doc__}, static Py_complex cmath_tan_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_tan(PyModuleDef *module, PyObject *args) +cmath_tan(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:tan", &z)) goto exit; @@ -611,19 +611,19 @@ PyDoc_STRVAR(cmath_tanh__doc__, "Return the hyperbolic tangent of z."); #define CMATH_TANH_METHODDEF \ - {"tanh", (PyCFunction)cmath_tanh, METH_VARARGS, cmath_tanh__doc__}, + {"tanh", (PyCFunction)cmath_tanh, METH_O, cmath_tanh__doc__}, static Py_complex cmath_tanh_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_tanh(PyModuleDef *module, PyObject *args) +cmath_tanh(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; Py_complex _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:tanh", &z)) goto exit; @@ -685,18 +685,18 @@ PyDoc_STRVAR(cmath_phase__doc__, "Return argument, also known as the phase angle, of a complex."); #define CMATH_PHASE_METHODDEF \ - {"phase", (PyCFunction)cmath_phase, METH_VARARGS, cmath_phase__doc__}, + {"phase", (PyCFunction)cmath_phase, METH_O, cmath_phase__doc__}, static PyObject * cmath_phase_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_phase(PyModuleDef *module, PyObject *args) +cmath_phase(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:phase", &z)) goto exit; @@ -715,18 +715,18 @@ PyDoc_STRVAR(cmath_polar__doc__, "r is the distance from 0 and phi the phase angle."); #define CMATH_POLAR_METHODDEF \ - {"polar", (PyCFunction)cmath_polar, METH_VARARGS, cmath_polar__doc__}, + {"polar", (PyCFunction)cmath_polar, METH_O, cmath_polar__doc__}, static PyObject * cmath_polar_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_polar(PyModuleDef *module, PyObject *args) +cmath_polar(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:polar", &z)) goto exit; @@ -772,18 +772,18 @@ PyDoc_STRVAR(cmath_isfinite__doc__, "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__}, + {"isfinite", (PyCFunction)cmath_isfinite, METH_O, cmath_isfinite__doc__}, static PyObject * cmath_isfinite_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_isfinite(PyModuleDef *module, PyObject *args) +cmath_isfinite(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:isfinite", &z)) goto exit; @@ -800,18 +800,18 @@ PyDoc_STRVAR(cmath_isnan__doc__, "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__}, + {"isnan", (PyCFunction)cmath_isnan, METH_O, cmath_isnan__doc__}, static PyObject * cmath_isnan_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_isnan(PyModuleDef *module, PyObject *args) +cmath_isnan(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:isnan", &z)) goto exit; @@ -828,18 +828,18 @@ PyDoc_STRVAR(cmath_isinf__doc__, "Checks if the real or imaginary part of z is infinite."); #define CMATH_ISINF_METHODDEF \ - {"isinf", (PyCFunction)cmath_isinf, METH_VARARGS, cmath_isinf__doc__}, + {"isinf", (PyCFunction)cmath_isinf, METH_O, cmath_isinf__doc__}, static PyObject * cmath_isinf_impl(PyModuleDef *module, Py_complex z); static PyObject * -cmath_isinf(PyModuleDef *module, PyObject *args) +cmath_isinf(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_complex z; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "D:isinf", &z)) goto exit; @@ -848,4 +848,4 @@ cmath_isinf(PyModuleDef *module, PyObjec exit: return return_value; } -/*[clinic end generated code: output=9b6d81711e4e3c4b input=a9049054013a1b77]*/ +/*[clinic end generated code: output=9143b8dcc8069024 input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/pwdmodule.c.h --- a/Modules/clinic/pwdmodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/pwdmodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -22,18 +22,18 @@ PyDoc_STRVAR(pwd_getpwnam__doc__, "See `help(pwd)` for more on password database entries."); #define PWD_GETPWNAM_METHODDEF \ - {"getpwnam", (PyCFunction)pwd_getpwnam, METH_VARARGS, pwd_getpwnam__doc__}, + {"getpwnam", (PyCFunction)pwd_getpwnam, METH_O, pwd_getpwnam__doc__}, static PyObject * pwd_getpwnam_impl(PyModuleDef *module, PyObject *arg); static PyObject * -pwd_getpwnam(PyModuleDef *module, PyObject *args) +pwd_getpwnam(PyModuleDef *module, PyObject *arg_) { PyObject *return_value = NULL; PyObject *arg; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg_, "U:getpwnam", &arg)) goto exit; @@ -70,4 +70,4 @@ pwd_getpwall(PyModuleDef *module, PyObje #ifndef PWD_GETPWALL_METHODDEF #define PWD_GETPWALL_METHODDEF #endif /* !defined(PWD_GETPWALL_METHODDEF) */ -/*[clinic end generated code: output=2e23f920020a750a input=a9049054013a1b77]*/ +/*[clinic end generated code: output=e7d5ac24b20e91ae input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/spwdmodule.c.h --- a/Modules/clinic/spwdmodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/spwdmodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -13,18 +13,18 @@ PyDoc_STRVAR(spwd_getspnam__doc__, "See `help(spwd)` for more on shadow password database entries."); #define SPWD_GETSPNAM_METHODDEF \ - {"getspnam", (PyCFunction)spwd_getspnam, METH_VARARGS, spwd_getspnam__doc__}, + {"getspnam", (PyCFunction)spwd_getspnam, METH_O, spwd_getspnam__doc__}, static PyObject * spwd_getspnam_impl(PyModuleDef *module, PyObject *arg); static PyObject * -spwd_getspnam(PyModuleDef *module, PyObject *args) +spwd_getspnam(PyModuleDef *module, PyObject *arg_) { PyObject *return_value = NULL; PyObject *arg; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg_, "U:getspnam", &arg)) goto exit; @@ -67,4 +67,4 @@ spwd_getspall(PyModuleDef *module, PyObj #ifndef SPWD_GETSPALL_METHODDEF #define SPWD_GETSPALL_METHODDEF #endif /* !defined(SPWD_GETSPALL_METHODDEF) */ -/*[clinic end generated code: output=41fec4a15b0cd2a0 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=8b7209b67f9ff3c4 input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/clinic/zlibmodule.c.h --- a/Modules/clinic/zlibmodule.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/clinic/zlibmodule.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -189,18 +189,18 @@ PyDoc_STRVAR(zlib_Compress_compress__doc "Call the flush() method to clear these buffers."); #define ZLIB_COMPRESS_COMPRESS_METHODDEF \ - {"compress", (PyCFunction)zlib_Compress_compress, METH_VARARGS, zlib_Compress_compress__doc__}, + {"compress", (PyCFunction)zlib_Compress_compress, METH_O, zlib_Compress_compress__doc__}, static PyObject * zlib_Compress_compress_impl(compobject *self, Py_buffer *data); static PyObject * -zlib_Compress_compress(compobject *self, PyObject *args) +zlib_Compress_compress(compobject *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer data = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:compress", &data)) goto exit; @@ -450,4 +450,4 @@ exit: return return_value; } -/*[clinic end generated code: output=bc9473721ca7c962 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=9ee0bc1b6d2b861c input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Modules/posixmodule.c --- a/Modules/posixmodule.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/posixmodule.c Fri Feb 20 16:26:18 2015 +0200 @@ -3030,19 +3030,19 @@ PyDoc_STRVAR(os_ttyname__doc__, " Integer file descriptor handle."); #define OS_TTYNAME_METHODDEF \ - {"ttyname", (PyCFunction)os_ttyname, METH_VARARGS, os_ttyname__doc__}, + {"ttyname", (PyCFunction)os_ttyname, METH_O, os_ttyname__doc__}, static char * os_ttyname_impl(PyModuleDef *module, int fd); static PyObject * -os_ttyname(PyModuleDef *module, PyObject *args) +os_ttyname(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; char *_return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:ttyname", &fd)) goto exit; @@ -3057,7 +3057,7 @@ exit: static char * os_ttyname_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=cee7bc4cffec01a2 input=5f72ca83e76b3b45]*/ +/*[clinic end generated code: output=ba2afcda1e7d382e input=5f72ca83e76b3b45]*/ { char *ret; @@ -4860,18 +4860,18 @@ PyDoc_STRVAR(os__getfinalpathname__doc__ "A helper function for samepath on windows."); #define OS__GETFINALPATHNAME_METHODDEF \ - {"_getfinalpathname", (PyCFunction)os__getfinalpathname, METH_VARARGS, os__getfinalpathname__doc__}, + {"_getfinalpathname", (PyCFunction)os__getfinalpathname, METH_O, os__getfinalpathname__doc__}, static PyObject * os__getfinalpathname_impl(PyModuleDef *module, PyObject *path); static PyObject * -os__getfinalpathname(PyModuleDef *module, PyObject *args) +os__getfinalpathname(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *path; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:_getfinalpathname", &path)) goto exit; @@ -4883,7 +4883,7 @@ exit: static PyObject * os__getfinalpathname_impl(PyModuleDef *module, PyObject *path) -/*[clinic end generated code: output=4563c6eacf1b0881 input=71d5e89334891bf4]*/ +/*[clinic end generated code: output=fd9893eb2869d5c4 input=71d5e89334891bf4]*/ { HANDLE hFile; int buf_size; @@ -5187,18 +5187,18 @@ PyDoc_STRVAR(os_nice__doc__, "Add increment to the priority of process and return the new priority."); #define OS_NICE_METHODDEF \ - {"nice", (PyCFunction)os_nice, METH_VARARGS, os_nice__doc__}, + {"nice", (PyCFunction)os_nice, METH_O, os_nice__doc__}, static PyObject * os_nice_impl(PyModuleDef *module, int increment); static PyObject * -os_nice(PyModuleDef *module, PyObject *args) +os_nice(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int increment; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:nice", &increment)) goto exit; @@ -5210,7 +5210,7 @@ exit: static PyObject * os_nice_impl(PyModuleDef *module, int increment) -/*[clinic end generated code: output=c360dc2a3bd8e3d0 input=864be2d402a21da2]*/ +/*[clinic end generated code: output=c024db183cbebc8f input=864be2d402a21da2]*/ { int value; @@ -5749,18 +5749,18 @@ PyDoc_STRVAR(os_umask__doc__, "Set the current numeric umask and return the previous umask."); #define OS_UMASK_METHODDEF \ - {"umask", (PyCFunction)os_umask, METH_VARARGS, os_umask__doc__}, + {"umask", (PyCFunction)os_umask, METH_O, os_umask__doc__}, static PyObject * os_umask_impl(PyModuleDef *module, int mask); static PyObject * -os_umask(PyModuleDef *module, PyObject *args) +os_umask(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int mask; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:umask", &mask)) goto exit; @@ -5772,7 +5772,7 @@ exit: static PyObject * os_umask_impl(PyModuleDef *module, int mask) -/*[clinic end generated code: output=90048b39d2d4a961 input=ab6bfd9b24d8a7e8]*/ +/*[clinic end generated code: output=1b9f4519b77024f0 input=ab6bfd9b24d8a7e8]*/ { int i = (int)umask(mask); if (i < 0) @@ -7361,18 +7361,18 @@ PyDoc_STRVAR(os_sched_getscheduler__doc_ "Passing 0 for pid returns the scheduling policy for the calling process."); #define OS_SCHED_GETSCHEDULER_METHODDEF \ - {"sched_getscheduler", (PyCFunction)os_sched_getscheduler, METH_VARARGS, os_sched_getscheduler__doc__}, + {"sched_getscheduler", (PyCFunction)os_sched_getscheduler, METH_O, os_sched_getscheduler__doc__}, static PyObject * os_sched_getscheduler_impl(PyModuleDef *module, pid_t pid); static PyObject * -os_sched_getscheduler(PyModuleDef *module, PyObject *args) +os_sched_getscheduler(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; pid_t pid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_PID ":sched_getscheduler", &pid)) goto exit; @@ -7384,7 +7384,7 @@ exit: static PyObject * os_sched_getscheduler_impl(PyModuleDef *module, pid_t pid) -/*[clinic end generated code: output=e0d6244207b1d828 input=5f14cfd1f189e1a0]*/ +/*[clinic end generated code: output=7d1ba9d1e24c99a9 input=5f14cfd1f189e1a0]*/ { int policy; @@ -7573,18 +7573,18 @@ PyDoc_STRVAR(os_sched_getparam__doc__, "Return value is an instance of sched_param."); #define OS_SCHED_GETPARAM_METHODDEF \ - {"sched_getparam", (PyCFunction)os_sched_getparam, METH_VARARGS, os_sched_getparam__doc__}, + {"sched_getparam", (PyCFunction)os_sched_getparam, METH_O, os_sched_getparam__doc__}, static PyObject * os_sched_getparam_impl(PyModuleDef *module, pid_t pid); static PyObject * -os_sched_getparam(PyModuleDef *module, PyObject *args) +os_sched_getparam(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; pid_t pid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_PID ":sched_getparam", &pid)) goto exit; @@ -7596,7 +7596,7 @@ exit: static PyObject * os_sched_getparam_impl(PyModuleDef *module, pid_t pid) -/*[clinic end generated code: output=b33acc8db004a8c9 input=18a1ef9c2efae296]*/ +/*[clinic end generated code: output=022e25e22e74b9e0 input=18a1ef9c2efae296]*/ { struct sched_param param; PyObject *result; @@ -7692,19 +7692,19 @@ PyDoc_STRVAR(os_sched_rr_get_interval__d "Value returned is a float."); #define OS_SCHED_RR_GET_INTERVAL_METHODDEF \ - {"sched_rr_get_interval", (PyCFunction)os_sched_rr_get_interval, METH_VARARGS, os_sched_rr_get_interval__doc__}, + {"sched_rr_get_interval", (PyCFunction)os_sched_rr_get_interval, METH_O, os_sched_rr_get_interval__doc__}, static double os_sched_rr_get_interval_impl(PyModuleDef *module, pid_t pid); static PyObject * -os_sched_rr_get_interval(PyModuleDef *module, PyObject *args) +os_sched_rr_get_interval(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; pid_t pid; double _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_PID ":sched_rr_get_interval", &pid)) goto exit; @@ -7719,7 +7719,7 @@ exit: static double os_sched_rr_get_interval_impl(PyModuleDef *module, pid_t pid) -/*[clinic end generated code: output=5b3b8d1f27fb2c0a input=2a973da15cca6fae]*/ +/*[clinic end generated code: output=4fb0d91c5309083b input=2a973da15cca6fae]*/ { struct timespec interval; if (sched_rr_get_interval(pid, &interval)) { @@ -7915,18 +7915,18 @@ PyDoc_STRVAR(os_sched_getaffinity__doc__ "The affinity is returned as a set of CPU identifiers."); #define OS_SCHED_GETAFFINITY_METHODDEF \ - {"sched_getaffinity", (PyCFunction)os_sched_getaffinity, METH_VARARGS, os_sched_getaffinity__doc__}, + {"sched_getaffinity", (PyCFunction)os_sched_getaffinity, METH_O, os_sched_getaffinity__doc__}, static PyObject * os_sched_getaffinity_impl(PyModuleDef *module, pid_t pid); static PyObject * -os_sched_getaffinity(PyModuleDef *module, PyObject *args) +os_sched_getaffinity(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; pid_t pid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_PID ":sched_getaffinity", &pid)) goto exit; @@ -7938,7 +7938,7 @@ exit: static PyObject * os_sched_getaffinity_impl(PyModuleDef *module, pid_t pid) -/*[clinic end generated code: output=7b273b0fca9830f0 input=eaf161936874b8a1]*/ +/*[clinic end generated code: output=819e20ad9a419c45 input=eaf161936874b8a1]*/ { int cpu, ncpus, count; size_t setsize; @@ -9111,18 +9111,18 @@ PyDoc_STRVAR(os_plock__doc__, "Lock program segments into memory.\");"); #define OS_PLOCK_METHODDEF \ - {"plock", (PyCFunction)os_plock, METH_VARARGS, os_plock__doc__}, + {"plock", (PyCFunction)os_plock, METH_O, os_plock__doc__}, static PyObject * os_plock_impl(PyModuleDef *module, int op); static PyObject * -os_plock(PyModuleDef *module, PyObject *args) +os_plock(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int op; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:plock", &op)) goto exit; @@ -9134,7 +9134,7 @@ exit: static PyObject * os_plock_impl(PyModuleDef *module, int op) -/*[clinic end generated code: output=2744fe4b6e5f4dbc input=e6e5e348e1525f60]*/ +/*[clinic end generated code: output=91114ed1e654ea5d input=e6e5e348e1525f60]*/ { if (plock(op) == -1) return posix_error(); @@ -9160,18 +9160,18 @@ PyDoc_STRVAR(os_setuid__doc__, "Set the current process\'s user id."); #define OS_SETUID_METHODDEF \ - {"setuid", (PyCFunction)os_setuid, METH_VARARGS, os_setuid__doc__}, + {"setuid", (PyCFunction)os_setuid, METH_O, os_setuid__doc__}, static PyObject * os_setuid_impl(PyModuleDef *module, uid_t uid); static PyObject * -os_setuid(PyModuleDef *module, PyObject *args) +os_setuid(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; uid_t uid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:setuid", _Py_Uid_Converter, &uid)) goto exit; @@ -9183,7 +9183,7 @@ exit: static PyObject * os_setuid_impl(PyModuleDef *module, uid_t uid) -/*[clinic end generated code: output=aea344bc22ccf400 input=c921a3285aa22256]*/ +/*[clinic end generated code: output=6d36894c89d9335a input=c921a3285aa22256]*/ { if (setuid(uid) < 0) return posix_error(); @@ -9209,18 +9209,18 @@ PyDoc_STRVAR(os_seteuid__doc__, "Set the current process\'s effective user id."); #define OS_SETEUID_METHODDEF \ - {"seteuid", (PyCFunction)os_seteuid, METH_VARARGS, os_seteuid__doc__}, + {"seteuid", (PyCFunction)os_seteuid, METH_O, os_seteuid__doc__}, static PyObject * os_seteuid_impl(PyModuleDef *module, uid_t euid); static PyObject * -os_seteuid(PyModuleDef *module, PyObject *args) +os_seteuid(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; uid_t euid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:seteuid", _Py_Uid_Converter, &euid)) goto exit; @@ -9232,7 +9232,7 @@ exit: static PyObject * os_seteuid_impl(PyModuleDef *module, uid_t euid) -/*[clinic end generated code: output=6e824cce4f3b8a5d input=ba93d927e4781aa9]*/ +/*[clinic end generated code: output=86e390b3ca06f0cb input=ba93d927e4781aa9]*/ { if (seteuid(euid) < 0) return posix_error(); @@ -9258,18 +9258,18 @@ PyDoc_STRVAR(os_setegid__doc__, "Set the current process\'s effective group id."); #define OS_SETEGID_METHODDEF \ - {"setegid", (PyCFunction)os_setegid, METH_VARARGS, os_setegid__doc__}, + {"setegid", (PyCFunction)os_setegid, METH_O, os_setegid__doc__}, static PyObject * os_setegid_impl(PyModuleDef *module, gid_t egid); static PyObject * -os_setegid(PyModuleDef *module, PyObject *args) +os_setegid(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; gid_t egid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:setegid", _Py_Gid_Converter, &egid)) goto exit; @@ -9281,7 +9281,7 @@ exit: static PyObject * os_setegid_impl(PyModuleDef *module, gid_t egid) -/*[clinic end generated code: output=80a32263a4d56a9c input=4080526d0ccd6ce3]*/ +/*[clinic end generated code: output=01cefd4bcec57c0c input=4080526d0ccd6ce3]*/ { if (setegid(egid) < 0) return posix_error(); @@ -9411,18 +9411,18 @@ PyDoc_STRVAR(os_setgid__doc__, "Set the current process\'s group id."); #define OS_SETGID_METHODDEF \ - {"setgid", (PyCFunction)os_setgid, METH_VARARGS, os_setgid__doc__}, + {"setgid", (PyCFunction)os_setgid, METH_O, os_setgid__doc__}, static PyObject * os_setgid_impl(PyModuleDef *module, gid_t gid); static PyObject * -os_setgid(PyModuleDef *module, PyObject *args) +os_setgid(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; gid_t gid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:setgid", _Py_Gid_Converter, &gid)) goto exit; @@ -9434,7 +9434,7 @@ exit: static PyObject * os_setgid_impl(PyModuleDef *module, gid_t gid) -/*[clinic end generated code: output=08287886db435f23 input=27d30c4059045dc6]*/ +/*[clinic end generated code: output=56458e96d3ffa7fa input=27d30c4059045dc6]*/ { if (setgid(gid) < 0) return posix_error(); @@ -10580,18 +10580,18 @@ PyDoc_STRVAR(os_getsid__doc__, "Call the system call getsid(pid) and return the result."); #define OS_GETSID_METHODDEF \ - {"getsid", (PyCFunction)os_getsid, METH_VARARGS, os_getsid__doc__}, + {"getsid", (PyCFunction)os_getsid, METH_O, os_getsid__doc__}, static PyObject * os_getsid_impl(PyModuleDef *module, pid_t pid); static PyObject * -os_getsid(PyModuleDef *module, PyObject *args) +os_getsid(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; pid_t pid; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_PID ":getsid", &pid)) goto exit; @@ -10603,7 +10603,7 @@ exit: static PyObject * os_getsid_impl(PyModuleDef *module, pid_t pid) -/*[clinic end generated code: output=ea8390f395f4e0e1 input=eeb2b923a30ce04e]*/ +/*[clinic end generated code: output=75d7aaadf28a60d6 input=eeb2b923a30ce04e]*/ { int sid; sid = getsid(pid); @@ -10718,18 +10718,18 @@ PyDoc_STRVAR(os_tcgetpgrp__doc__, "Return the process group associated with the terminal specified by fd."); #define OS_TCGETPGRP_METHODDEF \ - {"tcgetpgrp", (PyCFunction)os_tcgetpgrp, METH_VARARGS, os_tcgetpgrp__doc__}, + {"tcgetpgrp", (PyCFunction)os_tcgetpgrp, METH_O, os_tcgetpgrp__doc__}, static PyObject * os_tcgetpgrp_impl(PyModuleDef *module, int fd); static PyObject * -os_tcgetpgrp(PyModuleDef *module, PyObject *args) +os_tcgetpgrp(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:tcgetpgrp", &fd)) goto exit; @@ -10741,7 +10741,7 @@ exit: static PyObject * os_tcgetpgrp_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=abcf52ed4c8d22cb input=7f6c18eac10ada86]*/ +/*[clinic end generated code: output=ab0cdd2822a21f28 input=7f6c18eac10ada86]*/ { pid_t pgid = tcgetpgrp(fd); if (pgid < 0) @@ -11048,19 +11048,19 @@ PyDoc_STRVAR(os_dup__doc__, "Return a duplicate of a file descriptor."); #define OS_DUP_METHODDEF \ - {"dup", (PyCFunction)os_dup, METH_VARARGS, os_dup__doc__}, + {"dup", (PyCFunction)os_dup, METH_O, os_dup__doc__}, static int os_dup_impl(PyModuleDef *module, int fd); static PyObject * -os_dup(PyModuleDef *module, PyObject *args) +os_dup(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:dup", &fd)) goto exit; @@ -11075,7 +11075,7 @@ exit: static int os_dup_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=75943e057b25e1bd input=6f10f7ea97f7852a]*/ +/*[clinic end generated code: output=2a87d8162dec1814 input=6f10f7ea97f7852a]*/ { return _Py_dup(fd); } @@ -12007,19 +12007,19 @@ PyDoc_STRVAR(os_isatty__doc__, "connected to the slave end of a terminal."); #define OS_ISATTY_METHODDEF \ - {"isatty", (PyCFunction)os_isatty, METH_VARARGS, os_isatty__doc__}, + {"isatty", (PyCFunction)os_isatty, METH_O, os_isatty__doc__}, static int os_isatty_impl(PyModuleDef *module, int fd); static PyObject * -os_isatty(PyModuleDef *module, PyObject *args) +os_isatty(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:isatty", &fd)) goto exit; @@ -12034,7 +12034,7 @@ exit: static int os_isatty_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=4bfadbfe22715097 input=08ce94aa1eaf7b5e]*/ +/*[clinic end generated code: output=07cfa80c08cc82eb input=08ce94aa1eaf7b5e]*/ { if (!_PyVerify_fd(fd)) return 0; @@ -12173,18 +12173,18 @@ PyDoc_STRVAR(os_pipe2__doc__, "O_NONBLOCK, O_CLOEXEC."); #define OS_PIPE2_METHODDEF \ - {"pipe2", (PyCFunction)os_pipe2, METH_VARARGS, os_pipe2__doc__}, + {"pipe2", (PyCFunction)os_pipe2, METH_O, os_pipe2__doc__}, static PyObject * os_pipe2_impl(PyModuleDef *module, int flags); static PyObject * -os_pipe2(PyModuleDef *module, PyObject *args) +os_pipe2(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int flags; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:pipe2", &flags)) goto exit; @@ -12196,7 +12196,7 @@ exit: static PyObject * os_pipe2_impl(PyModuleDef *module, int flags) -/*[clinic end generated code: output=9e27c799ce19220b input=f261b6e7e63c6817]*/ +/*[clinic end generated code: output=6d8f0078603af150 input=f261b6e7e63c6817]*/ { int fds[2]; int res; @@ -12574,19 +12574,19 @@ PyDoc_STRVAR(os_major__doc__, "Extracts a device major number from a raw device number."); #define OS_MAJOR_METHODDEF \ - {"major", (PyCFunction)os_major, METH_VARARGS, os_major__doc__}, + {"major", (PyCFunction)os_major, METH_O, os_major__doc__}, static unsigned int os_major_impl(PyModuleDef *module, dev_t device); static PyObject * -os_major(PyModuleDef *module, PyObject *args) +os_major(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; dev_t device; unsigned int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:major", _Py_Dev_Converter, &device)) goto exit; @@ -12601,7 +12601,7 @@ exit: static unsigned int os_major_impl(PyModuleDef *module, dev_t device) -/*[clinic end generated code: output=a2d06e908ebf95b5 input=1e16a4d30c4d4462]*/ +/*[clinic end generated code: output=0de876756c48eb48 input=1e16a4d30c4d4462]*/ { return major(device); } @@ -12623,19 +12623,19 @@ PyDoc_STRVAR(os_minor__doc__, "Extracts a device minor number from a raw device number."); #define OS_MINOR_METHODDEF \ - {"minor", (PyCFunction)os_minor, METH_VARARGS, os_minor__doc__}, + {"minor", (PyCFunction)os_minor, METH_O, os_minor__doc__}, static unsigned int os_minor_impl(PyModuleDef *module, dev_t device); static PyObject * -os_minor(PyModuleDef *module, PyObject *args) +os_minor(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; dev_t device; unsigned int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:minor", _Py_Dev_Converter, &device)) goto exit; @@ -12650,7 +12650,7 @@ exit: static unsigned int os_minor_impl(PyModuleDef *module, dev_t device) -/*[clinic end generated code: output=6332287ee3f006e2 input=0842c6d23f24c65e]*/ +/*[clinic end generated code: output=3bee1d42e9e621a0 input=0842c6d23f24c65e]*/ { return minor(device); } @@ -13177,18 +13177,18 @@ PyDoc_STRVAR(os_unsetenv__doc__, "Delete an environment variable."); #define OS_UNSETENV_METHODDEF \ - {"unsetenv", (PyCFunction)os_unsetenv, METH_VARARGS, os_unsetenv__doc__}, + {"unsetenv", (PyCFunction)os_unsetenv, METH_O, os_unsetenv__doc__}, static PyObject * os_unsetenv_impl(PyModuleDef *module, PyObject *name); static PyObject * -os_unsetenv(PyModuleDef *module, PyObject *args) +os_unsetenv(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name = NULL; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:unsetenv", PyUnicode_FSConverter, &name)) goto exit; @@ -13203,7 +13203,7 @@ exit: static PyObject * os_unsetenv_impl(PyModuleDef *module, PyObject *name) -/*[clinic end generated code: output=91318c995f9a0767 input=2bb5288a599c7107]*/ +/*[clinic end generated code: output=2408973a2c64d125 input=2bb5288a599c7107]*/ { #ifndef HAVE_BROKEN_UNSETENV int err; @@ -13247,18 +13247,18 @@ PyDoc_STRVAR(os_strerror__doc__, "Translate an error code to a message string."); #define OS_STRERROR_METHODDEF \ - {"strerror", (PyCFunction)os_strerror, METH_VARARGS, os_strerror__doc__}, + {"strerror", (PyCFunction)os_strerror, METH_O, os_strerror__doc__}, static PyObject * os_strerror_impl(PyModuleDef *module, int code); static PyObject * -os_strerror(PyModuleDef *module, PyObject *args) +os_strerror(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int code; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:strerror", &code)) goto exit; @@ -13270,7 +13270,7 @@ exit: static PyObject * os_strerror_impl(PyModuleDef *module, int code) -/*[clinic end generated code: output=8665c70bb2ca4720 input=75a8673d97915a91]*/ +/*[clinic end generated code: output=dd6f398194212dca input=75a8673d97915a91]*/ { char *message = strerror(code); if (message == NULL) { @@ -13300,19 +13300,19 @@ PyDoc_STRVAR(os_WCOREDUMP__doc__, "Return True if the process returning status was dumped to a core file."); #define OS_WCOREDUMP_METHODDEF \ - {"WCOREDUMP", (PyCFunction)os_WCOREDUMP, METH_VARARGS, os_WCOREDUMP__doc__}, + {"WCOREDUMP", (PyCFunction)os_WCOREDUMP, METH_O, os_WCOREDUMP__doc__}, static int os_WCOREDUMP_impl(PyModuleDef *module, int status); static PyObject * -os_WCOREDUMP(PyModuleDef *module, PyObject *args) +os_WCOREDUMP(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int status; int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:WCOREDUMP", &status)) goto exit; @@ -13327,7 +13327,7 @@ exit: static int os_WCOREDUMP_impl(PyModuleDef *module, int status) -/*[clinic end generated code: output=e04d55c09c299828 input=8b05e7ab38528d04]*/ +/*[clinic end generated code: output=e34822d4c1b33370 input=8b05e7ab38528d04]*/ { WAIT_TYPE wait_status; WAIT_STATUS_INT(wait_status) = status; @@ -13818,18 +13818,18 @@ PyDoc_STRVAR(os_fstatvfs__doc__, "Equivalent to statvfs(fd)."); #define OS_FSTATVFS_METHODDEF \ - {"fstatvfs", (PyCFunction)os_fstatvfs, METH_VARARGS, os_fstatvfs__doc__}, + {"fstatvfs", (PyCFunction)os_fstatvfs, METH_O, os_fstatvfs__doc__}, static PyObject * os_fstatvfs_impl(PyModuleDef *module, int fd); static PyObject * -os_fstatvfs(PyModuleDef *module, PyObject *args) +os_fstatvfs(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:fstatvfs", &fd)) goto exit; @@ -13841,7 +13841,7 @@ exit: static PyObject * os_fstatvfs_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=0e32bf07f946ec0d input=d8122243ac50975e]*/ +/*[clinic end generated code: output=e3dbf948a770f2d2 input=d8122243ac50975e]*/ { int result; int async_err = 0; @@ -14477,18 +14477,18 @@ PyDoc_STRVAR(os_confstr__doc__, "Return a string-valued system configuration variable."); #define OS_CONFSTR_METHODDEF \ - {"confstr", (PyCFunction)os_confstr, METH_VARARGS, os_confstr__doc__}, + {"confstr", (PyCFunction)os_confstr, METH_O, os_confstr__doc__}, static PyObject * os_confstr_impl(PyModuleDef *module, int name); static PyObject * -os_confstr(PyModuleDef *module, PyObject *args) +os_confstr(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:confstr", conv_confstr_confname, &name)) goto exit; @@ -14500,7 +14500,7 @@ exit: static PyObject * os_confstr_impl(PyModuleDef *module, int name) -/*[clinic end generated code: output=3f5e8aba9f8e3174 input=18fb4d0567242e65]*/ +/*[clinic end generated code: output=a9f4c1529024879d input=18fb4d0567242e65]*/ { PyObject *result = NULL; char buffer[255]; @@ -15055,19 +15055,19 @@ PyDoc_STRVAR(os_sysconf__doc__, "Return an integer-valued system configuration variable."); #define OS_SYSCONF_METHODDEF \ - {"sysconf", (PyCFunction)os_sysconf, METH_VARARGS, os_sysconf__doc__}, + {"sysconf", (PyCFunction)os_sysconf, METH_O, os_sysconf__doc__}, static long os_sysconf_impl(PyModuleDef *module, int name); static PyObject * -os_sysconf(PyModuleDef *module, PyObject *args) +os_sysconf(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int name; long _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:sysconf", conv_sysconf_confname, &name)) goto exit; @@ -15082,7 +15082,7 @@ exit: static long os_sysconf_impl(PyModuleDef *module, int name) -/*[clinic end generated code: output=7b06dfdc472431e4 input=279e3430a33f29e4]*/ +/*[clinic end generated code: output=60f31fe3942a530a input=279e3430a33f29e4]*/ { long value; @@ -16074,18 +16074,18 @@ PyDoc_STRVAR(os_urandom__doc__, "Return a bytes object containing random bytes suitable for cryptographic use."); #define OS_URANDOM_METHODDEF \ - {"urandom", (PyCFunction)os_urandom, METH_VARARGS, os_urandom__doc__}, + {"urandom", (PyCFunction)os_urandom, METH_O, os_urandom__doc__}, static PyObject * os_urandom_impl(PyModuleDef *module, Py_ssize_t size); static PyObject * -os_urandom(PyModuleDef *module, PyObject *args) +os_urandom(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_ssize_t size; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "n:urandom", &size)) goto exit; @@ -16097,7 +16097,7 @@ exit: static PyObject * os_urandom_impl(PyModuleDef *module, Py_ssize_t size) -/*[clinic end generated code: output=5dbff582cab94cb9 input=4067cdb1b6776c29]*/ +/*[clinic end generated code: output=f20df3ac41f7de63 input=4067cdb1b6776c29]*/ { PyObject *bytes; int result; @@ -16298,19 +16298,19 @@ PyDoc_STRVAR(os_get_inheritable__doc__, "Get the close-on-exe flag of the specified file descriptor."); #define OS_GET_INHERITABLE_METHODDEF \ - {"get_inheritable", (PyCFunction)os_get_inheritable, METH_VARARGS, os_get_inheritable__doc__}, + {"get_inheritable", (PyCFunction)os_get_inheritable, METH_O, os_get_inheritable__doc__}, static int os_get_inheritable_impl(PyModuleDef *module, int fd); static PyObject * -os_get_inheritable(PyModuleDef *module, PyObject *args) +os_get_inheritable(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int fd; int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:get_inheritable", &fd)) goto exit; @@ -16325,7 +16325,7 @@ exit: static int os_get_inheritable_impl(PyModuleDef *module, int fd) -/*[clinic end generated code: output=261d1dd2b0dbdc35 input=89ac008dc9ab6b95]*/ +/*[clinic end generated code: output=152d35831ae75475 input=89ac008dc9ab6b95]*/ { if (!_PyVerify_fd(fd)){ posix_error(); @@ -16403,19 +16403,19 @@ PyDoc_STRVAR(os_get_handle_inheritable__ "Get the close-on-exe flag of the specified file descriptor."); #define OS_GET_HANDLE_INHERITABLE_METHODDEF \ - {"get_handle_inheritable", (PyCFunction)os_get_handle_inheritable, METH_VARARGS, os_get_handle_inheritable__doc__}, + {"get_handle_inheritable", (PyCFunction)os_get_handle_inheritable, METH_O, os_get_handle_inheritable__doc__}, static int os_get_handle_inheritable_impl(PyModuleDef *module, Py_intptr_t handle); static PyObject * -os_get_handle_inheritable(PyModuleDef *module, PyObject *args) +os_get_handle_inheritable(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; Py_intptr_t handle; int _return_value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "" _Py_PARSE_INTPTR ":get_handle_inheritable", &handle)) goto exit; @@ -16430,7 +16430,7 @@ exit: static int os_get_handle_inheritable_impl(PyModuleDef *module, Py_intptr_t handle) -/*[clinic end generated code: output=d5bf9d86900bf457 input=5f7759443aae3dc5]*/ +/*[clinic end generated code: output=afaa9d088628ede1 input=5f7759443aae3dc5]*/ { DWORD flags; diff -r da4eeba6ba20 Modules/pyexpat.c --- a/Modules/pyexpat.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Modules/pyexpat.c Fri Feb 20 16:26:18 2015 +0200 @@ -901,18 +901,18 @@ PyDoc_STRVAR(pyexpat_xmlparser_SetBase__ "Set the base URL for the parser."); #define PYEXPAT_XMLPARSER_SETBASE_METHODDEF \ - {"SetBase", (PyCFunction)pyexpat_xmlparser_SetBase, METH_VARARGS, pyexpat_xmlparser_SetBase__doc__}, + {"SetBase", (PyCFunction)pyexpat_xmlparser_SetBase, METH_O, pyexpat_xmlparser_SetBase__doc__}, static PyObject * pyexpat_xmlparser_SetBase_impl(xmlparseobject *self, const char *base); static PyObject * -pyexpat_xmlparser_SetBase(xmlparseobject *self, PyObject *args) +pyexpat_xmlparser_SetBase(xmlparseobject *self, PyObject *arg) { PyObject *return_value = NULL; const char *base; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "s:SetBase", &base)) goto exit; @@ -924,7 +924,7 @@ exit: static PyObject * pyexpat_xmlparser_SetBase_impl(xmlparseobject *self, const char *base) -/*[clinic end generated code: output=5bdb49f6689a5f93 input=c684e5de895ee1a8]*/ +/*[clinic end generated code: output=9b5f27bba09552b4 input=c684e5de895ee1a8]*/ { if (!XML_SetBase(self->itself, base)) { return PyErr_NoMemory(); @@ -1139,18 +1139,18 @@ PyDoc_STRVAR(pyexpat_xmlparser_SetParamE "was successful."); #define PYEXPAT_XMLPARSER_SETPARAMENTITYPARSING_METHODDEF \ - {"SetParamEntityParsing", (PyCFunction)pyexpat_xmlparser_SetParamEntityParsing, METH_VARARGS, pyexpat_xmlparser_SetParamEntityParsing__doc__}, + {"SetParamEntityParsing", (PyCFunction)pyexpat_xmlparser_SetParamEntityParsing, METH_O, pyexpat_xmlparser_SetParamEntityParsing__doc__}, static PyObject * pyexpat_xmlparser_SetParamEntityParsing_impl(xmlparseobject *self, int flag); static PyObject * -pyexpat_xmlparser_SetParamEntityParsing(xmlparseobject *self, PyObject *args) +pyexpat_xmlparser_SetParamEntityParsing(xmlparseobject *self, PyObject *arg) { PyObject *return_value = NULL; int flag; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:SetParamEntityParsing", &flag)) goto exit; @@ -1162,7 +1162,7 @@ exit: static PyObject * pyexpat_xmlparser_SetParamEntityParsing_impl(xmlparseobject *self, int flag) -/*[clinic end generated code: output=0f820882bc7768cc input=8aea19b4b15e9af1]*/ +/*[clinic end generated code: output=e71416f91164ca47 input=8aea19b4b15e9af1]*/ { flag = XML_SetParamEntityParsing(self->itself, flag); return PyLong_FromLong(flag); @@ -1849,18 +1849,18 @@ PyDoc_STRVAR(pyexpat_ErrorString__doc__, "Returns string error for given number."); #define PYEXPAT_ERRORSTRING_METHODDEF \ - {"ErrorString", (PyCFunction)pyexpat_ErrorString, METH_VARARGS, pyexpat_ErrorString__doc__}, + {"ErrorString", (PyCFunction)pyexpat_ErrorString, METH_O, pyexpat_ErrorString__doc__}, static PyObject * pyexpat_ErrorString_impl(PyModuleDef *module, long code); static PyObject * -pyexpat_ErrorString(PyModuleDef *module, PyObject *args) +pyexpat_ErrorString(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; long code; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "l:ErrorString", &code)) goto exit; @@ -1872,7 +1872,7 @@ exit: static PyObject * pyexpat_ErrorString_impl(PyModuleDef *module, long code) -/*[clinic end generated code: output=c70f3cd82bfaf067 input=cc67de010d9e62b3]*/ +/*[clinic end generated code: output=6a31ac860295786a input=cc67de010d9e62b3]*/ { return Py_BuildValue("z", XML_ErrorString((int)code)); } diff -r da4eeba6ba20 Objects/bytearrayobject.c --- a/Objects/bytearrayobject.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Objects/bytearrayobject.c Fri Feb 20 16:26:18 2015 +0200 @@ -2710,18 +2710,18 @@ PyDoc_STRVAR(bytearray_append__doc__, " The item to be appended."); #define BYTEARRAY_APPEND_METHODDEF \ - {"append", (PyCFunction)bytearray_append, METH_VARARGS, bytearray_append__doc__}, + {"append", (PyCFunction)bytearray_append, METH_O, bytearray_append__doc__}, static PyObject * bytearray_append_impl(PyByteArrayObject *self, int item); static PyObject * -bytearray_append(PyByteArrayObject *self, PyObject *args) +bytearray_append(PyByteArrayObject *self, PyObject *arg) { PyObject *return_value = NULL; int item; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:append", _getbytevalue, &item)) goto exit; @@ -2733,7 +2733,7 @@ exit: static PyObject * bytearray_append_impl(PyByteArrayObject *self, int item) -/*[clinic end generated code: output=b5b3325bb3bbaf85 input=ae56ea87380407cc]*/ +/*[clinic end generated code: output=27ebc1af1529ba26 input=ae56ea87380407cc]*/ { Py_ssize_t n = Py_SIZE(self); @@ -2947,18 +2947,18 @@ PyDoc_STRVAR(bytearray_remove__doc__, " The value to remove."); #define BYTEARRAY_REMOVE_METHODDEF \ - {"remove", (PyCFunction)bytearray_remove, METH_VARARGS, bytearray_remove__doc__}, + {"remove", (PyCFunction)bytearray_remove, METH_O, bytearray_remove__doc__}, static PyObject * bytearray_remove_impl(PyByteArrayObject *self, int value); static PyObject * -bytearray_remove(PyByteArrayObject *self, PyObject *args) +bytearray_remove(PyByteArrayObject *self, PyObject *arg) { PyObject *return_value = NULL; int value; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "O&:remove", _getbytevalue, &value)) goto exit; @@ -2970,7 +2970,7 @@ exit: static PyObject * bytearray_remove_impl(PyByteArrayObject *self, int value) -/*[clinic end generated code: output=c71c8bcf4703abfc input=47560b11fd856c24]*/ +/*[clinic end generated code: output=08ef399cc62f9aab input=47560b11fd856c24]*/ { Py_ssize_t where, n = Py_SIZE(self); char *buf = PyByteArray_AS_STRING(self); @@ -3421,18 +3421,18 @@ PyDoc_STRVAR(bytearray_fromhex__doc__, "Example: bytearray.fromhex(\'B9 01EF\') -> bytearray(b\'\\\\xb9\\\\x01\\\\xef\')"); #define BYTEARRAY_FROMHEX_METHODDEF \ - {"fromhex", (PyCFunction)bytearray_fromhex, METH_VARARGS|METH_CLASS, bytearray_fromhex__doc__}, + {"fromhex", (PyCFunction)bytearray_fromhex, METH_O|METH_CLASS, bytearray_fromhex__doc__}, static PyObject * bytearray_fromhex_impl(PyObject*cls, PyObject *string); static PyObject * -bytearray_fromhex(PyTypeObject *cls, PyObject *args) +bytearray_fromhex(PyTypeObject *cls, PyObject *arg) { PyObject *return_value = NULL; PyObject *string; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:fromhex", &string)) goto exit; @@ -3444,7 +3444,7 @@ exit: static PyObject * bytearray_fromhex_impl(PyObject*cls, PyObject *string) -/*[clinic end generated code: output=adc3c804a74e56d4 input=907bbd2d34d9367a]*/ +/*[clinic end generated code: output=d9a7f2f7d0d79a17 input=907bbd2d34d9367a]*/ { PyObject *newbytes; char *buf; diff -r da4eeba6ba20 Objects/bytesobject.c --- a/Objects/bytesobject.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Objects/bytesobject.c Fri Feb 20 16:26:18 2015 +0200 @@ -1661,18 +1661,18 @@ PyDoc_STRVAR(bytes_partition__doc__, "object and two empty bytes objects."); #define BYTES_PARTITION_METHODDEF \ - {"partition", (PyCFunction)bytes_partition, METH_VARARGS, bytes_partition__doc__}, + {"partition", (PyCFunction)bytes_partition, METH_O, bytes_partition__doc__}, static PyObject * bytes_partition_impl(PyBytesObject *self, Py_buffer *sep); static PyObject * -bytes_partition(PyBytesObject *self, PyObject *args) +bytes_partition(PyBytesObject *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer sep = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:partition", &sep)) goto exit; @@ -1688,7 +1688,7 @@ exit: static PyObject * bytes_partition_impl(PyBytesObject *self, Py_buffer *sep) -/*[clinic end generated code: output=3006727cfbf83aa4 input=bc855dc63ca949de]*/ +/*[clinic end generated code: output=1a733b879d4d2e15 input=bc855dc63ca949de]*/ { return stringlib_partition( (PyObject*) self, @@ -1728,18 +1728,18 @@ PyDoc_STRVAR(bytes_rpartition__doc__, "objects and the original bytes object."); #define BYTES_RPARTITION_METHODDEF \ - {"rpartition", (PyCFunction)bytes_rpartition, METH_VARARGS, bytes_rpartition__doc__}, + {"rpartition", (PyCFunction)bytes_rpartition, METH_O, bytes_rpartition__doc__}, static PyObject * bytes_rpartition_impl(PyBytesObject *self, Py_buffer *sep); static PyObject * -bytes_rpartition(PyBytesObject *self, PyObject *args) +bytes_rpartition(PyBytesObject *self, PyObject *arg) { PyObject *return_value = NULL; Py_buffer sep = {NULL, NULL}; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "y*:rpartition", &sep)) goto exit; @@ -1755,7 +1755,7 @@ exit: static PyObject * bytes_rpartition_impl(PyBytesObject *self, Py_buffer *sep) -/*[clinic end generated code: output=57b169dc47fa90e8 input=6588fff262a9170e]*/ +/*[clinic end generated code: output=4009faba6a1123d2 input=6588fff262a9170e]*/ { return stringlib_rpartition( (PyObject*) self, @@ -3394,18 +3394,18 @@ PyDoc_STRVAR(bytes_fromhex__doc__, "Example: bytes.fromhex(\'B9 01EF\') -> b\'\\\\xb9\\\\x01\\\\xef\'."); #define BYTES_FROMHEX_METHODDEF \ - {"fromhex", (PyCFunction)bytes_fromhex, METH_VARARGS|METH_CLASS, bytes_fromhex__doc__}, + {"fromhex", (PyCFunction)bytes_fromhex, METH_O|METH_CLASS, bytes_fromhex__doc__}, static PyObject * bytes_fromhex_impl(PyTypeObject *type, PyObject *string); static PyObject * -bytes_fromhex(PyTypeObject *type, PyObject *args) +bytes_fromhex(PyTypeObject *type, PyObject *arg) { PyObject *return_value = NULL; PyObject *string; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:fromhex", &string)) goto exit; @@ -3417,7 +3417,7 @@ exit: static PyObject * bytes_fromhex_impl(PyTypeObject *type, PyObject *string) -/*[clinic end generated code: output=09e6cbef56cbbb65 input=bf4d1c361670acd3]*/ +/*[clinic end generated code: output=bad49c2a092bf024 input=bf4d1c361670acd3]*/ { PyObject *newstring; char *buf; diff -r da4eeba6ba20 Python/bltinmodule.c --- a/Python/bltinmodule.c Fri Feb 20 12:46:11 2015 +0200 +++ b/Python/bltinmodule.c Fri Feb 20 16:26:18 2015 +0200 @@ -694,18 +694,18 @@ PyDoc_STRVAR(builtin_chr__doc__, "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff."); #define BUILTIN_CHR_METHODDEF \ - {"chr", (PyCFunction)builtin_chr, METH_VARARGS, builtin_chr__doc__}, + {"chr", (PyCFunction)builtin_chr, METH_O, builtin_chr__doc__}, static PyObject * builtin_chr_impl(PyModuleDef *module, int i); static PyObject * -builtin_chr(PyModuleDef *module, PyObject *args) +builtin_chr(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; int i; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "i:chr", &i)) goto exit; @@ -717,7 +717,7 @@ exit: static PyObject * builtin_chr_impl(PyModuleDef *module, int i) -/*[clinic end generated code: output=4d6bbe948f56e2ae input=9b1ced29615adf66]*/ +/*[clinic end generated code: output=f900f499635e86ce input=9b1ced29615adf66]*/ { return PyUnicode_FromOrdinal(i); } diff -r da4eeba6ba20 Python/clinic/import.c.h --- a/Python/clinic/import.c.h Fri Feb 20 12:46:11 2015 +0200 +++ b/Python/clinic/import.c.h Fri Feb 20 16:26:18 2015 +0200 @@ -122,18 +122,18 @@ PyDoc_STRVAR(_imp_init_builtin__doc__, "Initializes a built-in module."); #define _IMP_INIT_BUILTIN_METHODDEF \ - {"init_builtin", (PyCFunction)_imp_init_builtin, METH_VARARGS, _imp_init_builtin__doc__}, + {"init_builtin", (PyCFunction)_imp_init_builtin, METH_O, _imp_init_builtin__doc__}, static PyObject * _imp_init_builtin_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_init_builtin(PyModuleDef *module, PyObject *args) +_imp_init_builtin(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:init_builtin", &name)) goto exit; @@ -150,18 +150,18 @@ PyDoc_STRVAR(_imp_init_frozen__doc__, "Initializes a frozen module."); #define _IMP_INIT_FROZEN_METHODDEF \ - {"init_frozen", (PyCFunction)_imp_init_frozen, METH_VARARGS, _imp_init_frozen__doc__}, + {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__}, static PyObject * _imp_init_frozen_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_init_frozen(PyModuleDef *module, PyObject *args) +_imp_init_frozen(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:init_frozen", &name)) goto exit; @@ -178,18 +178,18 @@ PyDoc_STRVAR(_imp_get_frozen_object__doc "Create a code object for a frozen module."); #define _IMP_GET_FROZEN_OBJECT_METHODDEF \ - {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_VARARGS, _imp_get_frozen_object__doc__}, + {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_O, _imp_get_frozen_object__doc__}, static PyObject * _imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_get_frozen_object(PyModuleDef *module, PyObject *args) +_imp_get_frozen_object(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:get_frozen_object", &name)) goto exit; @@ -206,18 +206,18 @@ PyDoc_STRVAR(_imp_is_frozen_package__doc "Returns True if the module name is of a frozen package."); #define _IMP_IS_FROZEN_PACKAGE_METHODDEF \ - {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_VARARGS, _imp_is_frozen_package__doc__}, + {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__}, static PyObject * _imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_is_frozen_package(PyModuleDef *module, PyObject *args) +_imp_is_frozen_package(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:is_frozen_package", &name)) goto exit; @@ -234,18 +234,18 @@ PyDoc_STRVAR(_imp_is_builtin__doc__, "Returns True if the module name corresponds to a built-in module."); #define _IMP_IS_BUILTIN_METHODDEF \ - {"is_builtin", (PyCFunction)_imp_is_builtin, METH_VARARGS, _imp_is_builtin__doc__}, + {"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__}, static PyObject * _imp_is_builtin_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_is_builtin(PyModuleDef *module, PyObject *args) +_imp_is_builtin(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:is_builtin", &name)) goto exit; @@ -262,18 +262,18 @@ PyDoc_STRVAR(_imp_is_frozen__doc__, "Returns True if the module name corresponds to a frozen module."); #define _IMP_IS_FROZEN_METHODDEF \ - {"is_frozen", (PyCFunction)_imp_is_frozen, METH_VARARGS, _imp_is_frozen__doc__}, + {"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__}, static PyObject * _imp_is_frozen_impl(PyModuleDef *module, PyObject *name); static PyObject * -_imp_is_frozen(PyModuleDef *module, PyObject *args) +_imp_is_frozen(PyModuleDef *module, PyObject *arg) { PyObject *return_value = NULL; PyObject *name; - if (!PyArg_ParseTuple(args, + if (!PyArg_Parse(arg, "U:is_frozen", &name)) goto exit; @@ -320,4 +320,4 @@ exit: #ifndef _IMP_LOAD_DYNAMIC_METHODDEF #define _IMP_LOAD_DYNAMIC_METHODDEF #endif /* !defined(_IMP_LOAD_DYNAMIC_METHODDEF) */ -/*[clinic end generated code: output=087a1f22e9febcc7 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=d41c392510815c5b input=a9049054013a1b77]*/ diff -r da4eeba6ba20 Tools/clinic/clinic.py --- a/Tools/clinic/clinic.py Fri Feb 20 12:46:11 2015 +0200 +++ b/Tools/clinic/clinic.py Fri Feb 20 16:26:18 2015 +0200 @@ -589,8 +589,6 @@ class CLanguage(Language): meth_o = (len(parameters) == 1 and parameters[0].kind == inspect.Parameter.POSITIONAL_ONLY and not converters[0].is_optional() and - isinstance(converters[0], object_converter) and - converters[0].format_unit == 'O' and not new_or_init) # we have to set these things before we're done: @@ -696,22 +694,40 @@ class CLanguage(Language): elif meth_o: flags = "METH_O" - meth_o_prototype = normalize_snippet(""" - static PyObject * - {c_basename}({impl_parameters}) - """) - - if default_return_converter: - # maps perfectly to METH_O, doesn't need a return converter. - # so we skip making a parse function - # and call directly into the impl function. - impl_prototype = parser_prototype = parser_definition = '' - impl_definition = meth_o_prototype + if (isinstance(converters[0], object_converter) and + converters[0].format_unit == 'O'): + meth_o_prototype = normalize_snippet(""" + static PyObject * + {c_basename}({impl_parameters}) + """) + + if default_return_converter: + # maps perfectly to METH_O, doesn't need a return converter. + # so we skip making a parse function + # and call directly into the impl function. + impl_prototype = parser_prototype = parser_definition = '' + impl_definition = meth_o_prototype + else: + # SLIGHT HACK + # use impl_parameters for the parser here! + parser_prototype = meth_o_prototype + parser_definition = parser_body(parser_prototype) + else: - # SLIGHT HACK - # use impl_parameters for the parser here! - parser_prototype = meth_o_prototype - parser_definition = parser_body(parser_prototype) + argname = 'arg' + if parameters[0].name == argname: + argname += '_' + parser_prototype = normalize_snippet(""" + static PyObject * + {c_basename}({self_type}{self_name}, PyObject *%s) + """ % argname) + + parser_definition = parser_body(parser_prototype, normalize_snippet(""" + if (!PyArg_Parse(%s, + "{format_units}:{name}", + {parse_arguments})) + goto exit; + """ % argname, indent=4)) elif has_option_groups: # positional parameters with option groups @@ -1020,7 +1036,7 @@ class CLanguage(Language): # METH_O, we have exactly one anyway, so we know exactly # where it is. if ("METH_O" in templates['methoddef_define'] and - not default_return_converter): + '{impl_parameters}' in templates['parser_prototype']): data.declarations.pop(0) template_dict = {}