Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Issue #26305: Argument Clinic now uses braces in C code as required by PEP 7.

This commit is contained in:
Serhiy Storchaka 2016-06-09 16:16:06 +03:00
parent 2561bf6ae0
commit 5dee6551e2
52 changed files with 1575 additions and 816 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Modules/_io/clinic/_iomodule.c.h
View File

@ -149,11 +149,12 @@ _io_open(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *opener = Py_None; PyObject *opener = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|sizzziO:open", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|sizzziO:open", _keywords,
&file, &mode, &buffering, &encoding, &errors, &newline, &closefd, &opener)) &file, &mode, &buffering, &encoding, &errors, &newline, &closefd, &opener)) {
goto exit; goto exit;
}
return_value = _io_open_impl(module, file, mode, buffering, encoding, errors, newline, closefd, opener); return_value = _io_open_impl(module, file, mode, buffering, encoding, errors, newline, closefd, opener);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=97cdc09bf68a8064 input=a9049054013a1b77]*/ /*[clinic end generated code: output=079f597e71e9f0c6 input=a9049054013a1b77]*/

65
Modules/_io/clinic/bufferedio.c.h
View File

@ -19,14 +19,16 @@ _io__BufferedIOBase_readinto(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto", &buffer)) if (!PyArg_Parse(arg, "w*:readinto", &buffer)) {
goto exit; goto exit;
}
return_value = _io__BufferedIOBase_readinto_impl(self, &buffer); return_value = _io__BufferedIOBase_readinto_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -48,14 +50,16 @@ _io__BufferedIOBase_readinto1(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto1", &buffer)) if (!PyArg_Parse(arg, "w*:readinto1", &buffer)) {
goto exit; goto exit;
}
return_value = _io__BufferedIOBase_readinto1_impl(self, &buffer); return_value = _io__BufferedIOBase_readinto1_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -99,8 +103,9 @@ _io__Buffered_peek(buffered *self, PyObject *args)
Py_ssize_t size = 0; Py_ssize_t size = 0;
if (!PyArg_ParseTuple(args, "|n:peek", if (!PyArg_ParseTuple(args, "|n:peek",
&size)) &size)) {
goto exit; goto exit;
}
return_value = _io__Buffered_peek_impl(self, size); return_value = _io__Buffered_peek_impl(self, size);
exit: exit:
@ -125,8 +130,9 @@ _io__Buffered_read(buffered *self, PyObject *args)
Py_ssize_t n = -1; Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|O&:read", if (!PyArg_ParseTuple(args, "|O&:read",
_PyIO_ConvertSsize_t, &n)) _PyIO_ConvertSsize_t, &n)) {
goto exit; goto exit;
}
return_value = _io__Buffered_read_impl(self, n); return_value = _io__Buffered_read_impl(self, n);
exit: exit:
@ -150,8 +156,9 @@ _io__Buffered_read1(buffered *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_ssize_t n; Py_ssize_t n;
if (!PyArg_Parse(arg, "n:read1", &n)) if (!PyArg_Parse(arg, "n:read1", &n)) {
goto exit; goto exit;
}
return_value = _io__Buffered_read1_impl(self, n); return_value = _io__Buffered_read1_impl(self, n);
exit: exit:
@ -175,14 +182,16 @@ _io__Buffered_readinto(buffered *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto", &buffer)) if (!PyArg_Parse(arg, "w*:readinto", &buffer)) {
goto exit; goto exit;
}
return_value = _io__Buffered_readinto_impl(self, &buffer); return_value = _io__Buffered_readinto_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -204,14 +213,16 @@ _io__Buffered_readinto1(buffered *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto1", &buffer)) if (!PyArg_Parse(arg, "w*:readinto1", &buffer)) {
goto exit; goto exit;
}
return_value = _io__Buffered_readinto1_impl(self, &buffer); return_value = _io__Buffered_readinto1_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -234,8 +245,9 @@ _io__Buffered_readline(buffered *self, PyObject *args)
Py_ssize_t size = -1; Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|O&:readline", if (!PyArg_ParseTuple(args, "|O&:readline",
_PyIO_ConvertSsize_t, &size)) _PyIO_ConvertSsize_t, &size)) {
goto exit; goto exit;
}
return_value = _io__Buffered_readline_impl(self, size); return_value = _io__Buffered_readline_impl(self, size);
exit: exit:
@ -261,8 +273,9 @@ _io__Buffered_seek(buffered *self, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek", if (!PyArg_ParseTuple(args, "O|i:seek",
&targetobj, &whence)) &targetobj, &whence)) {
goto exit; goto exit;
}
return_value = _io__Buffered_seek_impl(self, targetobj, whence); return_value = _io__Buffered_seek_impl(self, targetobj, whence);
exit: exit:
@ -288,8 +301,9 @@ _io__Buffered_truncate(buffered *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "truncate", if (!PyArg_UnpackTuple(args, "truncate",
0, 1, 0, 1,
&pos)) &pos)) {
goto exit; goto exit;
}
return_value = _io__Buffered_truncate_impl(self, pos); return_value = _io__Buffered_truncate_impl(self, pos);
exit: exit:
@ -315,8 +329,9 @@ _io_BufferedReader___init__(PyObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE; Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedReader", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedReader", _keywords,
&raw, &buffer_size)) &raw, &buffer_size)) {
goto exit; goto exit;
}
return_value = _io_BufferedReader___init___impl((buffered *)self, raw, buffer_size); return_value = _io_BufferedReader___init___impl((buffered *)self, raw, buffer_size);
exit: exit:
@ -346,8 +361,9 @@ _io_BufferedWriter___init__(PyObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE; Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedWriter", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedWriter", _keywords,
&raw, &buffer_size)) &raw, &buffer_size)) {
goto exit; goto exit;
}
return_value = _io_BufferedWriter___init___impl((buffered *)self, raw, buffer_size); return_value = _io_BufferedWriter___init___impl((buffered *)self, raw, buffer_size);
exit: exit:
@ -371,14 +387,16 @@ _io_BufferedWriter_write(buffered *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:write", &buffer)) if (!PyArg_Parse(arg, "y*:write", &buffer)) {
goto exit; goto exit;
}
return_value = _io_BufferedWriter_write_impl(self, &buffer); return_value = _io_BufferedWriter_write_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -410,11 +428,13 @@ _io_BufferedRWPair___init__(PyObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE; Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
if ((Py_TYPE(self) == &PyBufferedRWPair_Type) && if ((Py_TYPE(self) == &PyBufferedRWPair_Type) &&
!_PyArg_NoKeywords("BufferedRWPair", kwargs)) !_PyArg_NoKeywords("BufferedRWPair", kwargs)) {
goto exit; goto exit;
}
if (!PyArg_ParseTuple(args, "OO|n:BufferedRWPair", if (!PyArg_ParseTuple(args, "OO|n:BufferedRWPair",
&reader, &writer, &buffer_size)) &reader, &writer, &buffer_size)) {
goto exit; goto exit;
}
return_value = _io_BufferedRWPair___init___impl((rwpair *)self, reader, writer, buffer_size); return_value = _io_BufferedRWPair___init___impl((rwpair *)self, reader, writer, buffer_size);
exit: exit:
@ -444,11 +464,12 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE; Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedRandom", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|n:BufferedRandom", _keywords,
&raw, &buffer_size)) &raw, &buffer_size)) {
goto exit; goto exit;
}
return_value = _io_BufferedRandom___init___impl((buffered *)self, raw, buffer_size); return_value = _io_BufferedRandom___init___impl((buffered *)self, raw, buffer_size);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=2bbb5e239b4ffe6f input=a9049054013a1b77]*/ /*[clinic end generated code: output=4f6196c756b880c8 input=a9049054013a1b77]*/

26
Modules/_io/clinic/bytesio.c.h
View File

@ -171,8 +171,9 @@ _io_BytesIO_read(bytesio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "read", if (!PyArg_UnpackTuple(args, "read",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_read_impl(self, arg); return_value = _io_BytesIO_read_impl(self, arg);
exit: exit:
@ -215,8 +216,9 @@ _io_BytesIO_readline(bytesio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "readline", if (!PyArg_UnpackTuple(args, "readline",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_readline_impl(self, arg); return_value = _io_BytesIO_readline_impl(self, arg);
exit: exit:
@ -247,8 +249,9 @@ _io_BytesIO_readlines(bytesio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "readlines", if (!PyArg_UnpackTuple(args, "readlines",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_readlines_impl(self, arg); return_value = _io_BytesIO_readlines_impl(self, arg);
exit: exit:
@ -276,14 +279,16 @@ _io_BytesIO_readinto(bytesio *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto", &buffer)) if (!PyArg_Parse(arg, "w*:readinto", &buffer)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_readinto_impl(self, &buffer); return_value = _io_BytesIO_readinto_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -311,8 +316,9 @@ _io_BytesIO_truncate(bytesio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "truncate", if (!PyArg_UnpackTuple(args, "truncate",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_truncate_impl(self, arg); return_value = _io_BytesIO_truncate_impl(self, arg);
exit: exit:
@ -345,8 +351,9 @@ _io_BytesIO_seek(bytesio *self, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "n|i:seek", if (!PyArg_ParseTuple(args, "n|i:seek",
&pos, &whence)) &pos, &whence)) {
goto exit; goto exit;
}
return_value = _io_BytesIO_seek_impl(self, pos, whence); return_value = _io_BytesIO_seek_impl(self, pos, whence);
exit: exit:
@ -412,11 +419,12 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *initvalue = NULL; PyObject *initvalue = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:BytesIO", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:BytesIO", _keywords,
&initvalue)) &initvalue)) {
goto exit; goto exit;
}
return_value = _io_BytesIO___init___impl((bytesio *)self, initvalue); return_value = _io_BytesIO___init___impl((bytesio *)self, initvalue);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=60ce2c6272718431 input=a9049054013a1b77]*/ /*[clinic end generated code: output=3fdb62f3e3b0544d input=a9049054013a1b77]*/

26
Modules/_io/clinic/fileio.c.h
View File

@ -56,8 +56,9 @@ _io_FileIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *opener = Py_None; PyObject *opener = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|siO:FileIO", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|siO:FileIO", _keywords,
&nameobj, &mode, &closefd, &opener)) &nameobj, &mode, &closefd, &opener)) {
goto exit; goto exit;
}
return_value = _io_FileIO___init___impl((fileio *)self, nameobj, mode, closefd, opener); return_value = _io_FileIO___init___impl((fileio *)self, nameobj, mode, closefd, opener);
exit: exit:
@ -154,14 +155,16 @@ _io_FileIO_readinto(fileio *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "w*:readinto", &buffer)) if (!PyArg_Parse(arg, "w*:readinto", &buffer)) {
goto exit; goto exit;
}
return_value = _io_FileIO_readinto_impl(self, &buffer); return_value = _io_FileIO_readinto_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -210,8 +213,9 @@ _io_FileIO_read(fileio *self, PyObject *args)
Py_ssize_t size = -1; Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|O&:read", if (!PyArg_ParseTuple(args, "|O&:read",
_PyIO_ConvertSsize_t, &size)) _PyIO_ConvertSsize_t, &size)) {
goto exit; goto exit;
}
return_value = _io_FileIO_read_impl(self, size); return_value = _io_FileIO_read_impl(self, size);
exit: exit:
@ -240,14 +244,16 @@ _io_FileIO_write(fileio *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer b = {NULL, NULL}; Py_buffer b = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:write", &b)) if (!PyArg_Parse(arg, "y*:write", &b)) {
goto exit; goto exit;
}
return_value = _io_FileIO_write_impl(self, &b); return_value = _io_FileIO_write_impl(self, &b);
exit: exit:
/* Cleanup for b */ /* Cleanup for b */
if (b.obj) if (b.obj) {
PyBuffer_Release(&b); PyBuffer_Release(&b);
}
return return_value; return return_value;
} }
@ -280,8 +286,9 @@ _io_FileIO_seek(fileio *self, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek", if (!PyArg_ParseTuple(args, "O|i:seek",
&pos, &whence)) &pos, &whence)) {
goto exit; goto exit;
}
return_value = _io_FileIO_seek_impl(self, pos, whence); return_value = _io_FileIO_seek_impl(self, pos, whence);
exit: exit:
@ -333,8 +340,9 @@ _io_FileIO_truncate(fileio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "truncate", if (!PyArg_UnpackTuple(args, "truncate",
0, 1, 0, 1,
&posobj)) &posobj)) {
goto exit; goto exit;
}
return_value = _io_FileIO_truncate_impl(self, posobj); return_value = _io_FileIO_truncate_impl(self, posobj);
exit: exit:
@ -364,4 +372,4 @@ _io_FileIO_isatty(fileio *self, PyObject *Py_UNUSED(ignored))
#ifndef _IO_FILEIO_TRUNCATE_METHODDEF #ifndef _IO_FILEIO_TRUNCATE_METHODDEF
#define _IO_FILEIO_TRUNCATE_METHODDEF #define _IO_FILEIO_TRUNCATE_METHODDEF
#endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */ #endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */
/*[clinic end generated code: output=dcbc39b466598492 input=a9049054013a1b77]*/ /*[clinic end generated code: output=bf4b4bd6b976346d input=a9049054013a1b77]*/

11
Modules/_io/clinic/iobase.c.h
View File

@ -186,8 +186,9 @@ _io__IOBase_readline(PyObject *self, PyObject *args)
Py_ssize_t limit = -1; Py_ssize_t limit = -1;
if (!PyArg_ParseTuple(args, "|O&:readline", if (!PyArg_ParseTuple(args, "|O&:readline",
_PyIO_ConvertSsize_t, &limit)) _PyIO_ConvertSsize_t, &limit)) {
goto exit; goto exit;
}
return_value = _io__IOBase_readline_impl(self, limit); return_value = _io__IOBase_readline_impl(self, limit);
exit: exit:
@ -217,8 +218,9 @@ _io__IOBase_readlines(PyObject *self, PyObject *args)
Py_ssize_t hint = -1; Py_ssize_t hint = -1;
if (!PyArg_ParseTuple(args, "|O&:readlines", if (!PyArg_ParseTuple(args, "|O&:readlines",
_PyIO_ConvertSsize_t, &hint)) _PyIO_ConvertSsize_t, &hint)) {
goto exit; goto exit;
}
return_value = _io__IOBase_readlines_impl(self, hint); return_value = _io__IOBase_readlines_impl(self, hint);
exit: exit:
@ -251,8 +253,9 @@ _io__RawIOBase_read(PyObject *self, PyObject *args)
Py_ssize_t n = -1; Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|n:read", if (!PyArg_ParseTuple(args, "|n:read",
&n)) &n)) {
goto exit; goto exit;
}
return_value = _io__RawIOBase_read_impl(self, n); return_value = _io__RawIOBase_read_impl(self, n);
exit: exit:
@ -276,4 +279,4 @@ _io__RawIOBase_readall(PyObject *self, PyObject *Py_UNUSED(ignored))
{ {
return _io__RawIOBase_readall_impl(self); return _io__RawIOBase_readall_impl(self);
} }
/*[clinic end generated code: output=b874952f5cc248a4 input=a9049054013a1b77]*/ /*[clinic end generated code: output=0f53fed928d8e02f input=a9049054013a1b77]*/

17
Modules/_io/clinic/stringio.c.h
View File

@ -61,8 +61,9 @@ _io_StringIO_read(stringio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "read", if (!PyArg_UnpackTuple(args, "read",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_StringIO_read_impl(self, arg); return_value = _io_StringIO_read_impl(self, arg);
exit: exit:
@ -91,8 +92,9 @@ _io_StringIO_readline(stringio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "readline", if (!PyArg_UnpackTuple(args, "readline",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_StringIO_readline_impl(self, arg); return_value = _io_StringIO_readline_impl(self, arg);
exit: exit:
@ -123,8 +125,9 @@ _io_StringIO_truncate(stringio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "truncate", if (!PyArg_UnpackTuple(args, "truncate",
0, 1, 0, 1,
&arg)) &arg)) {
goto exit; goto exit;
}
return_value = _io_StringIO_truncate_impl(self, arg); return_value = _io_StringIO_truncate_impl(self, arg);
exit: exit:
@ -157,8 +160,9 @@ _io_StringIO_seek(stringio *self, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "n|i:seek", if (!PyArg_ParseTuple(args, "n|i:seek",
&pos, &whence)) &pos, &whence)) {
goto exit; goto exit;
}
return_value = _io_StringIO_seek_impl(self, pos, whence); return_value = _io_StringIO_seek_impl(self, pos, whence);
exit: exit:
@ -222,8 +226,9 @@ _io_StringIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
PyObject *newline_obj = NULL; PyObject *newline_obj = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:StringIO", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:StringIO", _keywords,
&value, &newline_obj)) &value, &newline_obj)) {
goto exit; goto exit;
}
return_value = _io_StringIO___init___impl((stringio *)self, value, newline_obj); return_value = _io_StringIO___init___impl((stringio *)self, value, newline_obj);
exit: exit:
@ -283,4 +288,4 @@ _io_StringIO_seekable(stringio *self, PyObject *Py_UNUSED(ignored))
{ {
return _io_StringIO_seekable_impl(self); return _io_StringIO_seekable_impl(self);
} }
/*[clinic end generated code: output=f061cf3a20cd14ed input=a9049054013a1b77]*/ /*[clinic end generated code: output=0513219581cbe952 input=a9049054013a1b77]*/

26
Modules/_io/clinic/textio.c.h
View File

@ -30,8 +30,9 @@ _io_IncrementalNewlineDecoder___init__(PyObject *self, PyObject *args, PyObject
PyObject *errors = NULL; PyObject *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|O:IncrementalNewlineDecoder", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Oi|O:IncrementalNewlineDecoder", _keywords,
&decoder, &translate, &errors)) &decoder, &translate, &errors)) {
goto exit; goto exit;
}
return_value = _io_IncrementalNewlineDecoder___init___impl((nldecoder_object *)self, decoder, translate, errors); return_value = _io_IncrementalNewlineDecoder___init___impl((nldecoder_object *)self, decoder, translate, errors);
exit: exit:
@ -59,8 +60,9 @@ _io_IncrementalNewlineDecoder_decode(nldecoder_object *self, PyObject *args, PyO
int final = 0; int final = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:decode", _keywords,
&input, &final)) &input, &final)) {
goto exit; goto exit;
}
return_value = _io_IncrementalNewlineDecoder_decode_impl(self, input, final); return_value = _io_IncrementalNewlineDecoder_decode_impl(self, input, final);
exit: exit:
@ -162,8 +164,9 @@ _io_TextIOWrapper___init__(PyObject *self, PyObject *args, PyObject *kwargs)
int write_through = 0; int write_through = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|zzzii:TextIOWrapper", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|zzzii:TextIOWrapper", _keywords,
&buffer, &encoding, &errors, &newline, &line_buffering, &write_through)) &buffer, &encoding, &errors, &newline, &line_buffering, &write_through)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper___init___impl((textio *)self, buffer, encoding, errors, newline, line_buffering, write_through); return_value = _io_TextIOWrapper___init___impl((textio *)self, buffer, encoding, errors, newline, line_buffering, write_through);
exit: exit:
@ -204,8 +207,9 @@ _io_TextIOWrapper_write(textio *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *text; PyObject *text;
if (!PyArg_Parse(arg, "U:write", &text)) if (!PyArg_Parse(arg, "U:write", &text)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper_write_impl(self, text); return_value = _io_TextIOWrapper_write_impl(self, text);
exit: exit:
@ -230,8 +234,9 @@ _io_TextIOWrapper_read(textio *self, PyObject *args)
Py_ssize_t n = -1; Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|O&:read", if (!PyArg_ParseTuple(args, "|O&:read",
_PyIO_ConvertSsize_t, &n)) _PyIO_ConvertSsize_t, &n)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper_read_impl(self, n); return_value = _io_TextIOWrapper_read_impl(self, n);
exit: exit:
@ -256,8 +261,9 @@ _io_TextIOWrapper_readline(textio *self, PyObject *args)
Py_ssize_t size = -1; Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|n:readline", if (!PyArg_ParseTuple(args, "|n:readline",
&size)) &size)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper_readline_impl(self, size); return_value = _io_TextIOWrapper_readline_impl(self, size);
exit: exit:
@ -283,8 +289,9 @@ _io_TextIOWrapper_seek(textio *self, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek", if (!PyArg_ParseTuple(args, "O|i:seek",
&cookieObj, &whence)) &cookieObj, &whence)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence); return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence);
exit: exit:
@ -327,8 +334,9 @@ _io_TextIOWrapper_truncate(textio *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "truncate", if (!PyArg_UnpackTuple(args, "truncate",
0, 1, 0, 1,
&pos)) &pos)) {
goto exit; goto exit;
}
return_value = _io_TextIOWrapper_truncate_impl(self, pos); return_value = _io_TextIOWrapper_truncate_impl(self, pos);
exit: exit:
@ -453,4 +461,4 @@ _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
{ {
return _io_TextIOWrapper_close_impl(self); return _io_TextIOWrapper_close_impl(self);
} }
/*[clinic end generated code: output=690608f85aab8ba5 input=a9049054013a1b77]*/ /*[clinic end generated code: output=31a39bbbe07ae4e7 input=a9049054013a1b77]*/

4
Modules/_winapi.c
View File

@ -175,7 +175,7 @@ class HANDLE_return_converter(CReturnConverter):
self.declare(data) self.declare(data)
self.err_occurred_if("_return_value == INVALID_HANDLE_VALUE", data) self.err_occurred_if("_return_value == INVALID_HANDLE_VALUE", data)
data.return_conversion.append( data.return_conversion.append(
'if (_return_value == NULL)\n Py_RETURN_NONE;\n') 'if (_return_value == NULL) {\n Py_RETURN_NONE;\n}\n')
data.return_conversion.append( data.return_conversion.append(
'return_value = HANDLE_TO_PYNUM(_return_value);\n') 'return_value = HANDLE_TO_PYNUM(_return_value);\n')
@ -188,7 +188,7 @@ class DWORD_return_converter(CReturnConverter):
data.return_conversion.append( data.return_conversion.append(
'return_value = Py_BuildValue("k", _return_value);\n') 'return_value = Py_BuildValue("k", _return_value);\n')
[python start generated code]*/ [python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=374076979596ebba]*/ /*[python end generated code: output=da39a3ee5e6b4b0d input=94819e72d2c6d558]*/
#include "clinic/_winapi.c.h" #include "clinic/_winapi.c.h"

29
Modules/cjkcodecs/clinic/multibytecodec.c.h
View File

@ -30,8 +30,9 @@ _multibytecodec_MultibyteCodec_encode(MultibyteCodecObject *self, PyObject *args
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|z:encode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|z:encode", _keywords,
&input, &errors)) &input, &errors)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteCodec_encode_impl(self, input, errors); return_value = _multibytecodec_MultibyteCodec_encode_impl(self, input, errors);
exit: exit:
@ -66,14 +67,16 @@ _multibytecodec_MultibyteCodec_decode(MultibyteCodecObject *self, PyObject *args
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|z:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|z:decode", _keywords,
&input, &errors)) &input, &errors)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteCodec_decode_impl(self, &input, errors); return_value = _multibytecodec_MultibyteCodec_decode_impl(self, &input, errors);
exit: exit:
/* Cleanup for input */ /* Cleanup for input */
if (input.obj) if (input.obj) {
PyBuffer_Release(&input); PyBuffer_Release(&input);
}
return return_value; return return_value;
} }
@ -100,8 +103,9 @@ _multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderOb
int final = 0; int final = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:encode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:encode", _keywords,
&input, &final)) &input, &final)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final); return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final);
exit: exit:
@ -147,14 +151,16 @@ _multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderOb
int final = 0; int final = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i:decode", _keywords,
&input, &final)) &input, &final)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final); return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final);
exit: exit:
/* Cleanup for input */ /* Cleanup for input */
if (input.obj) if (input.obj) {
PyBuffer_Release(&input); PyBuffer_Release(&input);
}
return return_value; return return_value;
} }
@ -196,8 +202,9 @@ _multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject *self, Py
if (!PyArg_UnpackTuple(args, "read", if (!PyArg_UnpackTuple(args, "read",
0, 1, 0, 1,
&sizeobj)) &sizeobj)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj); return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj);
exit: exit:
@ -224,8 +231,9 @@ _multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject *self
if (!PyArg_UnpackTuple(args, "readline", if (!PyArg_UnpackTuple(args, "readline",
0, 1, 0, 1,
&sizeobj)) &sizeobj)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj); return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj);
exit: exit:
@ -252,8 +260,9 @@ _multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject *sel
if (!PyArg_UnpackTuple(args, "readlines", if (!PyArg_UnpackTuple(args, "readlines",
0, 1, 0, 1,
&sizehintobj)) &sizehintobj)) {
goto exit; goto exit;
}
return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj); return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj);
exit: exit:
@ -317,4 +326,4 @@ PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
#define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \ #define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
{"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__}, {"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
/*[clinic end generated code: output=eebb21e18c3043d1 input=a9049054013a1b77]*/ /*[clinic end generated code: output=f837bc56b2fa2a4e input=a9049054013a1b77]*/

26
Modules/clinic/_bz2module.c.h
View File

@ -25,14 +25,16 @@ _bz2_BZ2Compressor_compress(BZ2Compressor *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:compress", &data)) if (!PyArg_Parse(arg, "y*:compress", &data)) {
goto exit; goto exit;
}
return_value = _bz2_BZ2Compressor_compress_impl(self, &data); return_value = _bz2_BZ2Compressor_compress_impl(self, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -80,11 +82,13 @@ _bz2_BZ2Compressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
int compresslevel = 9; int compresslevel = 9;
if ((Py_TYPE(self) == &BZ2Compressor_Type) && if ((Py_TYPE(self) == &BZ2Compressor_Type) &&
!_PyArg_NoKeywords("BZ2Compressor", kwargs)) !_PyArg_NoKeywords("BZ2Compressor", kwargs)) {
goto exit; goto exit;
}
if (!PyArg_ParseTuple(args, "|i:BZ2Compressor", if (!PyArg_ParseTuple(args, "|i:BZ2Compressor",
&compresslevel)) &compresslevel)) {
goto exit; goto exit;
}
return_value = _bz2_BZ2Compressor___init___impl((BZ2Compressor *)self, compresslevel); return_value = _bz2_BZ2Compressor___init___impl((BZ2Compressor *)self, compresslevel);
exit: exit:
@ -126,14 +130,16 @@ _bz2_BZ2Decompressor_decompress(BZ2Decompressor *self, PyObject *args, PyObject
Py_ssize_t max_length = -1; Py_ssize_t max_length = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|n:decompress", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|n:decompress", _keywords,
&data, &max_length)) &data, &max_length)) {
goto exit; goto exit;
}
return_value = _bz2_BZ2Decompressor_decompress_impl(self, &data, max_length); return_value = _bz2_BZ2Decompressor_decompress_impl(self, &data, max_length);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -155,14 +161,16 @@ _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
int return_value = -1; int return_value = -1;
if ((Py_TYPE(self) == &BZ2Decompressor_Type) && if ((Py_TYPE(self) == &BZ2Decompressor_Type) &&
!_PyArg_NoPositional("BZ2Decompressor", args)) !_PyArg_NoPositional("BZ2Decompressor", args)) {
goto exit; goto exit;
}
if ((Py_TYPE(self) == &BZ2Decompressor_Type) && if ((Py_TYPE(self) == &BZ2Decompressor_Type) &&
!_PyArg_NoKeywords("BZ2Decompressor", kwargs)) !_PyArg_NoKeywords("BZ2Decompressor", kwargs)) {
goto exit; goto exit;
}
return_value = _bz2_BZ2Decompressor___init___impl((BZ2Decompressor *)self); return_value = _bz2_BZ2Decompressor___init___impl((BZ2Decompressor *)self);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=fef29b76b3314fc7 input=a9049054013a1b77]*/ /*[clinic end generated code: output=71be22f38224fe84 input=a9049054013a1b77]*/

191
Modules/clinic/_codecsmodule.c.h
View File

@ -33,8 +33,9 @@ _codecs_lookup(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *encoding; const char *encoding;
if (!PyArg_Parse(arg, "s:lookup", &encoding)) if (!PyArg_Parse(arg, "s:lookup", &encoding)) {
goto exit; goto exit;
}
return_value = _codecs_lookup_impl(module, encoding); return_value = _codecs_lookup_impl(module, encoding);
exit: exit:
@ -70,8 +71,9 @@ _codecs_encode(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:encode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:encode", _keywords,
&obj, &encoding, &errors)) &obj, &encoding, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_encode_impl(module, obj, encoding, errors); return_value = _codecs_encode_impl(module, obj, encoding, errors);
exit: exit:
@ -107,8 +109,9 @@ _codecs_decode(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:decode", _keywords,
&obj, &encoding, &errors)) &obj, &encoding, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_decode_impl(module, obj, encoding, errors); return_value = _codecs_decode_impl(module, obj, encoding, errors);
exit: exit:
@ -133,8 +136,9 @@ _codecs__forget_codec(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *encoding; const char *encoding;
if (!PyArg_Parse(arg, "s:_forget_codec", &encoding)) if (!PyArg_Parse(arg, "s:_forget_codec", &encoding)) {
goto exit; goto exit;
}
return_value = _codecs__forget_codec_impl(module, encoding); return_value = _codecs__forget_codec_impl(module, encoding);
exit: exit:
@ -161,14 +165,16 @@ _codecs_escape_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "s*|z:escape_decode", if (!PyArg_ParseTuple(args, "s*|z:escape_decode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_escape_decode_impl(module, &data, errors); return_value = _codecs_escape_decode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -193,8 +199,9 @@ _codecs_escape_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "O!|z:escape_encode", if (!PyArg_ParseTuple(args, "O!|z:escape_encode",
&PyBytes_Type, &data, &errors)) &PyBytes_Type, &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_escape_encode_impl(module, data, errors); return_value = _codecs_escape_encode_impl(module, data, errors);
exit: exit:
@ -221,8 +228,9 @@ _codecs_unicode_internal_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode", if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode",
&obj, &errors)) &obj, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_unicode_internal_decode_impl(module, obj, errors); return_value = _codecs_unicode_internal_decode_impl(module, obj, errors);
exit: exit:
@ -250,14 +258,16 @@ _codecs_utf_7_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_7_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_7_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_7_decode_impl(module, &data, errors, final); return_value = _codecs_utf_7_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -283,14 +293,16 @@ _codecs_utf_8_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_8_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_8_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_8_decode_impl(module, &data, errors, final); return_value = _codecs_utf_8_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -316,14 +328,16 @@ _codecs_utf_16_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_16_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_16_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_decode_impl(module, &data, errors, final); return_value = _codecs_utf_16_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -349,14 +363,16 @@ _codecs_utf_16_le_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_16_le_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_16_le_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_le_decode_impl(module, &data, errors, final); return_value = _codecs_utf_16_le_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -382,14 +398,16 @@ _codecs_utf_16_be_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_16_be_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_16_be_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_be_decode_impl(module, &data, errors, final); return_value = _codecs_utf_16_be_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -417,14 +435,16 @@ _codecs_utf_16_ex_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zii:utf_16_ex_decode", if (!PyArg_ParseTuple(args, "y*|zii:utf_16_ex_decode",
&data, &errors, &byteorder, &final)) &data, &errors, &byteorder, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_ex_decode_impl(module, &data, errors, byteorder, final); return_value = _codecs_utf_16_ex_decode_impl(module, &data, errors, byteorder, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -450,14 +470,16 @@ _codecs_utf_32_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_32_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_32_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_decode_impl(module, &data, errors, final); return_value = _codecs_utf_32_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -483,14 +505,16 @@ _codecs_utf_32_le_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_32_le_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_32_le_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_le_decode_impl(module, &data, errors, final); return_value = _codecs_utf_32_le_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -516,14 +540,16 @@ _codecs_utf_32_be_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:utf_32_be_decode", if (!PyArg_ParseTuple(args, "y*|zi:utf_32_be_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_be_decode_impl(module, &data, errors, final); return_value = _codecs_utf_32_be_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -551,14 +577,16 @@ _codecs_utf_32_ex_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zii:utf_32_ex_decode", if (!PyArg_ParseTuple(args, "y*|zii:utf_32_ex_decode",
&data, &errors, &byteorder, &final)) &data, &errors, &byteorder, &final)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_ex_decode_impl(module, &data, errors, byteorder, final); return_value = _codecs_utf_32_ex_decode_impl(module, &data, errors, byteorder, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -583,14 +611,16 @@ _codecs_unicode_escape_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "s*|z:unicode_escape_decode", if (!PyArg_ParseTuple(args, "s*|z:unicode_escape_decode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_unicode_escape_decode_impl(module, &data, errors); return_value = _codecs_unicode_escape_decode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -615,14 +645,16 @@ _codecs_raw_unicode_escape_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "s*|z:raw_unicode_escape_decode", if (!PyArg_ParseTuple(args, "s*|z:raw_unicode_escape_decode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_raw_unicode_escape_decode_impl(module, &data, errors); return_value = _codecs_raw_unicode_escape_decode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -647,14 +679,16 @@ _codecs_latin_1_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "y*|z:latin_1_decode", if (!PyArg_ParseTuple(args, "y*|z:latin_1_decode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_latin_1_decode_impl(module, &data, errors); return_value = _codecs_latin_1_decode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -679,14 +713,16 @@ _codecs_ascii_decode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "y*|z:ascii_decode", if (!PyArg_ParseTuple(args, "y*|z:ascii_decode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_ascii_decode_impl(module, &data, errors); return_value = _codecs_ascii_decode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -712,14 +748,16 @@ _codecs_charmap_decode(PyModuleDef *module, PyObject *args)
PyObject *mapping = NULL; PyObject *mapping = NULL;
if (!PyArg_ParseTuple(args, "y*|zO:charmap_decode", if (!PyArg_ParseTuple(args, "y*|zO:charmap_decode",
&data, &errors, &mapping)) &data, &errors, &mapping)) {
goto exit; goto exit;
}
return_value = _codecs_charmap_decode_impl(module, &data, errors, mapping); return_value = _codecs_charmap_decode_impl(module, &data, errors, mapping);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -747,14 +785,16 @@ _codecs_mbcs_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode", if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode",
&data, &errors, &final)) &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_mbcs_decode_impl(module, &data, errors, final); return_value = _codecs_mbcs_decode_impl(module, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -785,14 +825,16 @@ _codecs_code_page_decode(PyModuleDef *module, PyObject *args)
int final = 0; int final = 0;
if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode", if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode",
&codepage, &data, &errors, &final)) &codepage, &data, &errors, &final)) {
goto exit; goto exit;
}
return_value = _codecs_code_page_decode_impl(module, codepage, &data, errors, final); return_value = _codecs_code_page_decode_impl(module, codepage, &data, errors, final);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -819,14 +861,16 @@ _codecs_readbuffer_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "s*|z:readbuffer_encode", if (!PyArg_ParseTuple(args, "s*|z:readbuffer_encode",
&data, &errors)) &data, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_readbuffer_encode_impl(module, &data, errors); return_value = _codecs_readbuffer_encode_impl(module, &data, errors);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -851,8 +895,9 @@ _codecs_unicode_internal_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode", if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode",
&obj, &errors)) &obj, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_unicode_internal_encode_impl(module, obj, errors); return_value = _codecs_unicode_internal_encode_impl(module, obj, errors);
exit: exit:
@ -879,8 +924,9 @@ _codecs_utf_7_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_7_encode", if (!PyArg_ParseTuple(args, "U|z:utf_7_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_7_encode_impl(module, str, errors); return_value = _codecs_utf_7_encode_impl(module, str, errors);
exit: exit:
@ -907,8 +953,9 @@ _codecs_utf_8_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_8_encode", if (!PyArg_ParseTuple(args, "U|z:utf_8_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_8_encode_impl(module, str, errors); return_value = _codecs_utf_8_encode_impl(module, str, errors);
exit: exit:
@ -936,8 +983,9 @@ _codecs_utf_16_encode(PyModuleDef *module, PyObject *args)
int byteorder = 0; int byteorder = 0;
if (!PyArg_ParseTuple(args, "U|zi:utf_16_encode", if (!PyArg_ParseTuple(args, "U|zi:utf_16_encode",
&str, &errors, &byteorder)) &str, &errors, &byteorder)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_encode_impl(module, str, errors, byteorder); return_value = _codecs_utf_16_encode_impl(module, str, errors, byteorder);
exit: exit:
@ -964,8 +1012,9 @@ _codecs_utf_16_le_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_16_le_encode", if (!PyArg_ParseTuple(args, "U|z:utf_16_le_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_le_encode_impl(module, str, errors); return_value = _codecs_utf_16_le_encode_impl(module, str, errors);
exit: exit:
@ -992,8 +1041,9 @@ _codecs_utf_16_be_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_16_be_encode", if (!PyArg_ParseTuple(args, "U|z:utf_16_be_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_16_be_encode_impl(module, str, errors); return_value = _codecs_utf_16_be_encode_impl(module, str, errors);
exit: exit:
@ -1021,8 +1071,9 @@ _codecs_utf_32_encode(PyModuleDef *module, PyObject *args)
int byteorder = 0; int byteorder = 0;
if (!PyArg_ParseTuple(args, "U|zi:utf_32_encode", if (!PyArg_ParseTuple(args, "U|zi:utf_32_encode",
&str, &errors, &byteorder)) &str, &errors, &byteorder)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_encode_impl(module, str, errors, byteorder); return_value = _codecs_utf_32_encode_impl(module, str, errors, byteorder);
exit: exit:
@ -1049,8 +1100,9 @@ _codecs_utf_32_le_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_32_le_encode", if (!PyArg_ParseTuple(args, "U|z:utf_32_le_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_le_encode_impl(module, str, errors); return_value = _codecs_utf_32_le_encode_impl(module, str, errors);
exit: exit:
@ -1077,8 +1129,9 @@ _codecs_utf_32_be_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:utf_32_be_encode", if (!PyArg_ParseTuple(args, "U|z:utf_32_be_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_utf_32_be_encode_impl(module, str, errors); return_value = _codecs_utf_32_be_encode_impl(module, str, errors);
exit: exit:
@ -1105,8 +1158,9 @@ _codecs_unicode_escape_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:unicode_escape_encode", if (!PyArg_ParseTuple(args, "U|z:unicode_escape_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_unicode_escape_encode_impl(module, str, errors); return_value = _codecs_unicode_escape_encode_impl(module, str, errors);
exit: exit:
@ -1133,8 +1187,9 @@ _codecs_raw_unicode_escape_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:raw_unicode_escape_encode", if (!PyArg_ParseTuple(args, "U|z:raw_unicode_escape_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_raw_unicode_escape_encode_impl(module, str, errors); return_value = _codecs_raw_unicode_escape_encode_impl(module, str, errors);
exit: exit:
@ -1161,8 +1216,9 @@ _codecs_latin_1_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:latin_1_encode", if (!PyArg_ParseTuple(args, "U|z:latin_1_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_latin_1_encode_impl(module, str, errors); return_value = _codecs_latin_1_encode_impl(module, str, errors);
exit: exit:
@ -1189,8 +1245,9 @@ _codecs_ascii_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:ascii_encode", if (!PyArg_ParseTuple(args, "U|z:ascii_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_ascii_encode_impl(module, str, errors); return_value = _codecs_ascii_encode_impl(module, str, errors);
exit: exit:
@ -1218,8 +1275,9 @@ _codecs_charmap_encode(PyModuleDef *module, PyObject *args)
PyObject *mapping = NULL; PyObject *mapping = NULL;
if (!PyArg_ParseTuple(args, "U|zO:charmap_encode", if (!PyArg_ParseTuple(args, "U|zO:charmap_encode",
&str, &errors, &mapping)) &str, &errors, &mapping)) {
goto exit; goto exit;
}
return_value = _codecs_charmap_encode_impl(module, str, errors, mapping); return_value = _codecs_charmap_encode_impl(module, str, errors, mapping);
exit: exit:
@ -1243,8 +1301,9 @@ _codecs_charmap_build(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *map; PyObject *map;
if (!PyArg_Parse(arg, "U:charmap_build", &map)) if (!PyArg_Parse(arg, "U:charmap_build", &map)) {
goto exit; goto exit;
}
return_value = _codecs_charmap_build_impl(module, map); return_value = _codecs_charmap_build_impl(module, map);
exit: exit:
@ -1273,8 +1332,9 @@ _codecs_mbcs_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "U|z:mbcs_encode", if (!PyArg_ParseTuple(args, "U|z:mbcs_encode",
&str, &errors)) &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_mbcs_encode_impl(module, str, errors); return_value = _codecs_mbcs_encode_impl(module, str, errors);
exit: exit:
@ -1306,8 +1366,9 @@ _codecs_code_page_encode(PyModuleDef *module, PyObject *args)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTuple(args, "iU|z:code_page_encode", if (!PyArg_ParseTuple(args, "iU|z:code_page_encode",
&code_page, &str, &errors)) &code_page, &str, &errors)) {
goto exit; goto exit;
}
return_value = _codecs_code_page_encode_impl(module, code_page, str, errors); return_value = _codecs_code_page_encode_impl(module, code_page, str, errors);
exit: exit:
@ -1341,8 +1402,9 @@ _codecs_register_error(PyModuleDef *module, PyObject *args)
PyObject *handler; PyObject *handler;
if (!PyArg_ParseTuple(args, "sO:register_error", if (!PyArg_ParseTuple(args, "sO:register_error",
&errors, &handler)) &errors, &handler)) {
goto exit; goto exit;
}
return_value = _codecs_register_error_impl(module, errors, handler); return_value = _codecs_register_error_impl(module, errors, handler);
exit: exit:
@ -1370,8 +1432,9 @@ _codecs_lookup_error(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *name; const char *name;
if (!PyArg_Parse(arg, "s:lookup_error", &name)) if (!PyArg_Parse(arg, "s:lookup_error", &name)) {
goto exit; goto exit;
}
return_value = _codecs_lookup_error_impl(module, name); return_value = _codecs_lookup_error_impl(module, name);
exit: exit:
@ -1393,4 +1456,4 @@ exit:
#ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
#define _CODECS_CODE_PAGE_ENCODE_METHODDEF #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
#endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */ #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
/*[clinic end generated code: output=04007a13c8387689 input=a9049054013a1b77]*/ /*[clinic end generated code: output=120320fe2ac32085 input=a9049054013a1b77]*/

5
Modules/clinic/_cryptmodule.c.h
View File

@ -27,11 +27,12 @@ crypt_crypt(PyModuleDef *module, PyObject *args)
const char *salt; const char *salt;
if (!PyArg_ParseTuple(args, "ss:crypt", if (!PyArg_ParseTuple(args, "ss:crypt",
&word, &salt)) &word, &salt)) {
goto exit; goto exit;
}
return_value = crypt_crypt_impl(module, word, salt); return_value = crypt_crypt_impl(module, word, salt);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=22c295c9bce018c4 input=a9049054013a1b77]*/ /*[clinic end generated code: output=6977cf9917d9a684 input=a9049054013a1b77]*/

14
Modules/clinic/_cursesmodule.c.h
View File

@ -40,22 +40,26 @@ curses_window_addch(PyCursesWindowObject *self, PyObject *args)
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 1: case 1:
if (!PyArg_ParseTuple(args, "O:addch", &ch)) if (!PyArg_ParseTuple(args, "O:addch", &ch)) {
goto exit; goto exit;
}
break; break;
case 2: case 2:
if (!PyArg_ParseTuple(args, "Ol:addch", &ch, &attr)) if (!PyArg_ParseTuple(args, "Ol:addch", &ch, &attr)) {
goto exit; goto exit;
}
group_right_1 = 1; group_right_1 = 1;
break; break;
case 3: case 3:
if (!PyArg_ParseTuple(args, "iiO:addch", &y, &x, &ch)) if (!PyArg_ParseTuple(args, "iiO:addch", &y, &x, &ch)) {
goto exit; goto exit;
}
group_left_1 = 1; group_left_1 = 1;
break; break;
case 4: case 4:
if (!PyArg_ParseTuple(args, "iiOl:addch", &y, &x, &ch, &attr)) if (!PyArg_ParseTuple(args, "iiOl:addch", &y, &x, &ch, &attr)) {
goto exit; goto exit;
}
group_right_1 = 1; group_right_1 = 1;
group_left_1 = 1; group_left_1 = 1;
break; break;
@ -68,4 +72,4 @@ curses_window_addch(PyCursesWindowObject *self, PyObject *args)
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=982b1e709577f3ec input=a9049054013a1b77]*/ /*[clinic end generated code: output=13ffc5f8d79cbfbf input=a9049054013a1b77]*/

5
Modules/clinic/_datetimemodule.c.h
View File

@ -27,11 +27,12 @@ datetime_datetime_now(PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyObject *tz = Py_None; PyObject *tz = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:now", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:now", _keywords,
&tz)) &tz)) {
goto exit; goto exit;
}
return_value = datetime_datetime_now_impl(type, tz); return_value = datetime_datetime_now_impl(type, tz);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=7f45c670d6e4953a input=a9049054013a1b77]*/ /*[clinic end generated code: output=a82e6bd057a5dab9 input=a9049054013a1b77]*/

11
Modules/clinic/_dbmmodule.c.h
View File

@ -60,8 +60,9 @@ _dbm_dbm_get(dbmobject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "s#|O:get", if (!PyArg_ParseTuple(args, "s#|O:get",
&key, &key_length, &default_value)) &key, &key_length, &default_value)) {
goto exit; goto exit;
}
return_value = _dbm_dbm_get_impl(self, key, key_length, default_value); return_value = _dbm_dbm_get_impl(self, key, key_length, default_value);
exit: exit:
@ -93,8 +94,9 @@ _dbm_dbm_setdefault(dbmobject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "s#|O:setdefault", if (!PyArg_ParseTuple(args, "s#|O:setdefault",
&key, &key_length, &default_value)) &key, &key_length, &default_value)) {
goto exit; goto exit;
}
return_value = _dbm_dbm_setdefault_impl(self, key, key_length, default_value); return_value = _dbm_dbm_setdefault_impl(self, key, key_length, default_value);
exit: exit:
@ -131,11 +133,12 @@ dbmopen(PyModuleDef *module, PyObject *args)
int mode = 438; int mode = 438;
if (!PyArg_ParseTuple(args, "s|si:open", if (!PyArg_ParseTuple(args, "s|si:open",
&filename, &flags, &mode)) &filename, &flags, &mode)) {
goto exit; goto exit;
}
return_value = dbmopen_impl(module, filename, flags, mode); return_value = dbmopen_impl(module, filename, flags, mode);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=1d92e81b28c558d0 input=a9049054013a1b77]*/ /*[clinic end generated code: output=97f8b6f542973b71 input=a9049054013a1b77]*/

53
Modules/clinic/_elementtree.c.h
View File

@ -19,8 +19,9 @@ _elementtree_Element_append(ElementObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *subelement; PyObject *subelement;
if (!PyArg_Parse(arg, "O!:append", &Element_Type, &subelement)) if (!PyArg_Parse(arg, "O!:append", &Element_Type, &subelement)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_append_impl(self, subelement); return_value = _elementtree_Element_append_impl(self, subelement);
exit: exit:
@ -87,8 +88,9 @@ _elementtree_Element___sizeof__(ElementObject *self, PyObject *Py_UNUSED(ignored
Py_ssize_t _return_value; Py_ssize_t _return_value;
_return_value = _elementtree_Element___sizeof___impl(self); _return_value = _elementtree_Element___sizeof___impl(self);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
@ -149,8 +151,9 @@ _elementtree_Element_find(ElementObject *self, PyObject *args, PyObject *kwargs)
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:find", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:find", _keywords,
&path, &namespaces)) &path, &namespaces)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_find_impl(self, path, namespaces); return_value = _elementtree_Element_find_impl(self, path, namespaces);
exit: exit:
@ -180,8 +183,9 @@ _elementtree_Element_findtext(ElementObject *self, PyObject *args, PyObject *kwa
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:findtext", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:findtext", _keywords,
&path, &default_value, &namespaces)) &path, &default_value, &namespaces)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces); return_value = _elementtree_Element_findtext_impl(self, path, default_value, namespaces);
exit: exit:
@ -209,8 +213,9 @@ _elementtree_Element_findall(ElementObject *self, PyObject *args, PyObject *kwar
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:findall", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:findall", _keywords,
&path, &namespaces)) &path, &namespaces)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_findall_impl(self, path, namespaces); return_value = _elementtree_Element_findall_impl(self, path, namespaces);
exit: exit:
@ -238,8 +243,9 @@ _elementtree_Element_iterfind(ElementObject *self, PyObject *args, PyObject *kwa
PyObject *namespaces = Py_None; PyObject *namespaces = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:iterfind", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:iterfind", _keywords,
&path, &namespaces)) &path, &namespaces)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_iterfind_impl(self, path, namespaces); return_value = _elementtree_Element_iterfind_impl(self, path, namespaces);
exit: exit:
@ -267,8 +273,9 @@ _elementtree_Element_get(ElementObject *self, PyObject *args, PyObject *kwargs)
PyObject *default_value = Py_None; PyObject *default_value = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:get", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:get", _keywords,
&key, &default_value)) &key, &default_value)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_get_impl(self, key, default_value); return_value = _elementtree_Element_get_impl(self, key, default_value);
exit: exit:
@ -311,8 +318,9 @@ _elementtree_Element_iter(ElementObject *self, PyObject *args, PyObject *kwargs)
PyObject *tag = Py_None; PyObject *tag = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:iter", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:iter", _keywords,
&tag)) &tag)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_iter_impl(self, tag); return_value = _elementtree_Element_iter_impl(self, tag);
exit: exit:
@ -356,8 +364,9 @@ _elementtree_Element_insert(ElementObject *self, PyObject *args)
PyObject *subelement; PyObject *subelement;
if (!PyArg_ParseTuple(args, "nO!:insert", if (!PyArg_ParseTuple(args, "nO!:insert",
&index, &Element_Type, &subelement)) &index, &Element_Type, &subelement)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_insert_impl(self, index, subelement); return_value = _elementtree_Element_insert_impl(self, index, subelement);
exit: exit:
@ -419,8 +428,9 @@ _elementtree_Element_makeelement(ElementObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "makeelement", if (!PyArg_UnpackTuple(args, "makeelement",
2, 2, 2, 2,
&tag, &attrib)) &tag, &attrib)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_makeelement_impl(self, tag, attrib); return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
exit: exit:
@ -444,8 +454,9 @@ _elementtree_Element_remove(ElementObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *subelement; PyObject *subelement;
if (!PyArg_Parse(arg, "O!:remove", &Element_Type, &subelement)) if (!PyArg_Parse(arg, "O!:remove", &Element_Type, &subelement)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_remove_impl(self, subelement); return_value = _elementtree_Element_remove_impl(self, subelement);
exit: exit:
@ -473,8 +484,9 @@ _elementtree_Element_set(ElementObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "set", if (!PyArg_UnpackTuple(args, "set",
2, 2, 2, 2,
&key, &value)) &key, &value)) {
goto exit; goto exit;
}
return_value = _elementtree_Element_set_impl(self, key, value); return_value = _elementtree_Element_set_impl(self, key, value);
exit: exit:
@ -493,8 +505,9 @@ _elementtree_TreeBuilder___init__(PyObject *self, PyObject *args, PyObject *kwar
PyObject *element_factory = NULL; PyObject *element_factory = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:TreeBuilder", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:TreeBuilder", _keywords,
&element_factory)) &element_factory)) {
goto exit; goto exit;
}
return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory); return_value = _elementtree_TreeBuilder___init___impl((TreeBuilderObject *)self, element_factory);
exit: exit:
@ -555,8 +568,9 @@ _elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "start", if (!PyArg_UnpackTuple(args, "start",
1, 2, 1, 2,
&tag, &attrs)) &tag, &attrs)) {
goto exit; goto exit;
}
return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs); return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);
exit: exit:
@ -577,8 +591,9 @@ _elementtree_XMLParser___init__(PyObject *self, PyObject *args, PyObject *kwargs
const char *encoding = NULL; const char *encoding = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOz:XMLParser", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOz:XMLParser", _keywords,
&html, &target, &encoding)) &html, &target, &encoding)) {
goto exit; goto exit;
}
return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, html, target, encoding); return_value = _elementtree_XMLParser___init___impl((XMLParserObject *)self, html, target, encoding);
exit: exit:
@ -640,8 +655,9 @@ _elementtree_XMLParser_doctype(XMLParserObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "doctype", if (!PyArg_UnpackTuple(args, "doctype",
3, 3, 3, 3,
&name, &pubid, &system)) &name, &pubid, &system)) {
goto exit; goto exit;
}
return_value = _elementtree_XMLParser_doctype_impl(self, name, pubid, system); return_value = _elementtree_XMLParser_doctype_impl(self, name, pubid, system);
exit: exit:
@ -670,11 +686,12 @@ _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "_setevents", if (!PyArg_UnpackTuple(args, "_setevents",
1, 2, 1, 2,
&events_queue, &events_to_report)) &events_queue, &events_to_report)) {
goto exit; goto exit;
}
return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report); return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=19d94e2d2726d3aa input=a9049054013a1b77]*/ /*[clinic end generated code: output=491eb5718c1ae64b input=a9049054013a1b77]*/

14
Modules/clinic/_gdbmmodule.c.h
View File

@ -23,8 +23,9 @@ _gdbm_gdbm_get(dbmobject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "get", if (!PyArg_UnpackTuple(args, "get",
1, 2, 1, 2,
&key, &default_value)) &key, &default_value)) {
goto exit; goto exit;
}
return_value = _gdbm_gdbm_get_impl(self, key, default_value); return_value = _gdbm_gdbm_get_impl(self, key, default_value);
exit: exit:
@ -53,8 +54,9 @@ _gdbm_gdbm_setdefault(dbmobject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "setdefault", if (!PyArg_UnpackTuple(args, "setdefault",
1, 2, 1, 2,
&key, &default_value)) &key, &default_value)) {
goto exit; goto exit;
}
return_value = _gdbm_gdbm_setdefault_impl(self, key, default_value); return_value = _gdbm_gdbm_setdefault_impl(self, key, default_value);
exit: exit:
@ -147,8 +149,9 @@ _gdbm_gdbm_nextkey(dbmobject *self, PyObject *arg)
const char *key; const char *key;
Py_ssize_clean_t key_length; Py_ssize_clean_t key_length;
if (!PyArg_Parse(arg, "s#:nextkey", &key, &key_length)) if (!PyArg_Parse(arg, "s#:nextkey", &key, &key_length)) {
goto exit; goto exit;
}
return_value = _gdbm_gdbm_nextkey_impl(self, key, key_length); return_value = _gdbm_gdbm_nextkey_impl(self, key, key_length);
exit: exit:
@ -243,11 +246,12 @@ dbmopen(PyModuleDef *module, PyObject *args)
int mode = 438; int mode = 438;
if (!PyArg_ParseTuple(args, "s|si:open", if (!PyArg_ParseTuple(args, "s|si:open",
&name, &flags, &mode)) &name, &flags, &mode)) {
goto exit; goto exit;
}
return_value = dbmopen_impl(module, name, flags, mode); return_value = dbmopen_impl(module, name, flags, mode);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=d3d8d871bcccb68a input=a9049054013a1b77]*/ /*[clinic end generated code: output=418849fb5dbe69a5 input=a9049054013a1b77]*/

29
Modules/clinic/_lzmamodule.c.h
View File

@ -25,14 +25,16 @@ _lzma_LZMACompressor_compress(Compressor *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:compress", &data)) if (!PyArg_Parse(arg, "y*:compress", &data)) {
goto exit; goto exit;
}
return_value = _lzma_LZMACompressor_compress_impl(self, &data); return_value = _lzma_LZMACompressor_compress_impl(self, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -94,14 +96,16 @@ _lzma_LZMADecompressor_decompress(Decompressor *self, PyObject *args, PyObject *
Py_ssize_t max_length = -1; Py_ssize_t max_length = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|n:decompress", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|n:decompress", _keywords,
&data, &max_length)) &data, &max_length)) {
goto exit; goto exit;
}
return_value = _lzma_LZMADecompressor_decompress_impl(self, &data, max_length); return_value = _lzma_LZMADecompressor_decompress_impl(self, &data, max_length);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -143,8 +147,9 @@ _lzma_LZMADecompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs
PyObject *filters = Py_None; PyObject *filters = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iOO:LZMADecompressor", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iOO:LZMADecompressor", _keywords,
&format, &memlimit, &filters)) &format, &memlimit, &filters)) {
goto exit; goto exit;
}
return_value = _lzma_LZMADecompressor___init___impl((Decompressor *)self, format, memlimit, filters); return_value = _lzma_LZMADecompressor___init___impl((Decompressor *)self, format, memlimit, filters);
exit: exit:
@ -171,8 +176,9 @@ _lzma_is_check_supported(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int check_id; int check_id;
if (!PyArg_Parse(arg, "i:is_check_supported", &check_id)) if (!PyArg_Parse(arg, "i:is_check_supported", &check_id)) {
goto exit; goto exit;
}
return_value = _lzma_is_check_supported_impl(module, check_id); return_value = _lzma_is_check_supported_impl(module, check_id);
exit: exit:
@ -199,8 +205,9 @@ _lzma__encode_filter_properties(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
lzma_filter filter = {LZMA_VLI_UNKNOWN, NULL}; lzma_filter filter = {LZMA_VLI_UNKNOWN, NULL};
if (!PyArg_Parse(arg, "O&:_encode_filter_properties", lzma_filter_converter, &filter)) if (!PyArg_Parse(arg, "O&:_encode_filter_properties", lzma_filter_converter, &filter)) {
goto exit; goto exit;
}
return_value = _lzma__encode_filter_properties_impl(module, filter); return_value = _lzma__encode_filter_properties_impl(module, filter);
exit: exit:
@ -234,15 +241,17 @@ _lzma__decode_filter_properties(PyModuleDef *module, PyObject *args)
Py_buffer encoded_props = {NULL, NULL}; Py_buffer encoded_props = {NULL, NULL};
if (!PyArg_ParseTuple(args, "O&y*:_decode_filter_properties", if (!PyArg_ParseTuple(args, "O&y*:_decode_filter_properties",
lzma_vli_converter, &filter_id, &encoded_props)) lzma_vli_converter, &filter_id, &encoded_props)) {
goto exit; goto exit;
}
return_value = _lzma__decode_filter_properties_impl(module, filter_id, &encoded_props); return_value = _lzma__decode_filter_properties_impl(module, filter_id, &encoded_props);
exit: exit:
/* Cleanup for encoded_props */ /* Cleanup for encoded_props */
if (encoded_props.obj) if (encoded_props.obj) {
PyBuffer_Release(&encoded_props); PyBuffer_Release(&encoded_props);
}
return return_value; return return_value;
} }
/*[clinic end generated code: output=2d3e0842be3d3fe1 input=a9049054013a1b77]*/ /*[clinic end generated code: output=804aed7d196ba52e input=a9049054013a1b77]*/

8
Modules/clinic/_opcode.c.h
View File

@ -23,14 +23,16 @@ _opcode_stack_effect(PyModuleDef *module, PyObject *args)
int _return_value; int _return_value;
if (!PyArg_ParseTuple(args, "i|O:stack_effect", if (!PyArg_ParseTuple(args, "i|O:stack_effect",
&opcode, &oparg)) &opcode, &oparg)) {
goto exit; goto exit;
}
_return_value = _opcode_stack_effect_impl(module, opcode, oparg); _return_value = _opcode_stack_effect_impl(module, opcode, oparg);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=8ee7cb735705e8b3 input=a9049054013a1b77]*/ /*[clinic end generated code: output=5bd7c1c113e6526a input=a9049054013a1b77]*/

29
Modules/clinic/_pickle.c.h
View File

@ -53,8 +53,9 @@ _pickle_Pickler___sizeof__(PicklerObject *self, PyObject *Py_UNUSED(ignored))
Py_ssize_t _return_value; Py_ssize_t _return_value;
_return_value = _pickle_Pickler___sizeof___impl(self); _return_value = _pickle_Pickler___sizeof___impl(self);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
@ -98,8 +99,9 @@ _pickle_Pickler___init__(PyObject *self, PyObject *args, PyObject *kwargs)
int fix_imports = 1; int fix_imports = 1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Op:Pickler", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Op:Pickler", _keywords,
&file, &protocol, &fix_imports)) &file, &protocol, &fix_imports)) {
goto exit; goto exit;
}
return_value = _pickle_Pickler___init___impl((PicklerObject *)self, file, protocol, fix_imports); return_value = _pickle_Pickler___init___impl((PicklerObject *)self, file, protocol, fix_imports);
exit: exit:
@ -212,8 +214,9 @@ _pickle_Unpickler_find_class(UnpicklerObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "find_class", if (!PyArg_UnpackTuple(args, "find_class",
2, 2, 2, 2,
&module_name, &global_name)) &module_name, &global_name)) {
goto exit; goto exit;
}
return_value = _pickle_Unpickler_find_class_impl(self, module_name, global_name); return_value = _pickle_Unpickler_find_class_impl(self, module_name, global_name);
exit: exit:
@ -239,8 +242,9 @@ _pickle_Unpickler___sizeof__(UnpicklerObject *self, PyObject *Py_UNUSED(ignored)
Py_ssize_t _return_value; Py_ssize_t _return_value;
_return_value = _pickle_Unpickler___sizeof___impl(self); _return_value = _pickle_Unpickler___sizeof___impl(self);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
@ -288,8 +292,9 @@ _pickle_Unpickler___init__(PyObject *self, PyObject *args, PyObject *kwargs)
const char *errors = "strict"; const char *errors = "strict";
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:Unpickler", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:Unpickler", _keywords,
&file, &fix_imports, &encoding, &errors)) &file, &fix_imports, &encoding, &errors)) {
goto exit; goto exit;
}
return_value = _pickle_Unpickler___init___impl((UnpicklerObject *)self, file, fix_imports, encoding, errors); return_value = _pickle_Unpickler___init___impl((UnpicklerObject *)self, file, fix_imports, encoding, errors);
exit: exit:
@ -394,8 +399,9 @@ _pickle_dump(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int fix_imports = 1; int fix_imports = 1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O$p:dump", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O$p:dump", _keywords,
&obj, &file, &protocol, &fix_imports)) &obj, &file, &protocol, &fix_imports)) {
goto exit; goto exit;
}
return_value = _pickle_dump_impl(module, obj, file, protocol, fix_imports); return_value = _pickle_dump_impl(module, obj, file, protocol, fix_imports);
exit: exit:
@ -437,8 +443,9 @@ _pickle_dumps(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int fix_imports = 1; int fix_imports = 1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O$p:dumps", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O$p:dumps", _keywords,
&obj, &protocol, &fix_imports)) &obj, &protocol, &fix_imports)) {
goto exit; goto exit;
}
return_value = _pickle_dumps_impl(module, obj, protocol, fix_imports); return_value = _pickle_dumps_impl(module, obj, protocol, fix_imports);
exit: exit:
@ -492,8 +499,9 @@ _pickle_load(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *errors = "strict"; const char *errors = "strict";
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:load", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:load", _keywords,
&file, &fix_imports, &encoding, &errors)) &file, &fix_imports, &encoding, &errors)) {
goto exit; goto exit;
}
return_value = _pickle_load_impl(module, file, fix_imports, encoding, errors); return_value = _pickle_load_impl(module, file, fix_imports, encoding, errors);
exit: exit:
@ -538,11 +546,12 @@ _pickle_loads(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *errors = "strict"; const char *errors = "strict";
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:loads", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|$pss:loads", _keywords,
&data, &fix_imports, &encoding, &errors)) &data, &fix_imports, &encoding, &errors)) {
goto exit; goto exit;
}
return_value = _pickle_loads_impl(module, data, fix_imports, encoding, errors); return_value = _pickle_loads_impl(module, data, fix_imports, encoding, errors);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=a7169d4fbbeef827 input=a9049054013a1b77]*/ /*[clinic end generated code: output=5e972f339d197760 input=a9049054013a1b77]*/

71
Modules/clinic/_sre.c.h
View File

@ -20,8 +20,9 @@ _sre_getcodesize(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
int _return_value; int _return_value;
_return_value = _sre_getcodesize_impl(module); _return_value = _sre_getcodesize_impl(module);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -48,11 +49,13 @@ _sre_getlower(PyModuleDef *module, PyObject *args)
int _return_value; int _return_value;
if (!PyArg_ParseTuple(args, "ii:getlower", if (!PyArg_ParseTuple(args, "ii:getlower",
&character, &flags)) &character, &flags)) {
goto exit; goto exit;
}
_return_value = _sre_getlower_impl(module, character, flags); _return_value = _sre_getlower_impl(module, character, flags);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -84,8 +87,9 @@ _sre_SRE_Pattern_match(PatternObject *self, PyObject *args, PyObject *kwargs)
PyObject *pattern = NULL; PyObject *pattern = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:match", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:match", _keywords,
&string, &pos, &endpos, &pattern)) &string, &pos, &endpos, &pattern)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_match_impl(self, string, pos, endpos, pattern); return_value = _sre_SRE_Pattern_match_impl(self, string, pos, endpos, pattern);
exit: exit:
@ -118,8 +122,9 @@ _sre_SRE_Pattern_fullmatch(PatternObject *self, PyObject *args, PyObject *kwargs
PyObject *pattern = NULL; PyObject *pattern = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:fullmatch", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:fullmatch", _keywords,
&string, &pos, &endpos, &pattern)) &string, &pos, &endpos, &pattern)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_fullmatch_impl(self, string, pos, endpos, pattern); return_value = _sre_SRE_Pattern_fullmatch_impl(self, string, pos, endpos, pattern);
exit: exit:
@ -154,8 +159,9 @@ _sre_SRE_Pattern_search(PatternObject *self, PyObject *args, PyObject *kwargs)
PyObject *pattern = NULL; PyObject *pattern = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:search", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:search", _keywords,
&string, &pos, &endpos, &pattern)) &string, &pos, &endpos, &pattern)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_search_impl(self, string, pos, endpos, pattern); return_value = _sre_SRE_Pattern_search_impl(self, string, pos, endpos, pattern);
exit: exit:
@ -188,8 +194,9 @@ _sre_SRE_Pattern_findall(PatternObject *self, PyObject *args, PyObject *kwargs)
PyObject *source = NULL; PyObject *source = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:findall", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Onn$O:findall", _keywords,
&string, &pos, &endpos, &source)) &string, &pos, &endpos, &source)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_findall_impl(self, string, pos, endpos, source); return_value = _sre_SRE_Pattern_findall_impl(self, string, pos, endpos, source);
exit: exit:
@ -221,8 +228,9 @@ _sre_SRE_Pattern_finditer(PatternObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t endpos = PY_SSIZE_T_MAX; Py_ssize_t endpos = PY_SSIZE_T_MAX;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|nn:finditer", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|nn:finditer", _keywords,
&string, &pos, &endpos)) &string, &pos, &endpos)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_finditer_impl(self, string, pos, endpos); return_value = _sre_SRE_Pattern_finditer_impl(self, string, pos, endpos);
exit: exit:
@ -251,8 +259,9 @@ _sre_SRE_Pattern_scanner(PatternObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t endpos = PY_SSIZE_T_MAX; Py_ssize_t endpos = PY_SSIZE_T_MAX;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|nn:scanner", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|nn:scanner", _keywords,
&string, &pos, &endpos)) &string, &pos, &endpos)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_scanner_impl(self, string, pos, endpos); return_value = _sre_SRE_Pattern_scanner_impl(self, string, pos, endpos);
exit: exit:
@ -282,8 +291,9 @@ _sre_SRE_Pattern_split(PatternObject *self, PyObject *args, PyObject *kwargs)
PyObject *source = NULL; PyObject *source = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On$O:split", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On$O:split", _keywords,
&string, &maxsplit, &source)) &string, &maxsplit, &source)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_split_impl(self, string, maxsplit, source); return_value = _sre_SRE_Pattern_split_impl(self, string, maxsplit, source);
exit: exit:
@ -313,8 +323,9 @@ _sre_SRE_Pattern_sub(PatternObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t count = 0; Py_ssize_t count = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|n:sub", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|n:sub", _keywords,
&repl, &string, &count)) &repl, &string, &count)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_sub_impl(self, repl, string, count); return_value = _sre_SRE_Pattern_sub_impl(self, repl, string, count);
exit: exit:
@ -344,8 +355,9 @@ _sre_SRE_Pattern_subn(PatternObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t count = 0; Py_ssize_t count = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|n:subn", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|n:subn", _keywords,
&repl, &string, &count)) &repl, &string, &count)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern_subn_impl(self, repl, string, count); return_value = _sre_SRE_Pattern_subn_impl(self, repl, string, count);
exit: exit:
@ -388,8 +400,9 @@ _sre_SRE_Pattern___deepcopy__(PatternObject *self, PyObject *args, PyObject *kwa
PyObject *memo; PyObject *memo;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:__deepcopy__", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:__deepcopy__", _keywords,
&memo)) &memo)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Pattern___deepcopy___impl(self, memo); return_value = _sre_SRE_Pattern___deepcopy___impl(self, memo);
exit: exit:
@ -423,8 +436,9 @@ _sre_compile(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *indexgroup; PyObject *indexgroup;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO!nOO:compile", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO!nOO:compile", _keywords,
&pattern, &flags, &PyList_Type, &code, &groups, &groupindex, &indexgroup)) &pattern, &flags, &PyList_Type, &code, &groups, &groupindex, &indexgroup)) {
goto exit; goto exit;
}
return_value = _sre_compile_impl(module, pattern, flags, code, groups, groupindex, indexgroup); return_value = _sre_compile_impl(module, pattern, flags, code, groups, groupindex, indexgroup);
exit: exit:
@ -451,8 +465,9 @@ _sre_SRE_Match_expand(MatchObject *self, PyObject *args, PyObject *kwargs)
PyObject *template; PyObject *template;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:expand", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:expand", _keywords,
&template)) &template)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Match_expand_impl(self, template); return_value = _sre_SRE_Match_expand_impl(self, template);
exit: exit:
@ -482,8 +497,9 @@ _sre_SRE_Match_groups(MatchObject *self, PyObject *args, PyObject *kwargs)
PyObject *default_value = Py_None; PyObject *default_value = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:groups", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:groups", _keywords,
&default_value)) &default_value)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Match_groups_impl(self, default_value); return_value = _sre_SRE_Match_groups_impl(self, default_value);
exit: exit:
@ -513,8 +529,9 @@ _sre_SRE_Match_groupdict(MatchObject *self, PyObject *args, PyObject *kwargs)
PyObject *default_value = Py_None; PyObject *default_value = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:groupdict", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:groupdict", _keywords,
&default_value)) &default_value)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Match_groupdict_impl(self, default_value); return_value = _sre_SRE_Match_groupdict_impl(self, default_value);
exit: exit:
@ -542,11 +559,13 @@ _sre_SRE_Match_start(MatchObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "start", if (!PyArg_UnpackTuple(args, "start",
0, 1, 0, 1,
&group)) &group)) {
goto exit; goto exit;
}
_return_value = _sre_SRE_Match_start_impl(self, group); _return_value = _sre_SRE_Match_start_impl(self, group);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
@ -574,11 +593,13 @@ _sre_SRE_Match_end(MatchObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "end", if (!PyArg_UnpackTuple(args, "end",
0, 1, 0, 1,
&group)) &group)) {
goto exit; goto exit;
}
_return_value = _sre_SRE_Match_end_impl(self, group); _return_value = _sre_SRE_Match_end_impl(self, group);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
@ -605,8 +626,9 @@ _sre_SRE_Match_span(MatchObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "span", if (!PyArg_UnpackTuple(args, "span",
0, 1, 0, 1,
&group)) &group)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Match_span_impl(self, group); return_value = _sre_SRE_Match_span_impl(self, group);
exit: exit:
@ -649,8 +671,9 @@ _sre_SRE_Match___deepcopy__(MatchObject *self, PyObject *args, PyObject *kwargs)
PyObject *memo; PyObject *memo;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:__deepcopy__", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:__deepcopy__", _keywords,
&memo)) &memo)) {
goto exit; goto exit;
}
return_value = _sre_SRE_Match___deepcopy___impl(self, memo); return_value = _sre_SRE_Match___deepcopy___impl(self, memo);
exit: exit:
@ -690,4 +713,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
{ {
return _sre_SRE_Scanner_search_impl(self); return _sre_SRE_Scanner_search_impl(self);
} }
/*[clinic end generated code: output=d1d73ab2c5008bd4 input=a9049054013a1b77]*/ /*[clinic end generated code: output=00f7bf869b3283bc input=a9049054013a1b77]*/

101
Modules/clinic/_ssl.c.h
View File

@ -36,8 +36,9 @@ _ssl__test_decode_cert(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *path; PyObject *path;
if (!PyArg_Parse(arg, "O&:_test_decode_cert", PyUnicode_FSConverter, &path)) if (!PyArg_Parse(arg, "O&:_test_decode_cert", PyUnicode_FSConverter, &path)) {
goto exit; goto exit;
}
return_value = _ssl__test_decode_cert_impl(module, path); return_value = _ssl__test_decode_cert_impl(module, path);
exit: exit:
@ -71,8 +72,9 @@ _ssl__SSLSocket_peer_certificate(PySSLSocket *self, PyObject *args)
int binary_mode = 0; int binary_mode = 0;
if (!PyArg_ParseTuple(args, "|p:peer_certificate", if (!PyArg_ParseTuple(args, "|p:peer_certificate",
&binary_mode)) &binary_mode)) {
goto exit; goto exit;
}
return_value = _ssl__SSLSocket_peer_certificate_impl(self, binary_mode); return_value = _ssl__SSLSocket_peer_certificate_impl(self, binary_mode);
exit: exit:
@ -209,14 +211,16 @@ _ssl__SSLSocket_write(PySSLSocket *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer b = {NULL, NULL}; Py_buffer b = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:write", &b)) if (!PyArg_Parse(arg, "y*:write", &b)) {
goto exit; goto exit;
}
return_value = _ssl__SSLSocket_write_impl(self, &b); return_value = _ssl__SSLSocket_write_impl(self, &b);
exit: exit:
/* Cleanup for b */ /* Cleanup for b */
if (b.obj) if (b.obj) {
PyBuffer_Release(&b); PyBuffer_Release(&b);
}
return return_value; return return_value;
} }
@ -260,12 +264,14 @@ _ssl__SSLSocket_read(PySSLSocket *self, PyObject *args)
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 1: case 1:
if (!PyArg_ParseTuple(args, "i:read", &len)) if (!PyArg_ParseTuple(args, "i:read", &len)) {
goto exit; goto exit;
}
break; break;
case 2: case 2:
if (!PyArg_ParseTuple(args, "iw*:read", &len, &buffer)) if (!PyArg_ParseTuple(args, "iw*:read", &len, &buffer)) {
goto exit; goto exit;
}
group_right_1 = 1; group_right_1 = 1;
break; break;
default: default:
@ -276,8 +282,9 @@ _ssl__SSLSocket_read(PySSLSocket *self, PyObject *args)
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -332,11 +339,13 @@ _ssl__SSLContext(PyTypeObject *type, PyObject *args, PyObject *kwargs)
int proto_version; int proto_version;
if ((type == &PySSLContext_Type) && if ((type == &PySSLContext_Type) &&
!_PyArg_NoKeywords("_SSLContext", kwargs)) !_PyArg_NoKeywords("_SSLContext", kwargs)) {
goto exit; goto exit;
}
if (!PyArg_ParseTuple(args, "i:_SSLContext", if (!PyArg_ParseTuple(args, "i:_SSLContext",
&proto_version)) &proto_version)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext_impl(type, proto_version); return_value = _ssl__SSLContext_impl(type, proto_version);
exit: exit:
@ -360,8 +369,9 @@ _ssl__SSLContext_set_ciphers(PySSLContext *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *cipherlist; const char *cipherlist;
if (!PyArg_Parse(arg, "s:set_ciphers", &cipherlist)) if (!PyArg_Parse(arg, "s:set_ciphers", &cipherlist)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext_set_ciphers_impl(self, cipherlist); return_value = _ssl__SSLContext_set_ciphers_impl(self, cipherlist);
exit: exit:
@ -386,14 +396,16 @@ _ssl__SSLContext__set_npn_protocols(PySSLContext *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer protos = {NULL, NULL}; Py_buffer protos = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:_set_npn_protocols", &protos)) if (!PyArg_Parse(arg, "y*:_set_npn_protocols", &protos)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext__set_npn_protocols_impl(self, &protos); return_value = _ssl__SSLContext__set_npn_protocols_impl(self, &protos);
exit: exit:
/* Cleanup for protos */ /* Cleanup for protos */
if (protos.obj) if (protos.obj) {
PyBuffer_Release(&protos); PyBuffer_Release(&protos);
}
return return_value; return return_value;
} }
@ -416,14 +428,16 @@ _ssl__SSLContext__set_alpn_protocols(PySSLContext *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer protos = {NULL, NULL}; Py_buffer protos = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:_set_alpn_protocols", &protos)) if (!PyArg_Parse(arg, "y*:_set_alpn_protocols", &protos)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext__set_alpn_protocols_impl(self, &protos); return_value = _ssl__SSLContext__set_alpn_protocols_impl(self, &protos);
exit: exit:
/* Cleanup for protos */ /* Cleanup for protos */
if (protos.obj) if (protos.obj) {
PyBuffer_Release(&protos); PyBuffer_Release(&protos);
}
return return_value; return return_value;
} }
@ -450,8 +464,9 @@ _ssl__SSLContext_load_cert_chain(PySSLContext *self, PyObject *args, PyObject *k
PyObject *password = NULL; PyObject *password = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:load_cert_chain", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:load_cert_chain", _keywords,
&certfile, &keyfile, &password)) &certfile, &keyfile, &password)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext_load_cert_chain_impl(self, certfile, keyfile, password); return_value = _ssl__SSLContext_load_cert_chain_impl(self, certfile, keyfile, password);
exit: exit:
@ -482,8 +497,9 @@ _ssl__SSLContext_load_verify_locations(PySSLContext *self, PyObject *args, PyObj
PyObject *cadata = NULL; PyObject *cadata = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:load_verify_locations", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:load_verify_locations", _keywords,
&cafile, &capath, &cadata)) &cafile, &capath, &cadata)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext_load_verify_locations_impl(self, cafile, capath, cadata); return_value = _ssl__SSLContext_load_verify_locations_impl(self, cafile, capath, cadata);
exit: exit:
@ -520,8 +536,9 @@ _ssl__SSLContext__wrap_socket(PySSLContext *self, PyObject *args, PyObject *kwar
PyObject *hostname_obj = Py_None; PyObject *hostname_obj = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!i|O:_wrap_socket", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!i|O:_wrap_socket", _keywords,
PySocketModule.Sock_Type, &sock, &server_side, &hostname_obj)) PySocketModule.Sock_Type, &sock, &server_side, &hostname_obj)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext__wrap_socket_impl(self, sock, server_side, hostname_obj); return_value = _ssl__SSLContext__wrap_socket_impl(self, sock, server_side, hostname_obj);
exit: exit:
@ -553,8 +570,9 @@ _ssl__SSLContext__wrap_bio(PySSLContext *self, PyObject *args, PyObject *kwargs)
PyObject *hostname_obj = Py_None; PyObject *hostname_obj = Py_None;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!i|O:_wrap_bio", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!i|O:_wrap_bio", _keywords,
&PySSLMemoryBIO_Type, &incoming, &PySSLMemoryBIO_Type, &outgoing, &server_side, &hostname_obj)) &PySSLMemoryBIO_Type, &incoming, &PySSLMemoryBIO_Type, &outgoing, &server_side, &hostname_obj)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext__wrap_bio_impl(self, incoming, outgoing, server_side, hostname_obj); return_value = _ssl__SSLContext__wrap_bio_impl(self, incoming, outgoing, server_side, hostname_obj);
exit: exit:
@ -670,8 +688,9 @@ _ssl__SSLContext_get_ca_certs(PySSLContext *self, PyObject *args, PyObject *kwar
int binary_form = 0; int binary_form = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|p:get_ca_certs", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|p:get_ca_certs", _keywords,
&binary_form)) &binary_form)) {
goto exit; goto exit;
}
return_value = _ssl__SSLContext_get_ca_certs_impl(self, binary_form); return_value = _ssl__SSLContext_get_ca_certs_impl(self, binary_form);
exit: exit:
@ -687,11 +706,13 @@ _ssl_MemoryBIO(PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyObject *return_value = NULL; PyObject *return_value = NULL;
if ((type == &PySSLMemoryBIO_Type) && if ((type == &PySSLMemoryBIO_Type) &&
!_PyArg_NoPositional("MemoryBIO", args)) !_PyArg_NoPositional("MemoryBIO", args)) {
goto exit; goto exit;
}
if ((type == &PySSLMemoryBIO_Type) && if ((type == &PySSLMemoryBIO_Type) &&
!_PyArg_NoKeywords("MemoryBIO", kwargs)) !_PyArg_NoKeywords("MemoryBIO", kwargs)) {
goto exit; goto exit;
}
return_value = _ssl_MemoryBIO_impl(type); return_value = _ssl_MemoryBIO_impl(type);
exit: exit:
@ -722,8 +743,9 @@ _ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject *args)
int len = -1; int len = -1;
if (!PyArg_ParseTuple(args, "|i:read", if (!PyArg_ParseTuple(args, "|i:read",
&len)) &len)) {
goto exit; goto exit;
}
return_value = _ssl_MemoryBIO_read_impl(self, len); return_value = _ssl_MemoryBIO_read_impl(self, len);
exit: exit:
@ -750,14 +772,16 @@ _ssl_MemoryBIO_write(PySSLMemoryBIO *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer b = {NULL, NULL}; Py_buffer b = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:write", &b)) if (!PyArg_Parse(arg, "y*:write", &b)) {
goto exit; goto exit;
}
return_value = _ssl_MemoryBIO_write_impl(self, &b); return_value = _ssl_MemoryBIO_write_impl(self, &b);
exit: exit:
/* Cleanup for b */ /* Cleanup for b */
if (b.obj) if (b.obj) {
PyBuffer_Release(&b); PyBuffer_Release(&b);
}
return return_value; return return_value;
} }
@ -805,14 +829,16 @@ _ssl_RAND_add(PyModuleDef *module, PyObject *args)
double entropy; double entropy;
if (!PyArg_ParseTuple(args, "s*d:RAND_add", if (!PyArg_ParseTuple(args, "s*d:RAND_add",
&view, &entropy)) &view, &entropy)) {
goto exit; goto exit;
}
return_value = _ssl_RAND_add_impl(module, &view, entropy); return_value = _ssl_RAND_add_impl(module, &view, entropy);
exit: exit:
/* Cleanup for view */ /* Cleanup for view */
if (view.obj) if (view.obj) {
PyBuffer_Release(&view); PyBuffer_Release(&view);
}
return return_value; return return_value;
} }
@ -835,8 +861,9 @@ _ssl_RAND_bytes(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int n; int n;
if (!PyArg_Parse(arg, "i:RAND_bytes", &n)) if (!PyArg_Parse(arg, "i:RAND_bytes", &n)) {
goto exit; goto exit;
}
return_value = _ssl_RAND_bytes_impl(module, n); return_value = _ssl_RAND_bytes_impl(module, n);
exit: exit:
@ -864,8 +891,9 @@ _ssl_RAND_pseudo_bytes(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int n; int n;
if (!PyArg_Parse(arg, "i:RAND_pseudo_bytes", &n)) if (!PyArg_Parse(arg, "i:RAND_pseudo_bytes", &n)) {
goto exit; goto exit;
}
return_value = _ssl_RAND_pseudo_bytes_impl(module, n); return_value = _ssl_RAND_pseudo_bytes_impl(module, n);
exit: exit:
@ -916,8 +944,9 @@ _ssl_RAND_egd(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *path; PyObject *path;
if (!PyArg_Parse(arg, "O&:RAND_egd", PyUnicode_FSConverter, &path)) if (!PyArg_Parse(arg, "O&:RAND_egd", PyUnicode_FSConverter, &path)) {
goto exit; goto exit;
}
return_value = _ssl_RAND_egd_impl(module, path); return_value = _ssl_RAND_egd_impl(module, path);
exit: exit:
@ -970,8 +999,9 @@ _ssl_txt2obj(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int name = 0; int name = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|p:txt2obj", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|p:txt2obj", _keywords,
&txt, &name)) &txt, &name)) {
goto exit; goto exit;
}
return_value = _ssl_txt2obj_impl(module, txt, name); return_value = _ssl_txt2obj_impl(module, txt, name);
exit: exit:
@ -996,8 +1026,9 @@ _ssl_nid2obj(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int nid; int nid;
if (!PyArg_Parse(arg, "i:nid2obj", &nid)) if (!PyArg_Parse(arg, "i:nid2obj", &nid)) {
goto exit; goto exit;
}
return_value = _ssl_nid2obj_impl(module, nid); return_value = _ssl_nid2obj_impl(module, nid);
exit: exit:
@ -1032,8 +1063,9 @@ _ssl_enum_certificates(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *store_name; const char *store_name;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:enum_certificates", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:enum_certificates", _keywords,
&store_name)) &store_name)) {
goto exit; goto exit;
}
return_value = _ssl_enum_certificates_impl(module, store_name); return_value = _ssl_enum_certificates_impl(module, store_name);
exit: exit:
@ -1069,8 +1101,9 @@ _ssl_enum_crls(PyModuleDef *module, PyObject *args, PyObject *kwargs)
const char *store_name; const char *store_name;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:enum_crls", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:enum_crls", _keywords,
&store_name)) &store_name)) {
goto exit; goto exit;
}
return_value = _ssl_enum_crls_impl(module, store_name); return_value = _ssl_enum_crls_impl(module, store_name);
exit: exit:
@ -1102,4 +1135,4 @@ exit:
#ifndef _SSL_ENUM_CRLS_METHODDEF #ifndef _SSL_ENUM_CRLS_METHODDEF
#define _SSL_ENUM_CRLS_METHODDEF #define _SSL_ENUM_CRLS_METHODDEF
#endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */ #endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
/*[clinic end generated code: output=a14999cb565a69a2 input=a9049054013a1b77]*/ /*[clinic end generated code: output=c6fe203099a5aa89 input=a9049054013a1b77]*/

53
Modules/clinic/_tkinter.c.h
View File

@ -19,8 +19,9 @@ _tkinter_tkapp_eval(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *script; const char *script;
if (!PyArg_Parse(arg, "s:eval", &script)) if (!PyArg_Parse(arg, "s:eval", &script)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_eval_impl(self, script); return_value = _tkinter_tkapp_eval_impl(self, script);
exit: exit:
@ -44,8 +45,9 @@ _tkinter_tkapp_evalfile(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *fileName; const char *fileName;
if (!PyArg_Parse(arg, "s:evalfile", &fileName)) if (!PyArg_Parse(arg, "s:evalfile", &fileName)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_evalfile_impl(self, fileName); return_value = _tkinter_tkapp_evalfile_impl(self, fileName);
exit: exit:
@ -69,8 +71,9 @@ _tkinter_tkapp_record(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *script; const char *script;
if (!PyArg_Parse(arg, "s:record", &script)) if (!PyArg_Parse(arg, "s:record", &script)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_record_impl(self, script); return_value = _tkinter_tkapp_record_impl(self, script);
exit: exit:
@ -94,8 +97,9 @@ _tkinter_tkapp_adderrinfo(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *msg; const char *msg;
if (!PyArg_Parse(arg, "s:adderrinfo", &msg)) if (!PyArg_Parse(arg, "s:adderrinfo", &msg)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_adderrinfo_impl(self, msg); return_value = _tkinter_tkapp_adderrinfo_impl(self, msg);
exit: exit:
@ -143,8 +147,9 @@ _tkinter_tkapp_exprstring(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *s; const char *s;
if (!PyArg_Parse(arg, "s:exprstring", &s)) if (!PyArg_Parse(arg, "s:exprstring", &s)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_exprstring_impl(self, s); return_value = _tkinter_tkapp_exprstring_impl(self, s);
exit: exit:
@ -168,8 +173,9 @@ _tkinter_tkapp_exprlong(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *s; const char *s;
if (!PyArg_Parse(arg, "s:exprlong", &s)) if (!PyArg_Parse(arg, "s:exprlong", &s)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_exprlong_impl(self, s); return_value = _tkinter_tkapp_exprlong_impl(self, s);
exit: exit:
@ -193,8 +199,9 @@ _tkinter_tkapp_exprdouble(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *s; const char *s;
if (!PyArg_Parse(arg, "s:exprdouble", &s)) if (!PyArg_Parse(arg, "s:exprdouble", &s)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_exprdouble_impl(self, s); return_value = _tkinter_tkapp_exprdouble_impl(self, s);
exit: exit:
@ -218,8 +225,9 @@ _tkinter_tkapp_exprboolean(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *s; const char *s;
if (!PyArg_Parse(arg, "s:exprboolean", &s)) if (!PyArg_Parse(arg, "s:exprboolean", &s)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_exprboolean_impl(self, s); return_value = _tkinter_tkapp_exprboolean_impl(self, s);
exit: exit:
@ -262,8 +270,9 @@ _tkinter_tkapp_createcommand(TkappObject *self, PyObject *args)
PyObject *func; PyObject *func;
if (!PyArg_ParseTuple(args, "sO:createcommand", if (!PyArg_ParseTuple(args, "sO:createcommand",
&name, &func)) &name, &func)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_createcommand_impl(self, name, func); return_value = _tkinter_tkapp_createcommand_impl(self, name, func);
exit: exit:
@ -287,8 +296,9 @@ _tkinter_tkapp_deletecommand(TkappObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *name; const char *name;
if (!PyArg_Parse(arg, "s:deletecommand", &name)) if (!PyArg_Parse(arg, "s:deletecommand", &name)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_deletecommand_impl(self, name); return_value = _tkinter_tkapp_deletecommand_impl(self, name);
exit: exit:
@ -318,8 +328,9 @@ _tkinter_tkapp_createfilehandler(TkappObject *self, PyObject *args)
PyObject *func; PyObject *func;
if (!PyArg_ParseTuple(args, "OiO:createfilehandler", if (!PyArg_ParseTuple(args, "OiO:createfilehandler",
&file, &mask, &func)) &file, &mask, &func)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_createfilehandler_impl(self, file, mask, func); return_value = _tkinter_tkapp_createfilehandler_impl(self, file, mask, func);
exit: exit:
@ -377,8 +388,9 @@ _tkinter_tkapp_createtimerhandler(TkappObject *self, PyObject *args)
PyObject *func; PyObject *func;
if (!PyArg_ParseTuple(args, "iO:createtimerhandler", if (!PyArg_ParseTuple(args, "iO:createtimerhandler",
&milliseconds, &func)) &milliseconds, &func)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_createtimerhandler_impl(self, milliseconds, func); return_value = _tkinter_tkapp_createtimerhandler_impl(self, milliseconds, func);
exit: exit:
@ -403,8 +415,9 @@ _tkinter_tkapp_mainloop(TkappObject *self, PyObject *args)
int threshold = 0; int threshold = 0;
if (!PyArg_ParseTuple(args, "|i:mainloop", if (!PyArg_ParseTuple(args, "|i:mainloop",
&threshold)) &threshold)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_mainloop_impl(self, threshold); return_value = _tkinter_tkapp_mainloop_impl(self, threshold);
exit: exit:
@ -429,8 +442,9 @@ _tkinter_tkapp_dooneevent(TkappObject *self, PyObject *args)
int flags = 0; int flags = 0;
if (!PyArg_ParseTuple(args, "|i:dooneevent", if (!PyArg_ParseTuple(args, "|i:dooneevent",
&flags)) &flags)) {
goto exit; goto exit;
}
return_value = _tkinter_tkapp_dooneevent_impl(self, flags); return_value = _tkinter_tkapp_dooneevent_impl(self, flags);
exit: exit:
@ -551,8 +565,9 @@ _tkinter_create(PyModuleDef *module, PyObject *args)
const char *use = NULL; const char *use = NULL;
if (!PyArg_ParseTuple(args, "|zssiiiiz:create", if (!PyArg_ParseTuple(args, "|zssiiiiz:create",
&screenName, &baseName, &className, &interactive, &wantobjects, &wantTk, &sync, &use)) &screenName, &baseName, &className, &interactive, &wantobjects, &wantTk, &sync, &use)) {
goto exit; goto exit;
}
return_value = _tkinter_create_impl(module, screenName, baseName, className, interactive, wantobjects, wantTk, sync, use); return_value = _tkinter_create_impl(module, screenName, baseName, className, interactive, wantobjects, wantTk, sync, use);
exit: exit:
@ -579,8 +594,9 @@ _tkinter_setbusywaitinterval(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int new_val; int new_val;
if (!PyArg_Parse(arg, "i:setbusywaitinterval", &new_val)) if (!PyArg_Parse(arg, "i:setbusywaitinterval", &new_val)) {
goto exit; goto exit;
}
return_value = _tkinter_setbusywaitinterval_impl(module, new_val); return_value = _tkinter_setbusywaitinterval_impl(module, new_val);
exit: exit:
@ -606,8 +622,9 @@ _tkinter_getbusywaitinterval(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
int _return_value; int _return_value;
_return_value = _tkinter_getbusywaitinterval_impl(module); _return_value = _tkinter_getbusywaitinterval_impl(module);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -621,4 +638,4 @@ exit:
#ifndef _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF #ifndef _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
#define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF #define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
#endif /* !defined(_TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF) */ #endif /* !defined(_TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF) */
/*[clinic end generated code: output=6dd667b91cf8addd input=a9049054013a1b77]*/ /*[clinic end generated code: output=13be3f8313bba3c7 input=a9049054013a1b77]*/

5
Modules/clinic/_weakref.c.h
View File

@ -21,11 +21,12 @@ _weakref_getweakrefcount(PyModuleDef *module, PyObject *object)
Py_ssize_t _return_value; Py_ssize_t _return_value;
_return_value = _weakref_getweakrefcount_impl(module, object); _return_value = _weakref_getweakrefcount_impl(module, object);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromSsize_t(_return_value); return_value = PyLong_FromSsize_t(_return_value);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=4da9aade63eed77f input=a9049054013a1b77]*/ /*[clinic end generated code: output=00e317cda5359ea3 input=a9049054013a1b77]*/

116
Modules/clinic/_winapi.c.h
View File

@ -19,8 +19,9 @@ _winapi_Overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int wait; int wait;
if (!PyArg_Parse(arg, "p:GetOverlappedResult", &wait)) if (!PyArg_Parse(arg, "p:GetOverlappedResult", &wait)) {
goto exit; goto exit;
}
return_value = _winapi_Overlapped_GetOverlappedResult_impl(self, wait); return_value = _winapi_Overlapped_GetOverlappedResult_impl(self, wait);
exit: exit:
@ -79,8 +80,9 @@ _winapi_CloseHandle(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HANDLE handle; HANDLE handle;
if (!PyArg_Parse(arg, "" F_HANDLE ":CloseHandle", &handle)) if (!PyArg_Parse(arg, "" F_HANDLE ":CloseHandle", &handle)) {
goto exit; goto exit;
}
return_value = _winapi_CloseHandle_impl(module, handle); return_value = _winapi_CloseHandle_impl(module, handle);
exit: exit:
@ -108,8 +110,9 @@ _winapi_ConnectNamedPipe(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int use_overlapped = 0; int use_overlapped = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "|i:ConnectNamedPipe", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "|i:ConnectNamedPipe", _keywords,
&handle, &use_overlapped)) &handle, &use_overlapped)) {
goto exit; goto exit;
}
return_value = _winapi_ConnectNamedPipe_impl(module, handle, use_overlapped); return_value = _winapi_ConnectNamedPipe_impl(module, handle, use_overlapped);
exit: exit:
@ -147,13 +150,16 @@ _winapi_CreateFile(PyModuleDef *module, PyObject *args)
HANDLE _return_value; HANDLE _return_value;
if (!PyArg_ParseTuple(args, "skk" F_POINTER "kk" F_HANDLE ":CreateFile", if (!PyArg_ParseTuple(args, "skk" F_POINTER "kk" F_HANDLE ":CreateFile",
&file_name, &desired_access, &share_mode, &security_attributes, &creation_disposition, &flags_and_attributes, &template_file)) &file_name, &desired_access, &share_mode, &security_attributes, &creation_disposition, &flags_and_attributes, &template_file)) {
goto exit; goto exit;
}
_return_value = _winapi_CreateFile_impl(module, file_name, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file); _return_value = _winapi_CreateFile_impl(module, file_name, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -180,8 +186,9 @@ _winapi_CreateJunction(PyModuleDef *module, PyObject *args)
LPWSTR dst_path; LPWSTR dst_path;
if (!PyArg_ParseTuple(args, "uu:CreateJunction", if (!PyArg_ParseTuple(args, "uu:CreateJunction",
&src_path, &dst_path)) &src_path, &dst_path)) {
goto exit; goto exit;
}
return_value = _winapi_CreateJunction_impl(module, src_path, dst_path); return_value = _winapi_CreateJunction_impl(module, src_path, dst_path);
exit: exit:
@ -220,13 +227,16 @@ _winapi_CreateNamedPipe(PyModuleDef *module, PyObject *args)
HANDLE _return_value; HANDLE _return_value;
if (!PyArg_ParseTuple(args, "skkkkkk" F_POINTER ":CreateNamedPipe", if (!PyArg_ParseTuple(args, "skkkkkk" F_POINTER ":CreateNamedPipe",
&name, &open_mode, &pipe_mode, &max_instances, &out_buffer_size, &in_buffer_size, &default_timeout, &security_attributes)) &name, &open_mode, &pipe_mode, &max_instances, &out_buffer_size, &in_buffer_size, &default_timeout, &security_attributes)) {
goto exit; goto exit;
}
_return_value = _winapi_CreateNamedPipe_impl(module, name, open_mode, pipe_mode, max_instances, out_buffer_size, in_buffer_size, default_timeout, security_attributes); _return_value = _winapi_CreateNamedPipe_impl(module, name, open_mode, pipe_mode, max_instances, out_buffer_size, in_buffer_size, default_timeout, security_attributes);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -259,8 +269,9 @@ _winapi_CreatePipe(PyModuleDef *module, PyObject *args)
DWORD size; DWORD size;
if (!PyArg_ParseTuple(args, "Ok:CreatePipe", if (!PyArg_ParseTuple(args, "Ok:CreatePipe",
&pipe_attrs, &size)) &pipe_attrs, &size)) {
goto exit; goto exit;
}
return_value = _winapi_CreatePipe_impl(module, pipe_attrs, size); return_value = _winapi_CreatePipe_impl(module, pipe_attrs, size);
exit: exit:
@ -309,8 +320,9 @@ _winapi_CreateProcess(PyModuleDef *module, PyObject *args)
PyObject *startup_info; PyObject *startup_info;
if (!PyArg_ParseTuple(args, "ZZOOikOZO:CreateProcess", if (!PyArg_ParseTuple(args, "ZZOOikOZO:CreateProcess",
&application_name, &command_line, &proc_attrs, &thread_attrs, &inherit_handles, &creation_flags, &env_mapping, &current_directory, &startup_info)) &application_name, &command_line, &proc_attrs, &thread_attrs, &inherit_handles, &creation_flags, &env_mapping, &current_directory, &startup_info)) {
goto exit; goto exit;
}
return_value = _winapi_CreateProcess_impl(module, application_name, command_line, proc_attrs, thread_attrs, inherit_handles, creation_flags, env_mapping, current_directory, startup_info); return_value = _winapi_CreateProcess_impl(module, application_name, command_line, proc_attrs, thread_attrs, inherit_handles, creation_flags, env_mapping, current_directory, startup_info);
exit: exit:
@ -353,13 +365,16 @@ _winapi_DuplicateHandle(PyModuleDef *module, PyObject *args)
HANDLE _return_value; HANDLE _return_value;
if (!PyArg_ParseTuple(args, "" F_HANDLE "" F_HANDLE "" F_HANDLE "ki|k:DuplicateHandle", if (!PyArg_ParseTuple(args, "" F_HANDLE "" F_HANDLE "" F_HANDLE "ki|k:DuplicateHandle",
&source_process_handle, &source_handle, &target_process_handle, &desired_access, &inherit_handle, &options)) &source_process_handle, &source_handle, &target_process_handle, &desired_access, &inherit_handle, &options)) {
goto exit; goto exit;
}
_return_value = _winapi_DuplicateHandle_impl(module, source_process_handle, source_handle, target_process_handle, desired_access, inherit_handle, options); _return_value = _winapi_DuplicateHandle_impl(module, source_process_handle, source_handle, target_process_handle, desired_access, inherit_handle, options);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -383,8 +398,9 @@ _winapi_ExitProcess(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
UINT ExitCode; UINT ExitCode;
if (!PyArg_Parse(arg, "I:ExitProcess", &ExitCode)) if (!PyArg_Parse(arg, "I:ExitProcess", &ExitCode)) {
goto exit; goto exit;
}
return_value = _winapi_ExitProcess_impl(module, ExitCode); return_value = _winapi_ExitProcess_impl(module, ExitCode);
exit: exit:
@ -410,10 +426,12 @@ _winapi_GetCurrentProcess(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
HANDLE _return_value; HANDLE _return_value;
_return_value = _winapi_GetCurrentProcess_impl(module); _return_value = _winapi_GetCurrentProcess_impl(module);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -439,11 +457,13 @@ _winapi_GetExitCodeProcess(PyModuleDef *module, PyObject *arg)
HANDLE process; HANDLE process;
DWORD _return_value; DWORD _return_value;
if (!PyArg_Parse(arg, "" F_HANDLE ":GetExitCodeProcess", &process)) if (!PyArg_Parse(arg, "" F_HANDLE ":GetExitCodeProcess", &process)) {
goto exit; goto exit;
}
_return_value = _winapi_GetExitCodeProcess_impl(module, process); _return_value = _winapi_GetExitCodeProcess_impl(module, process);
if ((_return_value == DWORD_MAX) && PyErr_Occurred()) if ((_return_value == DWORD_MAX) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = Py_BuildValue("k", _return_value); return_value = Py_BuildValue("k", _return_value);
exit: exit:
@ -468,8 +488,9 @@ _winapi_GetLastError(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
DWORD _return_value; DWORD _return_value;
_return_value = _winapi_GetLastError_impl(module); _return_value = _winapi_GetLastError_impl(module);
if ((_return_value == DWORD_MAX) && PyErr_Occurred()) if ((_return_value == DWORD_MAX) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = Py_BuildValue("k", _return_value); return_value = Py_BuildValue("k", _return_value);
exit: exit:
@ -501,8 +522,9 @@ _winapi_GetModuleFileName(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HMODULE module_handle; HMODULE module_handle;
if (!PyArg_Parse(arg, "" F_HANDLE ":GetModuleFileName", &module_handle)) if (!PyArg_Parse(arg, "" F_HANDLE ":GetModuleFileName", &module_handle)) {
goto exit; goto exit;
}
return_value = _winapi_GetModuleFileName_impl(module, module_handle); return_value = _winapi_GetModuleFileName_impl(module, module_handle);
exit: exit:
@ -533,13 +555,16 @@ _winapi_GetStdHandle(PyModuleDef *module, PyObject *arg)
DWORD std_handle; DWORD std_handle;
HANDLE _return_value; HANDLE _return_value;
if (!PyArg_Parse(arg, "k:GetStdHandle", &std_handle)) if (!PyArg_Parse(arg, "k:GetStdHandle", &std_handle)) {
goto exit; goto exit;
}
_return_value = _winapi_GetStdHandle_impl(module, std_handle); _return_value = _winapi_GetStdHandle_impl(module, std_handle);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -565,8 +590,9 @@ _winapi_GetVersion(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
long _return_value; long _return_value;
_return_value = _winapi_GetVersion_impl(module); _return_value = _winapi_GetVersion_impl(module);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -595,13 +621,16 @@ _winapi_OpenProcess(PyModuleDef *module, PyObject *args)
HANDLE _return_value; HANDLE _return_value;
if (!PyArg_ParseTuple(args, "kik:OpenProcess", if (!PyArg_ParseTuple(args, "kik:OpenProcess",
&desired_access, &inherit_handle, &process_id)) &desired_access, &inherit_handle, &process_id)) {
goto exit; goto exit;
}
_return_value = _winapi_OpenProcess_impl(module, desired_access, inherit_handle, process_id); _return_value = _winapi_OpenProcess_impl(module, desired_access, inherit_handle, process_id);
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
goto exit; goto exit;
if (_return_value == NULL) }
if (_return_value == NULL) {
Py_RETURN_NONE; Py_RETURN_NONE;
}
return_value = HANDLE_TO_PYNUM(_return_value); return_value = HANDLE_TO_PYNUM(_return_value);
exit: exit:
@ -627,8 +656,9 @@ _winapi_PeekNamedPipe(PyModuleDef *module, PyObject *args)
int size = 0; int size = 0;
if (!PyArg_ParseTuple(args, "" F_HANDLE "|i:PeekNamedPipe", if (!PyArg_ParseTuple(args, "" F_HANDLE "|i:PeekNamedPipe",
&handle, &size)) &handle, &size)) {
goto exit; goto exit;
}
return_value = _winapi_PeekNamedPipe_impl(module, handle, size); return_value = _winapi_PeekNamedPipe_impl(module, handle, size);
exit: exit:
@ -657,8 +687,9 @@ _winapi_ReadFile(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int use_overlapped = 0; int use_overlapped = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "i|i:ReadFile", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "i|i:ReadFile", _keywords,
&handle, &size, &use_overlapped)) &handle, &size, &use_overlapped)) {
goto exit; goto exit;
}
return_value = _winapi_ReadFile_impl(module, handle, size, use_overlapped); return_value = _winapi_ReadFile_impl(module, handle, size, use_overlapped);
exit: exit:
@ -690,8 +721,9 @@ _winapi_SetNamedPipeHandleState(PyModuleDef *module, PyObject *args)
PyObject *collect_data_timeout; PyObject *collect_data_timeout;
if (!PyArg_ParseTuple(args, "" F_HANDLE "OOO:SetNamedPipeHandleState", if (!PyArg_ParseTuple(args, "" F_HANDLE "OOO:SetNamedPipeHandleState",
&named_pipe, &mode, &max_collection_count, &collect_data_timeout)) &named_pipe, &mode, &max_collection_count, &collect_data_timeout)) {
goto exit; goto exit;
}
return_value = _winapi_SetNamedPipeHandleState_impl(module, named_pipe, mode, max_collection_count, collect_data_timeout); return_value = _winapi_SetNamedPipeHandleState_impl(module, named_pipe, mode, max_collection_count, collect_data_timeout);
exit: exit:
@ -719,8 +751,9 @@ _winapi_TerminateProcess(PyModuleDef *module, PyObject *args)
UINT exit_code; UINT exit_code;
if (!PyArg_ParseTuple(args, "" F_HANDLE "I:TerminateProcess", if (!PyArg_ParseTuple(args, "" F_HANDLE "I:TerminateProcess",
&handle, &exit_code)) &handle, &exit_code)) {
goto exit; goto exit;
}
return_value = _winapi_TerminateProcess_impl(module, handle, exit_code); return_value = _winapi_TerminateProcess_impl(module, handle, exit_code);
exit: exit:
@ -746,8 +779,9 @@ _winapi_WaitNamedPipe(PyModuleDef *module, PyObject *args)
DWORD timeout; DWORD timeout;
if (!PyArg_ParseTuple(args, "sk:WaitNamedPipe", if (!PyArg_ParseTuple(args, "sk:WaitNamedPipe",
&name, &timeout)) &name, &timeout)) {
goto exit; goto exit;
}
return_value = _winapi_WaitNamedPipe_impl(module, name, timeout); return_value = _winapi_WaitNamedPipe_impl(module, name, timeout);
exit: exit:
@ -777,8 +811,9 @@ _winapi_WaitForMultipleObjects(PyModuleDef *module, PyObject *args)
DWORD milliseconds = INFINITE; DWORD milliseconds = INFINITE;
if (!PyArg_ParseTuple(args, "Oi|k:WaitForMultipleObjects", if (!PyArg_ParseTuple(args, "Oi|k:WaitForMultipleObjects",
&handle_seq, &wait_flag, &milliseconds)) &handle_seq, &wait_flag, &milliseconds)) {
goto exit; goto exit;
}
return_value = _winapi_WaitForMultipleObjects_impl(module, handle_seq, wait_flag, milliseconds); return_value = _winapi_WaitForMultipleObjects_impl(module, handle_seq, wait_flag, milliseconds);
exit: exit:
@ -811,11 +846,13 @@ _winapi_WaitForSingleObject(PyModuleDef *module, PyObject *args)
long _return_value; long _return_value;
if (!PyArg_ParseTuple(args, "" F_HANDLE "k:WaitForSingleObject", if (!PyArg_ParseTuple(args, "" F_HANDLE "k:WaitForSingleObject",
&handle, &milliseconds)) &handle, &milliseconds)) {
goto exit; goto exit;
}
_return_value = _winapi_WaitForSingleObject_impl(module, handle, milliseconds); _return_value = _winapi_WaitForSingleObject_impl(module, handle, milliseconds);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -844,11 +881,12 @@ _winapi_WriteFile(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int use_overlapped = 0; int use_overlapped = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "O|i:WriteFile", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "" F_HANDLE "O|i:WriteFile", _keywords,
&handle, &buffer, &use_overlapped)) &handle, &buffer, &use_overlapped)) {
goto exit; goto exit;
}
return_value = _winapi_WriteFile_impl(module, handle, buffer, use_overlapped); return_value = _winapi_WriteFile_impl(module, handle, buffer, use_overlapped);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=98771c6584056d19 input=a9049054013a1b77]*/ /*[clinic end generated code: output=d099ee4fbcdd5bc0 input=a9049054013a1b77]*/

29
Modules/clinic/arraymodule.c.h
View File

@ -77,8 +77,9 @@ array_array_pop(arrayobject *self, PyObject *args)
Py_ssize_t i = -1; Py_ssize_t i = -1;
if (!PyArg_ParseTuple(args, "|n:pop", if (!PyArg_ParseTuple(args, "|n:pop",
&i)) &i)) {
goto exit; goto exit;
}
return_value = array_array_pop_impl(self, i); return_value = array_array_pop_impl(self, i);
exit: exit:
@ -114,8 +115,9 @@ array_array_insert(arrayobject *self, PyObject *args)
PyObject *v; PyObject *v;
if (!PyArg_ParseTuple(args, "nO:insert", if (!PyArg_ParseTuple(args, "nO:insert",
&i, &v)) &i, &v)) {
goto exit; goto exit;
}
return_value = array_array_insert_impl(self, i, v); return_value = array_array_insert_impl(self, i, v);
exit: exit:
@ -211,8 +213,9 @@ array_array_fromfile(arrayobject *self, PyObject *args)
Py_ssize_t n; Py_ssize_t n;
if (!PyArg_ParseTuple(args, "On:fromfile", if (!PyArg_ParseTuple(args, "On:fromfile",
&f, &n)) &f, &n)) {
goto exit; goto exit;
}
return_value = array_array_fromfile_impl(self, f, n); return_value = array_array_fromfile_impl(self, f, n);
exit: exit:
@ -275,14 +278,16 @@ array_array_fromstring(arrayobject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "s*:fromstring", &buffer)) if (!PyArg_Parse(arg, "s*:fromstring", &buffer)) {
goto exit; goto exit;
}
return_value = array_array_fromstring_impl(self, &buffer); return_value = array_array_fromstring_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -305,14 +310,16 @@ array_array_frombytes(arrayobject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL}; Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:frombytes", &buffer)) if (!PyArg_Parse(arg, "y*:frombytes", &buffer)) {
goto exit; goto exit;
}
return_value = array_array_frombytes_impl(self, &buffer); return_value = array_array_frombytes_impl(self, &buffer);
exit: exit:
/* Cleanup for buffer */ /* Cleanup for buffer */
if (buffer.obj) if (buffer.obj) {
PyBuffer_Release(&buffer); PyBuffer_Release(&buffer);
}
return return_value; return return_value;
} }
@ -379,8 +386,9 @@ array_array_fromunicode(arrayobject *self, PyObject *arg)
Py_UNICODE *ustr; Py_UNICODE *ustr;
Py_ssize_clean_t ustr_length; Py_ssize_clean_t ustr_length;
if (!PyArg_Parse(arg, "u#:fromunicode", &ustr, &ustr_length)) if (!PyArg_Parse(arg, "u#:fromunicode", &ustr, &ustr_length)) {
goto exit; goto exit;
}
return_value = array_array_fromunicode_impl(self, ustr, ustr_length); return_value = array_array_fromunicode_impl(self, ustr, ustr_length);
exit: exit:
@ -453,8 +461,9 @@ array__array_reconstructor(PyModuleDef *module, PyObject *args)
PyObject *items; PyObject *items;
if (!PyArg_ParseTuple(args, "OCiO:_array_reconstructor", if (!PyArg_ParseTuple(args, "OCiO:_array_reconstructor",
&arraytype, &typecode, &mformat_code, &items)) &arraytype, &typecode, &mformat_code, &items)) {
goto exit; goto exit;
}
return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items); return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items);
exit: exit:
@ -496,4 +505,4 @@ PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
#define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF \ #define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF \
{"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__}, {"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
/*[clinic end generated code: output=d2e82c65ea841cfc input=a9049054013a1b77]*/ /*[clinic end generated code: output=0b99c89275eda265 input=a9049054013a1b77]*/

167
Modules/clinic/audioop.c.h
View File

@ -24,14 +24,16 @@ audioop_getsample(PyModuleDef *module, PyObject *args)
Py_ssize_t index; Py_ssize_t index;
if (!PyArg_ParseTuple(args, "y*in:getsample", if (!PyArg_ParseTuple(args, "y*in:getsample",
&fragment, &width, &index)) &fragment, &width, &index)) {
goto exit; goto exit;
}
return_value = audioop_getsample_impl(module, &fragment, width, index); return_value = audioop_getsample_impl(module, &fragment, width, index);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -56,14 +58,16 @@ audioop_max(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:max", if (!PyArg_ParseTuple(args, "y*i:max",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_max_impl(module, &fragment, width); return_value = audioop_max_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -88,14 +92,16 @@ audioop_minmax(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:minmax", if (!PyArg_ParseTuple(args, "y*i:minmax",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_minmax_impl(module, &fragment, width); return_value = audioop_minmax_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -120,14 +126,16 @@ audioop_avg(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:avg", if (!PyArg_ParseTuple(args, "y*i:avg",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_avg_impl(module, &fragment, width); return_value = audioop_avg_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -152,14 +160,16 @@ audioop_rms(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:rms", if (!PyArg_ParseTuple(args, "y*i:rms",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_rms_impl(module, &fragment, width); return_value = audioop_rms_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -185,17 +195,20 @@ audioop_findfit(PyModuleDef *module, PyObject *args)
Py_buffer reference = {NULL, NULL}; Py_buffer reference = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:findfit", if (!PyArg_ParseTuple(args, "y*y*:findfit",
&fragment, &reference)) &fragment, &reference)) {
goto exit; goto exit;
}
return_value = audioop_findfit_impl(module, &fragment, &reference); return_value = audioop_findfit_impl(module, &fragment, &reference);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
/* Cleanup for reference */ /* Cleanup for reference */
if (reference.obj) if (reference.obj) {
PyBuffer_Release(&reference); PyBuffer_Release(&reference);
}
return return_value; return return_value;
} }
@ -221,17 +234,20 @@ audioop_findfactor(PyModuleDef *module, PyObject *args)
Py_buffer reference = {NULL, NULL}; Py_buffer reference = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:findfactor", if (!PyArg_ParseTuple(args, "y*y*:findfactor",
&fragment, &reference)) &fragment, &reference)) {
goto exit; goto exit;
}
return_value = audioop_findfactor_impl(module, &fragment, &reference); return_value = audioop_findfactor_impl(module, &fragment, &reference);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
/* Cleanup for reference */ /* Cleanup for reference */
if (reference.obj) if (reference.obj) {
PyBuffer_Release(&reference); PyBuffer_Release(&reference);
}
return return_value; return return_value;
} }
@ -257,14 +273,16 @@ audioop_findmax(PyModuleDef *module, PyObject *args)
Py_ssize_t length; Py_ssize_t length;
if (!PyArg_ParseTuple(args, "y*n:findmax", if (!PyArg_ParseTuple(args, "y*n:findmax",
&fragment, &length)) &fragment, &length)) {
goto exit; goto exit;
}
return_value = audioop_findmax_impl(module, &fragment, length); return_value = audioop_findmax_impl(module, &fragment, length);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -289,14 +307,16 @@ audioop_avgpp(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:avgpp", if (!PyArg_ParseTuple(args, "y*i:avgpp",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_avgpp_impl(module, &fragment, width); return_value = audioop_avgpp_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -321,14 +341,16 @@ audioop_maxpp(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:maxpp", if (!PyArg_ParseTuple(args, "y*i:maxpp",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_maxpp_impl(module, &fragment, width); return_value = audioop_maxpp_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -353,14 +375,16 @@ audioop_cross(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:cross", if (!PyArg_ParseTuple(args, "y*i:cross",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_cross_impl(module, &fragment, width); return_value = audioop_cross_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -387,14 +411,16 @@ audioop_mul(PyModuleDef *module, PyObject *args)
double factor; double factor;
if (!PyArg_ParseTuple(args, "y*id:mul", if (!PyArg_ParseTuple(args, "y*id:mul",
&fragment, &width, &factor)) &fragment, &width, &factor)) {
goto exit; goto exit;
}
return_value = audioop_mul_impl(module, &fragment, width, factor); return_value = audioop_mul_impl(module, &fragment, width, factor);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -422,14 +448,16 @@ audioop_tomono(PyModuleDef *module, PyObject *args)
double rfactor; double rfactor;
if (!PyArg_ParseTuple(args, "y*idd:tomono", if (!PyArg_ParseTuple(args, "y*idd:tomono",
&fragment, &width, &lfactor, &rfactor)) &fragment, &width, &lfactor, &rfactor)) {
goto exit; goto exit;
}
return_value = audioop_tomono_impl(module, &fragment, width, lfactor, rfactor); return_value = audioop_tomono_impl(module, &fragment, width, lfactor, rfactor);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -457,14 +485,16 @@ audioop_tostereo(PyModuleDef *module, PyObject *args)
double rfactor; double rfactor;
if (!PyArg_ParseTuple(args, "y*idd:tostereo", if (!PyArg_ParseTuple(args, "y*idd:tostereo",
&fragment, &width, &lfactor, &rfactor)) &fragment, &width, &lfactor, &rfactor)) {
goto exit; goto exit;
}
return_value = audioop_tostereo_impl(module, &fragment, width, lfactor, rfactor); return_value = audioop_tostereo_impl(module, &fragment, width, lfactor, rfactor);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -491,17 +521,20 @@ audioop_add(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*y*i:add", if (!PyArg_ParseTuple(args, "y*y*i:add",
&fragment1, &fragment2, &width)) &fragment1, &fragment2, &width)) {
goto exit; goto exit;
}
return_value = audioop_add_impl(module, &fragment1, &fragment2, width); return_value = audioop_add_impl(module, &fragment1, &fragment2, width);
exit: exit:
/* Cleanup for fragment1 */ /* Cleanup for fragment1 */
if (fragment1.obj) if (fragment1.obj) {
PyBuffer_Release(&fragment1); PyBuffer_Release(&fragment1);
}
/* Cleanup for fragment2 */ /* Cleanup for fragment2 */
if (fragment2.obj) if (fragment2.obj) {
PyBuffer_Release(&fragment2); PyBuffer_Release(&fragment2);
}
return return_value; return return_value;
} }
@ -528,14 +561,16 @@ audioop_bias(PyModuleDef *module, PyObject *args)
int bias; int bias;
if (!PyArg_ParseTuple(args, "y*ii:bias", if (!PyArg_ParseTuple(args, "y*ii:bias",
&fragment, &width, &bias)) &fragment, &width, &bias)) {
goto exit; goto exit;
}
return_value = audioop_bias_impl(module, &fragment, width, bias); return_value = audioop_bias_impl(module, &fragment, width, bias);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -560,14 +595,16 @@ audioop_reverse(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:reverse", if (!PyArg_ParseTuple(args, "y*i:reverse",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_reverse_impl(module, &fragment, width); return_value = audioop_reverse_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -592,14 +629,16 @@ audioop_byteswap(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:byteswap", if (!PyArg_ParseTuple(args, "y*i:byteswap",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_byteswap_impl(module, &fragment, width); return_value = audioop_byteswap_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -626,14 +665,16 @@ audioop_lin2lin(PyModuleDef *module, PyObject *args)
int newwidth; int newwidth;
if (!PyArg_ParseTuple(args, "y*ii:lin2lin", if (!PyArg_ParseTuple(args, "y*ii:lin2lin",
&fragment, &width, &newwidth)) &fragment, &width, &newwidth)) {
goto exit; goto exit;
}
return_value = audioop_lin2lin_impl(module, &fragment, width, newwidth); return_value = audioop_lin2lin_impl(module, &fragment, width, newwidth);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -667,14 +708,16 @@ audioop_ratecv(PyModuleDef *module, PyObject *args)
int weightB = 0; int weightB = 0;
if (!PyArg_ParseTuple(args, "y*iiiiO|ii:ratecv", if (!PyArg_ParseTuple(args, "y*iiiiO|ii:ratecv",
&fragment, &width, &nchannels, &inrate, &outrate, &state, &weightA, &weightB)) &fragment, &width, &nchannels, &inrate, &outrate, &state, &weightA, &weightB)) {
goto exit; goto exit;
}
return_value = audioop_ratecv_impl(module, &fragment, width, nchannels, inrate, outrate, state, weightA, weightB); return_value = audioop_ratecv_impl(module, &fragment, width, nchannels, inrate, outrate, state, weightA, weightB);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -699,14 +742,16 @@ audioop_lin2ulaw(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:lin2ulaw", if (!PyArg_ParseTuple(args, "y*i:lin2ulaw",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_lin2ulaw_impl(module, &fragment, width); return_value = audioop_lin2ulaw_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -731,14 +776,16 @@ audioop_ulaw2lin(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:ulaw2lin", if (!PyArg_ParseTuple(args, "y*i:ulaw2lin",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_ulaw2lin_impl(module, &fragment, width); return_value = audioop_ulaw2lin_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -763,14 +810,16 @@ audioop_lin2alaw(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:lin2alaw", if (!PyArg_ParseTuple(args, "y*i:lin2alaw",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_lin2alaw_impl(module, &fragment, width); return_value = audioop_lin2alaw_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -795,14 +844,16 @@ audioop_alaw2lin(PyModuleDef *module, PyObject *args)
int width; int width;
if (!PyArg_ParseTuple(args, "y*i:alaw2lin", if (!PyArg_ParseTuple(args, "y*i:alaw2lin",
&fragment, &width)) &fragment, &width)) {
goto exit; goto exit;
}
return_value = audioop_alaw2lin_impl(module, &fragment, width); return_value = audioop_alaw2lin_impl(module, &fragment, width);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -829,14 +880,16 @@ audioop_lin2adpcm(PyModuleDef *module, PyObject *args)
PyObject *state; PyObject *state;
if (!PyArg_ParseTuple(args, "y*iO:lin2adpcm", if (!PyArg_ParseTuple(args, "y*iO:lin2adpcm",
&fragment, &width, &state)) &fragment, &width, &state)) {
goto exit; goto exit;
}
return_value = audioop_lin2adpcm_impl(module, &fragment, width, state); return_value = audioop_lin2adpcm_impl(module, &fragment, width, state);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
@ -863,15 +916,17 @@ audioop_adpcm2lin(PyModuleDef *module, PyObject *args)
PyObject *state; PyObject *state;
if (!PyArg_ParseTuple(args, "y*iO:adpcm2lin", if (!PyArg_ParseTuple(args, "y*iO:adpcm2lin",
&fragment, &width, &state)) &fragment, &width, &state)) {
goto exit; goto exit;
}
return_value = audioop_adpcm2lin_impl(module, &fragment, width, state); return_value = audioop_adpcm2lin_impl(module, &fragment, width, state);
exit: exit:
/* Cleanup for fragment */ /* Cleanup for fragment */
if (fragment.obj) if (fragment.obj) {
PyBuffer_Release(&fragment); PyBuffer_Release(&fragment);
}
return return_value; return return_value;
} }
/*[clinic end generated code: output=a076e1b213a8727b input=a9049054013a1b77]*/ /*[clinic end generated code: output=af5b025f0241fee2 input=a9049054013a1b77]*/

86
Modules/clinic/binascii.c.h
View File

@ -20,8 +20,9 @@ binascii_a2b_uu(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "O&:a2b_uu", ascii_buffer_converter, &data)) if (!PyArg_Parse(arg, "O&:a2b_uu", ascii_buffer_converter, &data)) {
goto exit; goto exit;
}
return_value = binascii_a2b_uu_impl(module, &data); return_value = binascii_a2b_uu_impl(module, &data);
exit: exit:
@ -50,14 +51,16 @@ binascii_b2a_uu(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:b2a_uu", &data)) if (!PyArg_Parse(arg, "y*:b2a_uu", &data)) {
goto exit; goto exit;
}
return_value = binascii_b2a_uu_impl(module, &data); return_value = binascii_b2a_uu_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -80,8 +83,9 @@ binascii_a2b_base64(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "O&:a2b_base64", ascii_buffer_converter, &data)) if (!PyArg_Parse(arg, "O&:a2b_base64", ascii_buffer_converter, &data)) {
goto exit; goto exit;
}
return_value = binascii_a2b_base64_impl(module, &data); return_value = binascii_a2b_base64_impl(module, &data);
exit: exit:
@ -113,14 +117,16 @@ binascii_b2a_base64(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int newline = 1; int newline = 1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|$i:b2a_base64", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|$i:b2a_base64", _keywords,
&data, &newline)) &data, &newline)) {
goto exit; goto exit;
}
return_value = binascii_b2a_base64_impl(module, &data, newline); return_value = binascii_b2a_base64_impl(module, &data, newline);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -143,8 +149,9 @@ binascii_a2b_hqx(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "O&:a2b_hqx", ascii_buffer_converter, &data)) if (!PyArg_Parse(arg, "O&:a2b_hqx", ascii_buffer_converter, &data)) {
goto exit; goto exit;
}
return_value = binascii_a2b_hqx_impl(module, &data); return_value = binascii_a2b_hqx_impl(module, &data);
exit: exit:
@ -173,14 +180,16 @@ binascii_rlecode_hqx(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:rlecode_hqx", &data)) if (!PyArg_Parse(arg, "y*:rlecode_hqx", &data)) {
goto exit; goto exit;
}
return_value = binascii_rlecode_hqx_impl(module, &data); return_value = binascii_rlecode_hqx_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -203,14 +212,16 @@ binascii_b2a_hqx(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:b2a_hqx", &data)) if (!PyArg_Parse(arg, "y*:b2a_hqx", &data)) {
goto exit; goto exit;
}
return_value = binascii_b2a_hqx_impl(module, &data); return_value = binascii_b2a_hqx_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -233,14 +244,16 @@ binascii_rledecode_hqx(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:rledecode_hqx", &data)) if (!PyArg_Parse(arg, "y*:rledecode_hqx", &data)) {
goto exit; goto exit;
}
return_value = binascii_rledecode_hqx_impl(module, &data); return_value = binascii_rledecode_hqx_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -266,17 +279,20 @@ binascii_crc_hqx(PyModuleDef *module, PyObject *args)
unsigned int _return_value; unsigned int _return_value;
if (!PyArg_ParseTuple(args, "y*I:crc_hqx", if (!PyArg_ParseTuple(args, "y*I:crc_hqx",
&data, &crc)) &data, &crc)) {
goto exit; goto exit;
}
_return_value = binascii_crc_hqx_impl(module, &data, crc); _return_value = binascii_crc_hqx_impl(module, &data, crc);
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromUnsignedLong((unsigned long)_return_value); return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -302,17 +318,20 @@ binascii_crc32(PyModuleDef *module, PyObject *args)
unsigned int _return_value; unsigned int _return_value;
if (!PyArg_ParseTuple(args, "y*|I:crc32", if (!PyArg_ParseTuple(args, "y*|I:crc32",
&data, &crc)) &data, &crc)) {
goto exit; goto exit;
}
_return_value = binascii_crc32_impl(module, &data, crc); _return_value = binascii_crc32_impl(module, &data, crc);
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromUnsignedLong((unsigned long)_return_value); return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -338,14 +357,16 @@ binascii_b2a_hex(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:b2a_hex", &data)) if (!PyArg_Parse(arg, "y*:b2a_hex", &data)) {
goto exit; goto exit;
}
return_value = binascii_b2a_hex_impl(module, &data); return_value = binascii_b2a_hex_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -370,14 +391,16 @@ binascii_hexlify(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:hexlify", &data)) if (!PyArg_Parse(arg, "y*:hexlify", &data)) {
goto exit; goto exit;
}
return_value = binascii_hexlify_impl(module, &data); return_value = binascii_hexlify_impl(module, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -403,8 +426,9 @@ binascii_a2b_hex(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer hexstr = {NULL, NULL}; Py_buffer hexstr = {NULL, NULL};
if (!PyArg_Parse(arg, "O&:a2b_hex", ascii_buffer_converter, &hexstr)) if (!PyArg_Parse(arg, "O&:a2b_hex", ascii_buffer_converter, &hexstr)) {
goto exit; goto exit;
}
return_value = binascii_a2b_hex_impl(module, &hexstr); return_value = binascii_a2b_hex_impl(module, &hexstr);
exit: exit:
@ -435,8 +459,9 @@ binascii_unhexlify(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer hexstr = {NULL, NULL}; Py_buffer hexstr = {NULL, NULL};
if (!PyArg_Parse(arg, "O&:unhexlify", ascii_buffer_converter, &hexstr)) if (!PyArg_Parse(arg, "O&:unhexlify", ascii_buffer_converter, &hexstr)) {
goto exit; goto exit;
}
return_value = binascii_unhexlify_impl(module, &hexstr); return_value = binascii_unhexlify_impl(module, &hexstr);
exit: exit:
@ -468,8 +493,9 @@ binascii_a2b_qp(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int header = 0; int header = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|i:a2b_qp", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|i:a2b_qp", _keywords,
ascii_buffer_converter, &data, &header)) ascii_buffer_converter, &data, &header)) {
goto exit; goto exit;
}
return_value = binascii_a2b_qp_impl(module, &data, header); return_value = binascii_a2b_qp_impl(module, &data, header);
exit: exit:
@ -508,15 +534,17 @@ binascii_b2a_qp(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int header = 0; int header = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|iii:b2a_qp", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|iii:b2a_qp", _keywords,
&data, &quotetabs, &istext, &header)) &data, &quotetabs, &istext, &header)) {
goto exit; goto exit;
}
return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header); return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
/*[clinic end generated code: output=b15a24350d105251 input=a9049054013a1b77]*/ /*[clinic end generated code: output=7fb420392d78ac4d input=a9049054013a1b77]*/

74
Modules/clinic/cmathmodule.c.h
View File

@ -21,8 +21,9 @@ cmath_acos(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:acos", &z)) if (!PyArg_Parse(arg, "D:acos", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_acos_impl(module, z); _return_value = cmath_acos_impl(module, z);
@ -62,8 +63,9 @@ cmath_acosh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:acosh", &z)) if (!PyArg_Parse(arg, "D:acosh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_acosh_impl(module, z); _return_value = cmath_acosh_impl(module, z);
@ -103,8 +105,9 @@ cmath_asin(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:asin", &z)) if (!PyArg_Parse(arg, "D:asin", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_asin_impl(module, z); _return_value = cmath_asin_impl(module, z);
@ -144,8 +147,9 @@ cmath_asinh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:asinh", &z)) if (!PyArg_Parse(arg, "D:asinh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_asinh_impl(module, z); _return_value = cmath_asinh_impl(module, z);
@ -185,8 +189,9 @@ cmath_atan(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:atan", &z)) if (!PyArg_Parse(arg, "D:atan", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_atan_impl(module, z); _return_value = cmath_atan_impl(module, z);
@ -226,8 +231,9 @@ cmath_atanh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:atanh", &z)) if (!PyArg_Parse(arg, "D:atanh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_atanh_impl(module, z); _return_value = cmath_atanh_impl(module, z);
@ -267,8 +273,9 @@ cmath_cos(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:cos", &z)) if (!PyArg_Parse(arg, "D:cos", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_cos_impl(module, z); _return_value = cmath_cos_impl(module, z);
@ -308,8 +315,9 @@ cmath_cosh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:cosh", &z)) if (!PyArg_Parse(arg, "D:cosh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_cosh_impl(module, z); _return_value = cmath_cosh_impl(module, z);
@ -349,8 +357,9 @@ cmath_exp(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:exp", &z)) if (!PyArg_Parse(arg, "D:exp", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_exp_impl(module, z); _return_value = cmath_exp_impl(module, z);
@ -390,8 +399,9 @@ cmath_log10(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:log10", &z)) if (!PyArg_Parse(arg, "D:log10", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_log10_impl(module, z); _return_value = cmath_log10_impl(module, z);
@ -431,8 +441,9 @@ cmath_sin(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:sin", &z)) if (!PyArg_Parse(arg, "D:sin", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_sin_impl(module, z); _return_value = cmath_sin_impl(module, z);
@ -472,8 +483,9 @@ cmath_sinh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:sinh", &z)) if (!PyArg_Parse(arg, "D:sinh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_sinh_impl(module, z); _return_value = cmath_sinh_impl(module, z);
@ -513,8 +525,9 @@ cmath_sqrt(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:sqrt", &z)) if (!PyArg_Parse(arg, "D:sqrt", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_sqrt_impl(module, z); _return_value = cmath_sqrt_impl(module, z);
@ -554,8 +567,9 @@ cmath_tan(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:tan", &z)) if (!PyArg_Parse(arg, "D:tan", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_tan_impl(module, z); _return_value = cmath_tan_impl(module, z);
@ -595,8 +609,9 @@ cmath_tanh(PyModuleDef *module, PyObject *arg)
Py_complex z; Py_complex z;
Py_complex _return_value; Py_complex _return_value;
if (!PyArg_Parse(arg, "D:tanh", &z)) if (!PyArg_Parse(arg, "D:tanh", &z)) {
goto exit; goto exit;
}
/* modifications for z */ /* modifications for z */
errno = 0; PyFPE_START_PROTECT("complex function", goto exit); errno = 0; PyFPE_START_PROTECT("complex function", goto exit);
_return_value = cmath_tanh_impl(module, z); _return_value = cmath_tanh_impl(module, z);
@ -639,8 +654,9 @@ cmath_log(PyModuleDef *module, PyObject *args)
PyObject *y_obj = NULL; PyObject *y_obj = NULL;
if (!PyArg_ParseTuple(args, "D|O:log", if (!PyArg_ParseTuple(args, "D|O:log",
&x, &y_obj)) &x, &y_obj)) {
goto exit; goto exit;
}
return_value = cmath_log_impl(module, x, y_obj); return_value = cmath_log_impl(module, x, y_obj);
exit: exit:
@ -665,8 +681,9 @@ cmath_phase(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_complex z; Py_complex z;
if (!PyArg_Parse(arg, "D:phase", &z)) if (!PyArg_Parse(arg, "D:phase", &z)) {
goto exit; goto exit;
}
return_value = cmath_phase_impl(module, z); return_value = cmath_phase_impl(module, z);
exit: exit:
@ -693,8 +710,9 @@ cmath_polar(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_complex z; Py_complex z;
if (!PyArg_Parse(arg, "D:polar", &z)) if (!PyArg_Parse(arg, "D:polar", &z)) {
goto exit; goto exit;
}
return_value = cmath_polar_impl(module, z); return_value = cmath_polar_impl(module, z);
exit: exit:
@ -721,8 +739,9 @@ cmath_rect(PyModuleDef *module, PyObject *args)
double phi; double phi;
if (!PyArg_ParseTuple(args, "dd:rect", if (!PyArg_ParseTuple(args, "dd:rect",
&r, &phi)) &r, &phi)) {
goto exit; goto exit;
}
return_value = cmath_rect_impl(module, r, phi); return_value = cmath_rect_impl(module, r, phi);
exit: exit:
@ -747,8 +766,9 @@ cmath_isfinite(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_complex z; Py_complex z;
if (!PyArg_Parse(arg, "D:isfinite", &z)) if (!PyArg_Parse(arg, "D:isfinite", &z)) {
goto exit; goto exit;
}
return_value = cmath_isfinite_impl(module, z); return_value = cmath_isfinite_impl(module, z);
exit: exit:
@ -773,8 +793,9 @@ cmath_isnan(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_complex z; Py_complex z;
if (!PyArg_Parse(arg, "D:isnan", &z)) if (!PyArg_Parse(arg, "D:isnan", &z)) {
goto exit; goto exit;
}
return_value = cmath_isnan_impl(module, z); return_value = cmath_isnan_impl(module, z);
exit: exit:
@ -799,8 +820,9 @@ cmath_isinf(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_complex z; Py_complex z;
if (!PyArg_Parse(arg, "D:isinf", &z)) if (!PyArg_Parse(arg, "D:isinf", &z)) {
goto exit; goto exit;
}
return_value = cmath_isinf_impl(module, z); return_value = cmath_isinf_impl(module, z);
exit: exit:
@ -847,14 +869,16 @@ cmath_isclose(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int _return_value; int _return_value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "DD|$dd:isclose", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "DD|$dd:isclose", _keywords,
&a, &b, &rel_tol, &abs_tol)) &a, &b, &rel_tol, &abs_tol)) {
goto exit; goto exit;
}
_return_value = cmath_isclose_impl(module, a, b, rel_tol, abs_tol); _return_value = cmath_isclose_impl(module, a, b, rel_tol, abs_tol);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyBool_FromLong((long)_return_value); return_value = PyBool_FromLong((long)_return_value);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=229e9c48c9d27362 input=a9049054013a1b77]*/ /*[clinic end generated code: output=f166205b4beb1826 input=a9049054013a1b77]*/

14
Modules/clinic/fcntlmodule.c.h
View File

@ -33,8 +33,9 @@ fcntl_fcntl(PyModuleDef *module, PyObject *args)
PyObject *arg = NULL; PyObject *arg = NULL;
if (!PyArg_ParseTuple(args, "O&i|O:fcntl", if (!PyArg_ParseTuple(args, "O&i|O:fcntl",
conv_descriptor, &fd, &code, &arg)) conv_descriptor, &fd, &code, &arg)) {
goto exit; goto exit;
}
return_value = fcntl_fcntl_impl(module, fd, code, arg); return_value = fcntl_fcntl_impl(module, fd, code, arg);
exit: exit:
@ -91,8 +92,9 @@ fcntl_ioctl(PyModuleDef *module, PyObject *args)
int mutate_arg = 1; int mutate_arg = 1;
if (!PyArg_ParseTuple(args, "O&I|Op:ioctl", if (!PyArg_ParseTuple(args, "O&I|Op:ioctl",
conv_descriptor, &fd, &code, &ob_arg, &mutate_arg)) conv_descriptor, &fd, &code, &ob_arg, &mutate_arg)) {
goto exit; goto exit;
}
return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg); return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg);
exit: exit:
@ -122,8 +124,9 @@ fcntl_flock(PyModuleDef *module, PyObject *args)
int code; int code;
if (!PyArg_ParseTuple(args, "O&i:flock", if (!PyArg_ParseTuple(args, "O&i:flock",
conv_descriptor, &fd, &code)) conv_descriptor, &fd, &code)) {
goto exit; goto exit;
}
return_value = fcntl_flock_impl(module, fd, code); return_value = fcntl_flock_impl(module, fd, code);
exit: exit:
@ -175,11 +178,12 @@ fcntl_lockf(PyModuleDef *module, PyObject *args)
int whence = 0; int whence = 0;
if (!PyArg_ParseTuple(args, "O&i|OOi:lockf", if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
conv_descriptor, &fd, &code, &lenobj, &startobj, &whence)) conv_descriptor, &fd, &code, &lenobj, &startobj, &whence)) {
goto exit; goto exit;
}
return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence); return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=b7d6e8fc2ad09c48 input=a9049054013a1b77]*/ /*[clinic end generated code: output=b08537e9adc04ca2 input=a9049054013a1b77]*/

8
Modules/clinic/grpmodule.c.h
View File

@ -24,8 +24,9 @@ grp_getgrgid(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *id; PyObject *id;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:getgrgid", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:getgrgid", _keywords,
&id)) &id)) {
goto exit; goto exit;
}
return_value = grp_getgrgid_impl(module, id); return_value = grp_getgrgid_impl(module, id);
exit: exit:
@ -54,8 +55,9 @@ grp_getgrnam(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *name; PyObject *name;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "U:getgrnam", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "U:getgrnam", _keywords,
&name)) &name)) {
goto exit; goto exit;
}
return_value = grp_getgrnam_impl(module, name); return_value = grp_getgrnam_impl(module, name);
exit: exit:
@ -82,4 +84,4 @@ grp_getgrall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{ {
return grp_getgrall_impl(module); return grp_getgrall_impl(module);
} }
/*[clinic end generated code: output=5191c25600afb1bd input=a9049054013a1b77]*/ /*[clinic end generated code: output=a8a097520206ccd6 input=a9049054013a1b77]*/

5
Modules/clinic/md5module.c.h
View File

@ -85,11 +85,12 @@ _md5_md5(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:md5", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:md5", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _md5_md5_impl(module, string); return_value = _md5_md5_impl(module, string);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=0f803ded701aca54 input=a9049054013a1b77]*/ /*[clinic end generated code: output=d701d041d387b081 input=a9049054013a1b77]*/

482
Modules/clinic/posixmodule.c.h
View File

File diff suppressed because it is too large Load Diff

5
Modules/clinic/pwdmodule.c.h
View File

@ -33,8 +33,9 @@ pwd_getpwnam(PyModuleDef *module, PyObject *arg_)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *arg; PyObject *arg;
if (!PyArg_Parse(arg_, "U:getpwnam", &arg)) if (!PyArg_Parse(arg_, "U:getpwnam", &arg)) {
goto exit; goto exit;
}
return_value = pwd_getpwnam_impl(module, arg); return_value = pwd_getpwnam_impl(module, arg);
exit: exit:
@ -68,4 +69,4 @@ pwd_getpwall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
#ifndef PWD_GETPWALL_METHODDEF #ifndef PWD_GETPWALL_METHODDEF
#define PWD_GETPWALL_METHODDEF #define PWD_GETPWALL_METHODDEF
#endif /* !defined(PWD_GETPWALL_METHODDEF) */ #endif /* !defined(PWD_GETPWALL_METHODDEF) */
/*[clinic end generated code: output=2ed0ecf34fd3f98f input=a9049054013a1b77]*/ /*[clinic end generated code: output=f807c89b44be0fde input=a9049054013a1b77]*/

23
Modules/clinic/pyexpat.c.h
View File

@ -25,8 +25,9 @@ pyexpat_xmlparser_Parse(xmlparseobject *self, PyObject *args)
int isfinal = 0; int isfinal = 0;
if (!PyArg_ParseTuple(args, "O|i:Parse", if (!PyArg_ParseTuple(args, "O|i:Parse",
&data, &isfinal)) &data, &isfinal)) {
goto exit; goto exit;
}
return_value = pyexpat_xmlparser_Parse_impl(self, data, isfinal); return_value = pyexpat_xmlparser_Parse_impl(self, data, isfinal);
exit: exit:
@ -60,8 +61,9 @@ pyexpat_xmlparser_SetBase(xmlparseobject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
const char *base; const char *base;
if (!PyArg_Parse(arg, "s:SetBase", &base)) if (!PyArg_Parse(arg, "s:SetBase", &base)) {
goto exit; goto exit;
}
return_value = pyexpat_xmlparser_SetBase_impl(self, base); return_value = pyexpat_xmlparser_SetBase_impl(self, base);
exit: exit:
@ -129,8 +131,9 @@ pyexpat_xmlparser_ExternalEntityParserCreate(xmlparseobject *self, PyObject *arg
const char *encoding = NULL; const char *encoding = NULL;
if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate", if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",
&context, &encoding)) &context, &encoding)) {
goto exit; goto exit;
}
return_value = pyexpat_xmlparser_ExternalEntityParserCreate_impl(self, context, encoding); return_value = pyexpat_xmlparser_ExternalEntityParserCreate_impl(self, context, encoding);
exit: exit:
@ -160,8 +163,9 @@ pyexpat_xmlparser_SetParamEntityParsing(xmlparseobject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int flag; int flag;
if (!PyArg_Parse(arg, "i:SetParamEntityParsing", &flag)) if (!PyArg_Parse(arg, "i:SetParamEntityParsing", &flag)) {
goto exit; goto exit;
}
return_value = pyexpat_xmlparser_SetParamEntityParsing_impl(self, flag); return_value = pyexpat_xmlparser_SetParamEntityParsing_impl(self, flag);
exit: exit:
@ -193,8 +197,9 @@ pyexpat_xmlparser_UseForeignDTD(xmlparseobject *self, PyObject *args)
int flag = 1; int flag = 1;
if (!PyArg_ParseTuple(args, "|p:UseForeignDTD", if (!PyArg_ParseTuple(args, "|p:UseForeignDTD",
&flag)) &flag)) {
goto exit; goto exit;
}
return_value = pyexpat_xmlparser_UseForeignDTD_impl(self, flag); return_value = pyexpat_xmlparser_UseForeignDTD_impl(self, flag);
exit: exit:
@ -244,8 +249,9 @@ pyexpat_ParserCreate(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *intern = NULL; PyObject *intern = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|zzO:ParserCreate", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|zzO:ParserCreate", _keywords,
&encoding, &namespace_separator, &intern)) &encoding, &namespace_separator, &intern)) {
goto exit; goto exit;
}
return_value = pyexpat_ParserCreate_impl(module, encoding, namespace_separator, intern); return_value = pyexpat_ParserCreate_impl(module, encoding, namespace_separator, intern);
exit: exit:
@ -270,8 +276,9 @@ pyexpat_ErrorString(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
long code; long code;
if (!PyArg_Parse(arg, "l:ErrorString", &code)) if (!PyArg_Parse(arg, "l:ErrorString", &code)) {
goto exit; goto exit;
}
return_value = pyexpat_ErrorString_impl(module, code); return_value = pyexpat_ErrorString_impl(module, code);
exit: exit:
@ -281,4 +288,4 @@ exit:
#ifndef PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF #ifndef PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF #define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#endif /* !defined(PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF) */ #endif /* !defined(PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF) */
/*[clinic end generated code: output=bf4d99c9702d8a6c input=a9049054013a1b77]*/ /*[clinic end generated code: output=71a60d709647fbe3 input=a9049054013a1b77]*/

5
Modules/clinic/sha1module.c.h
View File

@ -85,11 +85,12 @@ _sha1_sha1(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha1", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha1", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _sha1_sha1_impl(module, string); return_value = _sha1_sha1_impl(module, string);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=be19102f3120490a input=a9049054013a1b77]*/ /*[clinic end generated code: output=40df3f8955919e72 input=a9049054013a1b77]*/

8
Modules/clinic/sha256module.c.h
View File

@ -85,8 +85,9 @@ _sha256_sha256(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha256", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha256", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _sha256_sha256_impl(module, string); return_value = _sha256_sha256_impl(module, string);
exit: exit:
@ -113,11 +114,12 @@ _sha256_sha224(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha224", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha224", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _sha256_sha224_impl(module, string); return_value = _sha256_sha224_impl(module, string);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=354cedf3b632c7b2 input=a9049054013a1b77]*/ /*[clinic end generated code: output=e85cc4a223371d84 input=a9049054013a1b77]*/

8
Modules/clinic/sha512module.c.h
View File

@ -103,8 +103,9 @@ _sha512_sha512(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha512", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha512", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _sha512_sha512_impl(module, string); return_value = _sha512_sha512_impl(module, string);
exit: exit:
@ -135,8 +136,9 @@ _sha512_sha384(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *string = NULL; PyObject *string = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha384", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:sha384", _keywords,
&string)) &string)) {
goto exit; goto exit;
}
return_value = _sha512_sha384_impl(module, string); return_value = _sha512_sha384_impl(module, string);
exit: exit:
@ -168,4 +170,4 @@ exit:
#ifndef _SHA512_SHA384_METHODDEF #ifndef _SHA512_SHA384_METHODDEF
#define _SHA512_SHA384_METHODDEF #define _SHA512_SHA384_METHODDEF
#endif /* !defined(_SHA512_SHA384_METHODDEF) */ #endif /* !defined(_SHA512_SHA384_METHODDEF) */
/*[clinic end generated code: output=1c7d385731fee7c0 input=a9049054013a1b77]*/ /*[clinic end generated code: output=845af47cea22e2a1 input=a9049054013a1b77]*/

32
Modules/clinic/signalmodule.c.h
View File

@ -23,11 +23,13 @@ signal_alarm(PyModuleDef *module, PyObject *arg)
int seconds; int seconds;
long _return_value; long _return_value;
if (!PyArg_Parse(arg, "i:alarm", &seconds)) if (!PyArg_Parse(arg, "i:alarm", &seconds)) {
goto exit; goto exit;
}
_return_value = signal_alarm_impl(module, seconds); _return_value = signal_alarm_impl(module, seconds);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -85,8 +87,9 @@ signal_signal(PyModuleDef *module, PyObject *args)
PyObject *handler; PyObject *handler;
if (!PyArg_ParseTuple(args, "iO:signal", if (!PyArg_ParseTuple(args, "iO:signal",
&signalnum, &handler)) &signalnum, &handler)) {
goto exit; goto exit;
}
return_value = signal_signal_impl(module, signalnum, handler); return_value = signal_signal_impl(module, signalnum, handler);
exit: exit:
@ -117,8 +120,9 @@ signal_getsignal(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int signalnum; int signalnum;
if (!PyArg_Parse(arg, "i:getsignal", &signalnum)) if (!PyArg_Parse(arg, "i:getsignal", &signalnum)) {
goto exit; goto exit;
}
return_value = signal_getsignal_impl(module, signalnum); return_value = signal_getsignal_impl(module, signalnum);
exit: exit:
@ -150,8 +154,9 @@ signal_siginterrupt(PyModuleDef *module, PyObject *args)
int flag; int flag;
if (!PyArg_ParseTuple(args, "ii:siginterrupt", if (!PyArg_ParseTuple(args, "ii:siginterrupt",
&signalnum, &flag)) &signalnum, &flag)) {
goto exit; goto exit;
}
return_value = signal_siginterrupt_impl(module, signalnum, flag); return_value = signal_siginterrupt_impl(module, signalnum, flag);
exit: exit:
@ -189,8 +194,9 @@ signal_setitimer(PyModuleDef *module, PyObject *args)
double interval = 0.0; double interval = 0.0;
if (!PyArg_ParseTuple(args, "id|d:setitimer", if (!PyArg_ParseTuple(args, "id|d:setitimer",
&which, &seconds, &interval)) &which, &seconds, &interval)) {
goto exit; goto exit;
}
return_value = signal_setitimer_impl(module, which, seconds, interval); return_value = signal_setitimer_impl(module, which, seconds, interval);
exit: exit:
@ -219,8 +225,9 @@ signal_getitimer(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int which; int which;
if (!PyArg_Parse(arg, "i:getitimer", &which)) if (!PyArg_Parse(arg, "i:getitimer", &which)) {
goto exit; goto exit;
}
return_value = signal_getitimer_impl(module, which); return_value = signal_getitimer_impl(module, which);
exit: exit:
@ -251,8 +258,9 @@ signal_pthread_sigmask(PyModuleDef *module, PyObject *args)
PyObject *mask; PyObject *mask;
if (!PyArg_ParseTuple(args, "iO:pthread_sigmask", if (!PyArg_ParseTuple(args, "iO:pthread_sigmask",
&how, &mask)) &how, &mask)) {
goto exit; goto exit;
}
return_value = signal_pthread_sigmask_impl(module, how, mask); return_value = signal_pthread_sigmask_impl(module, how, mask);
exit: exit:
@ -344,8 +352,9 @@ signal_sigtimedwait(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "sigtimedwait", if (!PyArg_UnpackTuple(args, "sigtimedwait",
2, 2, 2, 2,
&sigset, &timeout_obj)) &sigset, &timeout_obj)) {
goto exit; goto exit;
}
return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj); return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
exit: exit:
@ -376,8 +385,9 @@ signal_pthread_kill(PyModuleDef *module, PyObject *args)
int signalnum; int signalnum;
if (!PyArg_ParseTuple(args, "li:pthread_kill", if (!PyArg_ParseTuple(args, "li:pthread_kill",
&thread_id, &signalnum)) &thread_id, &signalnum)) {
goto exit; goto exit;
}
return_value = signal_pthread_kill_impl(module, thread_id, signalnum); return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
exit: exit:
@ -429,4 +439,4 @@ exit:
#ifndef SIGNAL_PTHREAD_KILL_METHODDEF #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
#define SIGNAL_PTHREAD_KILL_METHODDEF #define SIGNAL_PTHREAD_KILL_METHODDEF
#endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */ #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
/*[clinic end generated code: output=b99278c16c40ea43 input=a9049054013a1b77]*/ /*[clinic end generated code: output=4b9519180a091536 input=a9049054013a1b77]*/

5
Modules/clinic/spwdmodule.c.h
View File

@ -24,8 +24,9 @@ spwd_getspnam(PyModuleDef *module, PyObject *arg_)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *arg; PyObject *arg;
if (!PyArg_Parse(arg_, "U:getspnam", &arg)) if (!PyArg_Parse(arg_, "U:getspnam", &arg)) {
goto exit; goto exit;
}
return_value = spwd_getspnam_impl(module, arg); return_value = spwd_getspnam_impl(module, arg);
exit: exit:
@ -65,4 +66,4 @@ spwd_getspall(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
#ifndef SPWD_GETSPALL_METHODDEF #ifndef SPWD_GETSPALL_METHODDEF
#define SPWD_GETSPALL_METHODDEF #define SPWD_GETSPALL_METHODDEF
#endif /* !defined(SPWD_GETSPALL_METHODDEF) */ #endif /* !defined(SPWD_GETSPALL_METHODDEF) */
/*[clinic end generated code: output=6c178830413f7763 input=a9049054013a1b77]*/ /*[clinic end generated code: output=2b7a384447e5f1e3 input=a9049054013a1b77]*/

44
Modules/clinic/unicodedata.c.h
View File

@ -27,8 +27,9 @@ unicodedata_UCD_decimal(PyObject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:decimal", if (!PyArg_ParseTuple(args, "C|O:decimal",
&chr, &default_value)) &chr, &default_value)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_decimal_impl(self, chr, default_value); return_value = unicodedata_UCD_decimal_impl(self, chr, default_value);
exit: exit:
@ -59,8 +60,9 @@ unicodedata_UCD_digit(PyObject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:digit", if (!PyArg_ParseTuple(args, "C|O:digit",
&chr, &default_value)) &chr, &default_value)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_digit_impl(self, chr, default_value); return_value = unicodedata_UCD_digit_impl(self, chr, default_value);
exit: exit:
@ -92,8 +94,9 @@ unicodedata_UCD_numeric(PyObject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:numeric", if (!PyArg_ParseTuple(args, "C|O:numeric",
&chr, &default_value)) &chr, &default_value)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_numeric_impl(self, chr, default_value); return_value = unicodedata_UCD_numeric_impl(self, chr, default_value);
exit: exit:
@ -118,8 +121,9 @@ unicodedata_UCD_category(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int chr; int chr;
if (!PyArg_Parse(arg, "C:category", &chr)) if (!PyArg_Parse(arg, "C:category", &chr)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_category_impl(self, chr); return_value = unicodedata_UCD_category_impl(self, chr);
exit: exit:
@ -146,8 +150,9 @@ unicodedata_UCD_bidirectional(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int chr; int chr;
if (!PyArg_Parse(arg, "C:bidirectional", &chr)) if (!PyArg_Parse(arg, "C:bidirectional", &chr)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_bidirectional_impl(self, chr); return_value = unicodedata_UCD_bidirectional_impl(self, chr);
exit: exit:
@ -175,11 +180,13 @@ unicodedata_UCD_combining(PyObject *self, PyObject *arg)
int chr; int chr;
int _return_value; int _return_value;
if (!PyArg_Parse(arg, "C:combining", &chr)) if (!PyArg_Parse(arg, "C:combining", &chr)) {
goto exit; goto exit;
}
_return_value = unicodedata_UCD_combining_impl(self, chr); _return_value = unicodedata_UCD_combining_impl(self, chr);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -208,11 +215,13 @@ unicodedata_UCD_mirrored(PyObject *self, PyObject *arg)
int chr; int chr;
int _return_value; int _return_value;
if (!PyArg_Parse(arg, "C:mirrored", &chr)) if (!PyArg_Parse(arg, "C:mirrored", &chr)) {
goto exit; goto exit;
}
_return_value = unicodedata_UCD_mirrored_impl(self, chr); _return_value = unicodedata_UCD_mirrored_impl(self, chr);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -237,8 +246,9 @@ unicodedata_UCD_east_asian_width(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int chr; int chr;
if (!PyArg_Parse(arg, "C:east_asian_width", &chr)) if (!PyArg_Parse(arg, "C:east_asian_width", &chr)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_east_asian_width_impl(self, chr); return_value = unicodedata_UCD_east_asian_width_impl(self, chr);
exit: exit:
@ -265,8 +275,9 @@ unicodedata_UCD_decomposition(PyObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int chr; int chr;
if (!PyArg_Parse(arg, "C:decomposition", &chr)) if (!PyArg_Parse(arg, "C:decomposition", &chr)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_decomposition_impl(self, chr); return_value = unicodedata_UCD_decomposition_impl(self, chr);
exit: exit:
@ -296,8 +307,9 @@ unicodedata_UCD_normalize(PyObject *self, PyObject *args)
PyObject *input; PyObject *input;
if (!PyArg_ParseTuple(args, "sO!:normalize", if (!PyArg_ParseTuple(args, "sO!:normalize",
&form, &PyUnicode_Type, &input)) &form, &PyUnicode_Type, &input)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_normalize_impl(self, form, input); return_value = unicodedata_UCD_normalize_impl(self, form, input);
exit: exit:
@ -327,8 +339,9 @@ unicodedata_UCD_name(PyObject *self, PyObject *args)
PyObject *default_value = NULL; PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:name", if (!PyArg_ParseTuple(args, "C|O:name",
&chr, &default_value)) &chr, &default_value)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_name_impl(self, chr, default_value); return_value = unicodedata_UCD_name_impl(self, chr, default_value);
exit: exit:
@ -358,11 +371,12 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
const char *name; const char *name;
Py_ssize_clean_t name_length; Py_ssize_clean_t name_length;
if (!PyArg_Parse(arg, "s#:lookup", &name, &name_length)) if (!PyArg_Parse(arg, "s#:lookup", &name, &name_length)) {
goto exit; goto exit;
}
return_value = unicodedata_UCD_lookup_impl(self, name, name_length); return_value = unicodedata_UCD_lookup_impl(self, name, name_length);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=4f8da33c6bc6efc9 input=a9049054013a1b77]*/ /*[clinic end generated code: output=5313ce129da87b2f input=a9049054013a1b77]*/

53
Modules/clinic/zlibmodule.c.h
View File

@ -28,14 +28,16 @@ zlib_compress(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int level = Z_DEFAULT_COMPRESSION; int level = Z_DEFAULT_COMPRESSION;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i:compress", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i:compress", _keywords,
&data, &level)) &data, &level)) {
goto exit; goto exit;
}
return_value = zlib_compress_impl(module, &data, level); return_value = zlib_compress_impl(module, &data, level);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -69,14 +71,16 @@ zlib_decompress(PyModuleDef *module, PyObject *args)
unsigned int bufsize = DEF_BUF_SIZE; unsigned int bufsize = DEF_BUF_SIZE;
if (!PyArg_ParseTuple(args, "y*|iO&:decompress", if (!PyArg_ParseTuple(args, "y*|iO&:decompress",
&data, &wbits, capped_uint_converter, &bufsize)) &data, &wbits, capped_uint_converter, &bufsize)) {
goto exit; goto exit;
}
return_value = zlib_decompress_impl(module, &data, wbits, bufsize); return_value = zlib_decompress_impl(module, &data, wbits, bufsize);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -131,14 +135,16 @@ zlib_compressobj(PyModuleDef *module, PyObject *args, PyObject *kwargs)
Py_buffer zdict = {NULL, NULL}; Py_buffer zdict = {NULL, NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iiiiiy*:compressobj", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iiiiiy*:compressobj", _keywords,
&level, &method, &wbits, &memLevel, &strategy, &zdict)) &level, &method, &wbits, &memLevel, &strategy, &zdict)) {
goto exit; goto exit;
}
return_value = zlib_compressobj_impl(module, level, method, wbits, memLevel, strategy, &zdict); return_value = zlib_compressobj_impl(module, level, method, wbits, memLevel, strategy, &zdict);
exit: exit:
/* Cleanup for zdict */ /* Cleanup for zdict */
if (zdict.obj) if (zdict.obj) {
PyBuffer_Release(&zdict); PyBuffer_Release(&zdict);
}
return return_value; return return_value;
} }
@ -170,8 +176,9 @@ zlib_decompressobj(PyModuleDef *module, PyObject *args, PyObject *kwargs)
PyObject *zdict = NULL; PyObject *zdict = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iO:decompressobj", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iO:decompressobj", _keywords,
&wbits, &zdict)) &wbits, &zdict)) {
goto exit; goto exit;
}
return_value = zlib_decompressobj_impl(module, wbits, zdict); return_value = zlib_decompressobj_impl(module, wbits, zdict);
exit: exit:
@ -203,14 +210,16 @@ zlib_Compress_compress(compobject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL}; Py_buffer data = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:compress", &data)) if (!PyArg_Parse(arg, "y*:compress", &data)) {
goto exit; goto exit;
}
return_value = zlib_Compress_compress_impl(self, &data); return_value = zlib_Compress_compress_impl(self, &data);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -247,14 +256,16 @@ zlib_Decompress_decompress(compobject *self, PyObject *args)
unsigned int max_length = 0; unsigned int max_length = 0;
if (!PyArg_ParseTuple(args, "y*|O&:decompress", if (!PyArg_ParseTuple(args, "y*|O&:decompress",
&data, capped_uint_converter, &max_length)) &data, capped_uint_converter, &max_length)) {
goto exit; goto exit;
}
return_value = zlib_Decompress_decompress_impl(self, &data, max_length); return_value = zlib_Decompress_decompress_impl(self, &data, max_length);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -284,8 +295,9 @@ zlib_Compress_flush(compobject *self, PyObject *args)
int mode = Z_FINISH; int mode = Z_FINISH;
if (!PyArg_ParseTuple(args, "|i:flush", if (!PyArg_ParseTuple(args, "|i:flush",
&mode)) &mode)) {
goto exit; goto exit;
}
return_value = zlib_Compress_flush_impl(self, mode); return_value = zlib_Compress_flush_impl(self, mode);
exit: exit:
@ -358,8 +370,9 @@ zlib_Decompress_flush(compobject *self, PyObject *args)
unsigned int length = DEF_BUF_SIZE; unsigned int length = DEF_BUF_SIZE;
if (!PyArg_ParseTuple(args, "|O&:flush", if (!PyArg_ParseTuple(args, "|O&:flush",
capped_uint_converter, &length)) capped_uint_converter, &length)) {
goto exit; goto exit;
}
return_value = zlib_Decompress_flush_impl(self, length); return_value = zlib_Decompress_flush_impl(self, length);
exit: exit:
@ -391,14 +404,16 @@ zlib_adler32(PyModuleDef *module, PyObject *args)
unsigned int value = 1; unsigned int value = 1;
if (!PyArg_ParseTuple(args, "y*|I:adler32", if (!PyArg_ParseTuple(args, "y*|I:adler32",
&data, &value)) &data, &value)) {
goto exit; goto exit;
}
return_value = zlib_adler32_impl(module, &data, value); return_value = zlib_adler32_impl(module, &data, value);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -428,14 +443,16 @@ zlib_crc32(PyModuleDef *module, PyObject *args)
unsigned int value = 0; unsigned int value = 0;
if (!PyArg_ParseTuple(args, "y*|I:crc32", if (!PyArg_ParseTuple(args, "y*|I:crc32",
&data, &value)) &data, &value)) {
goto exit; goto exit;
}
return_value = zlib_crc32_impl(module, &data, value); return_value = zlib_crc32_impl(module, &data, value);
exit: exit:
/* Cleanup for data */ /* Cleanup for data */
if (data.obj) if (data.obj) {
PyBuffer_Release(&data); PyBuffer_Release(&data);
}
return return_value; return return_value;
} }
@ -443,4 +460,4 @@ exit:
#ifndef ZLIB_COMPRESS_COPY_METHODDEF #ifndef ZLIB_COMPRESS_COPY_METHODDEF
#define ZLIB_COMPRESS_COPY_METHODDEF #define ZLIB_COMPRESS_COPY_METHODDEF
#endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */ #endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */
/*[clinic end generated code: output=8669ba9266c78433 input=a9049054013a1b77]*/ /*[clinic end generated code: output=9bd8a093baa653b2 input=a9049054013a1b77]*/

65
Objects/clinic/bytearrayobject.c.h
View File

@ -65,12 +65,14 @@ bytearray_translate(PyByteArrayObject *self, PyObject *args)
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 1: case 1:
if (!PyArg_ParseTuple(args, "O:translate", &table)) if (!PyArg_ParseTuple(args, "O:translate", &table)) {
goto exit; goto exit;
}
break; break;
case 2: case 2:
if (!PyArg_ParseTuple(args, "OO:translate", &table, &deletechars)) if (!PyArg_ParseTuple(args, "OO:translate", &table, &deletechars)) {
goto exit; goto exit;
}
group_right_1 = 1; group_right_1 = 1;
break; break;
default: default:
@ -108,17 +110,20 @@ bytearray_maketrans(void *null, PyObject *args)
Py_buffer to = {NULL, NULL}; Py_buffer to = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:maketrans", if (!PyArg_ParseTuple(args, "y*y*:maketrans",
&frm, &to)) &frm, &to)) {
goto exit; goto exit;
}
return_value = bytearray_maketrans_impl(&frm, &to); return_value = bytearray_maketrans_impl(&frm, &to);
exit: exit:
/* Cleanup for frm */ /* Cleanup for frm */
if (frm.obj) if (frm.obj) {
PyBuffer_Release(&frm); PyBuffer_Release(&frm);
}
/* Cleanup for to */ /* Cleanup for to */
if (to.obj) if (to.obj) {
PyBuffer_Release(&to); PyBuffer_Release(&to);
}
return return_value; return return_value;
} }
@ -152,17 +157,20 @@ bytearray_replace(PyByteArrayObject *self, PyObject *args)
Py_ssize_t count = -1; Py_ssize_t count = -1;
if (!PyArg_ParseTuple(args, "y*y*|n:replace", if (!PyArg_ParseTuple(args, "y*y*|n:replace",
&old, &new, &count)) &old, &new, &count)) {
goto exit; goto exit;
}
return_value = bytearray_replace_impl(self, &old, &new, count); return_value = bytearray_replace_impl(self, &old, &new, count);
exit: exit:
/* Cleanup for old */ /* Cleanup for old */
if (old.obj) if (old.obj) {
PyBuffer_Release(&old); PyBuffer_Release(&old);
}
/* Cleanup for new */ /* Cleanup for new */
if (new.obj) if (new.obj) {
PyBuffer_Release(&new); PyBuffer_Release(&new);
}
return return_value; return return_value;
} }
@ -197,8 +205,9 @@ bytearray_split(PyByteArrayObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t maxsplit = -1; Py_ssize_t maxsplit = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:split", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:split", _keywords,
&sep, &maxsplit)) &sep, &maxsplit)) {
goto exit; goto exit;
}
return_value = bytearray_split_impl(self, sep, maxsplit); return_value = bytearray_split_impl(self, sep, maxsplit);
exit: exit:
@ -269,8 +278,9 @@ bytearray_rsplit(PyByteArrayObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t maxsplit = -1; Py_ssize_t maxsplit = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:rsplit", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:rsplit", _keywords,
&sep, &maxsplit)) &sep, &maxsplit)) {
goto exit; goto exit;
}
return_value = bytearray_rsplit_impl(self, sep, maxsplit); return_value = bytearray_rsplit_impl(self, sep, maxsplit);
exit: exit:
@ -320,8 +330,9 @@ bytearray_insert(PyByteArrayObject *self, PyObject *args)
int item; int item;
if (!PyArg_ParseTuple(args, "nO&:insert", if (!PyArg_ParseTuple(args, "nO&:insert",
&index, _getbytevalue, &item)) &index, _getbytevalue, &item)) {
goto exit; goto exit;
}
return_value = bytearray_insert_impl(self, index, item); return_value = bytearray_insert_impl(self, index, item);
exit: exit:
@ -349,8 +360,9 @@ bytearray_append(PyByteArrayObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int item; int item;
if (!PyArg_Parse(arg, "O&:append", _getbytevalue, &item)) if (!PyArg_Parse(arg, "O&:append", _getbytevalue, &item)) {
goto exit; goto exit;
}
return_value = bytearray_append_impl(self, item); return_value = bytearray_append_impl(self, item);
exit: exit:
@ -394,8 +406,9 @@ bytearray_pop(PyByteArrayObject *self, PyObject *args)
Py_ssize_t index = -1; Py_ssize_t index = -1;
if (!PyArg_ParseTuple(args, "|n:pop", if (!PyArg_ParseTuple(args, "|n:pop",
&index)) &index)) {
goto exit; goto exit;
}
return_value = bytearray_pop_impl(self, index); return_value = bytearray_pop_impl(self, index);
exit: exit:
@ -423,8 +436,9 @@ bytearray_remove(PyByteArrayObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int value; int value;
if (!PyArg_Parse(arg, "O&:remove", _getbytevalue, &value)) if (!PyArg_Parse(arg, "O&:remove", _getbytevalue, &value)) {
goto exit; goto exit;
}
return_value = bytearray_remove_impl(self, value); return_value = bytearray_remove_impl(self, value);
exit: exit:
@ -453,8 +467,9 @@ bytearray_strip(PyByteArrayObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "strip", if (!PyArg_UnpackTuple(args, "strip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytearray_strip_impl(self, bytes); return_value = bytearray_strip_impl(self, bytes);
exit: exit:
@ -483,8 +498,9 @@ bytearray_lstrip(PyByteArrayObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "lstrip", if (!PyArg_UnpackTuple(args, "lstrip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytearray_lstrip_impl(self, bytes); return_value = bytearray_lstrip_impl(self, bytes);
exit: exit:
@ -513,8 +529,9 @@ bytearray_rstrip(PyByteArrayObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "rstrip", if (!PyArg_UnpackTuple(args, "rstrip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytearray_rstrip_impl(self, bytes); return_value = bytearray_rstrip_impl(self, bytes);
exit: exit:
@ -552,8 +569,9 @@ bytearray_decode(PyByteArrayObject *self, PyObject *args, PyObject *kwargs)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:decode", _keywords,
&encoding, &errors)) &encoding, &errors)) {
goto exit; goto exit;
}
return_value = bytearray_decode_impl(self, encoding, errors); return_value = bytearray_decode_impl(self, encoding, errors);
exit: exit:
@ -596,8 +614,9 @@ bytearray_splitlines(PyByteArrayObject *self, PyObject *args, PyObject *kwargs)
int keepends = 0; int keepends = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:splitlines", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:splitlines", _keywords,
&keepends)) &keepends)) {
goto exit; goto exit;
}
return_value = bytearray_splitlines_impl(self, keepends); return_value = bytearray_splitlines_impl(self, keepends);
exit: exit:
@ -625,8 +644,9 @@ bytearray_fromhex(PyTypeObject *cls, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *string; PyObject *string;
if (!PyArg_Parse(arg, "U:fromhex", &string)) if (!PyArg_Parse(arg, "U:fromhex", &string)) {
goto exit; goto exit;
}
return_value = bytearray_fromhex_impl((PyObject*)cls, string); return_value = bytearray_fromhex_impl((PyObject*)cls, string);
exit: exit:
@ -670,8 +690,9 @@ bytearray_reduce_ex(PyByteArrayObject *self, PyObject *args)
int proto = 0; int proto = 0;
if (!PyArg_ParseTuple(args, "|i:__reduce_ex__", if (!PyArg_ParseTuple(args, "|i:__reduce_ex__",
&proto)) &proto)) {
goto exit; goto exit;
}
return_value = bytearray_reduce_ex_impl(self, proto); return_value = bytearray_reduce_ex_impl(self, proto);
exit: exit:
@ -695,4 +716,4 @@ bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
{ {
return bytearray_sizeof_impl(self); return bytearray_sizeof_impl(self);
} }
/*[clinic end generated code: output=966c15ff22c5e243 input=a9049054013a1b77]*/ /*[clinic end generated code: output=044a6c26a836bcfe input=a9049054013a1b77]*/

62
Objects/clinic/bytesobject.c.h
View File

@ -31,8 +31,9 @@ bytes_split(PyBytesObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t maxsplit = -1; Py_ssize_t maxsplit = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:split", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:split", _keywords,
&sep, &maxsplit)) &sep, &maxsplit)) {
goto exit; goto exit;
}
return_value = bytes_split_impl(self, sep, maxsplit); return_value = bytes_split_impl(self, sep, maxsplit);
exit: exit:
@ -64,14 +65,16 @@ bytes_partition(PyBytesObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer sep = {NULL, NULL}; Py_buffer sep = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:partition", &sep)) if (!PyArg_Parse(arg, "y*:partition", &sep)) {
goto exit; goto exit;
}
return_value = bytes_partition_impl(self, &sep); return_value = bytes_partition_impl(self, &sep);
exit: exit:
/* Cleanup for sep */ /* Cleanup for sep */
if (sep.obj) if (sep.obj) {
PyBuffer_Release(&sep); PyBuffer_Release(&sep);
}
return return_value; return return_value;
} }
@ -101,14 +104,16 @@ bytes_rpartition(PyBytesObject *self, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_buffer sep = {NULL, NULL}; Py_buffer sep = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:rpartition", &sep)) if (!PyArg_Parse(arg, "y*:rpartition", &sep)) {
goto exit; goto exit;
}
return_value = bytes_rpartition_impl(self, &sep); return_value = bytes_rpartition_impl(self, &sep);
exit: exit:
/* Cleanup for sep */ /* Cleanup for sep */
if (sep.obj) if (sep.obj) {
PyBuffer_Release(&sep); PyBuffer_Release(&sep);
}
return return_value; return return_value;
} }
@ -144,8 +149,9 @@ bytes_rsplit(PyBytesObject *self, PyObject *args, PyObject *kwargs)
Py_ssize_t maxsplit = -1; Py_ssize_t maxsplit = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:rsplit", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|On:rsplit", _keywords,
&sep, &maxsplit)) &sep, &maxsplit)) {
goto exit; goto exit;
}
return_value = bytes_rsplit_impl(self, sep, maxsplit); return_value = bytes_rsplit_impl(self, sep, maxsplit);
exit: exit:
@ -189,8 +195,9 @@ bytes_strip(PyBytesObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "strip", if (!PyArg_UnpackTuple(args, "strip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytes_strip_impl(self, bytes); return_value = bytes_strip_impl(self, bytes);
exit: exit:
@ -219,8 +226,9 @@ bytes_lstrip(PyBytesObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "lstrip", if (!PyArg_UnpackTuple(args, "lstrip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytes_lstrip_impl(self, bytes); return_value = bytes_lstrip_impl(self, bytes);
exit: exit:
@ -249,8 +257,9 @@ bytes_rstrip(PyBytesObject *self, PyObject *args)
if (!PyArg_UnpackTuple(args, "rstrip", if (!PyArg_UnpackTuple(args, "rstrip",
0, 1, 0, 1,
&bytes)) &bytes)) {
goto exit; goto exit;
}
return_value = bytes_rstrip_impl(self, bytes); return_value = bytes_rstrip_impl(self, bytes);
exit: exit:
@ -284,12 +293,14 @@ bytes_translate(PyBytesObject *self, PyObject *args)
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 1: case 1:
if (!PyArg_ParseTuple(args, "O:translate", &table)) if (!PyArg_ParseTuple(args, "O:translate", &table)) {
goto exit; goto exit;
}
break; break;
case 2: case 2:
if (!PyArg_ParseTuple(args, "OO:translate", &table, &deletechars)) if (!PyArg_ParseTuple(args, "OO:translate", &table, &deletechars)) {
goto exit; goto exit;
}
group_right_1 = 1; group_right_1 = 1;
break; break;
default: default:
@ -327,17 +338,20 @@ bytes_maketrans(void *null, PyObject *args)
Py_buffer to = {NULL, NULL}; Py_buffer to = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:maketrans", if (!PyArg_ParseTuple(args, "y*y*:maketrans",
&frm, &to)) &frm, &to)) {
goto exit; goto exit;
}
return_value = bytes_maketrans_impl(&frm, &to); return_value = bytes_maketrans_impl(&frm, &to);
exit: exit:
/* Cleanup for frm */ /* Cleanup for frm */
if (frm.obj) if (frm.obj) {
PyBuffer_Release(&frm); PyBuffer_Release(&frm);
}
/* Cleanup for to */ /* Cleanup for to */
if (to.obj) if (to.obj) {
PyBuffer_Release(&to); PyBuffer_Release(&to);
}
return return_value; return return_value;
} }
@ -371,17 +385,20 @@ bytes_replace(PyBytesObject *self, PyObject *args)
Py_ssize_t count = -1; Py_ssize_t count = -1;
if (!PyArg_ParseTuple(args, "y*y*|n:replace", if (!PyArg_ParseTuple(args, "y*y*|n:replace",
&old, &new, &count)) &old, &new, &count)) {
goto exit; goto exit;
}
return_value = bytes_replace_impl(self, &old, &new, count); return_value = bytes_replace_impl(self, &old, &new, count);
exit: exit:
/* Cleanup for old */ /* Cleanup for old */
if (old.obj) if (old.obj) {
PyBuffer_Release(&old); PyBuffer_Release(&old);
}
/* Cleanup for new */ /* Cleanup for new */
if (new.obj) if (new.obj) {
PyBuffer_Release(&new); PyBuffer_Release(&new);
}
return return_value; return return_value;
} }
@ -417,8 +434,9 @@ bytes_decode(PyBytesObject *self, PyObject *args, PyObject *kwargs)
const char *errors = NULL; const char *errors = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:decode", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:decode", _keywords,
&encoding, &errors)) &encoding, &errors)) {
goto exit; goto exit;
}
return_value = bytes_decode_impl(self, encoding, errors); return_value = bytes_decode_impl(self, encoding, errors);
exit: exit:
@ -448,8 +466,9 @@ bytes_splitlines(PyBytesObject *self, PyObject *args, PyObject *kwargs)
int keepends = 0; int keepends = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:splitlines", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:splitlines", _keywords,
&keepends)) &keepends)) {
goto exit; goto exit;
}
return_value = bytes_splitlines_impl(self, keepends); return_value = bytes_splitlines_impl(self, keepends);
exit: exit:
@ -477,11 +496,12 @@ bytes_fromhex(PyTypeObject *type, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *string; PyObject *string;
if (!PyArg_Parse(arg, "U:fromhex", &string)) if (!PyArg_Parse(arg, "U:fromhex", &string)) {
goto exit; goto exit;
}
return_value = bytes_fromhex_impl(type, string); return_value = bytes_fromhex_impl(type, string);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=d0e9f5a1c0682910 input=a9049054013a1b77]*/ /*[clinic end generated code: output=6fe884a74e7d49cf input=a9049054013a1b77]*/

5
Objects/clinic/dictobject.c.h
View File

@ -23,8 +23,9 @@ dict_fromkeys(PyTypeObject *type, PyObject *args)
if (!PyArg_UnpackTuple(args, "fromkeys", if (!PyArg_UnpackTuple(args, "fromkeys",
1, 2, 1, 2,
&iterable, &value)) &iterable, &value)) {
goto exit; goto exit;
}
return_value = dict_fromkeys_impl(type, iterable, value); return_value = dict_fromkeys_impl(type, iterable, value);
exit: exit:
@ -39,4 +40,4 @@ PyDoc_STRVAR(dict___contains____doc__,
#define DICT___CONTAINS___METHODDEF \ #define DICT___CONTAINS___METHODDEF \
{"__contains__", (PyCFunction)dict___contains__, METH_O|METH_COEXIST, dict___contains____doc__}, {"__contains__", (PyCFunction)dict___contains__, METH_O|METH_COEXIST, dict___contains____doc__},
/*[clinic end generated code: output=fe74d676332fdba6 input=a9049054013a1b77]*/ /*[clinic end generated code: output=926326109e3d9839 input=a9049054013a1b77]*/

5
Objects/clinic/unicodeobject.c.h
View File

@ -31,11 +31,12 @@ unicode_maketrans(void *null, PyObject *args)
PyObject *z = NULL; PyObject *z = NULL;
if (!PyArg_ParseTuple(args, "O|UU:maketrans", if (!PyArg_ParseTuple(args, "O|UU:maketrans",
&x, &y, &z)) &x, &y, &z)) {
goto exit; goto exit;
}
return_value = unicode_maketrans_impl(x, y, z); return_value = unicode_maketrans_impl(x, y, z);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=94affdff5b2daff5 input=a9049054013a1b77]*/ /*[clinic end generated code: output=4a86dd108d92d104 input=a9049054013a1b77]*/

59
PC/clinic/msvcrtmodule.c.h
View File

@ -51,8 +51,9 @@ msvcrt_locking(PyModuleDef *module, PyObject *args)
long nbytes; long nbytes;
if (!PyArg_ParseTuple(args, "iil:locking", if (!PyArg_ParseTuple(args, "iil:locking",
&fd, &mode, &nbytes)) &fd, &mode, &nbytes)) {
goto exit; goto exit;
}
return_value = msvcrt_locking_impl(module, fd, mode, nbytes); return_value = msvcrt_locking_impl(module, fd, mode, nbytes);
exit: exit:
@ -85,11 +86,13 @@ msvcrt_setmode(PyModuleDef *module, PyObject *args)
long _return_value; long _return_value;
if (!PyArg_ParseTuple(args, "ii:setmode", if (!PyArg_ParseTuple(args, "ii:setmode",
&fd, &flags)) &fd, &flags)) {
goto exit; goto exit;
}
_return_value = msvcrt_setmode_impl(module, fd, flags); _return_value = msvcrt_setmode_impl(module, fd, flags);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -122,11 +125,13 @@ msvcrt_open_osfhandle(PyModuleDef *module, PyObject *args)
long _return_value; long _return_value;
if (!PyArg_ParseTuple(args, ""_Py_PARSE_INTPTR"i:open_osfhandle", if (!PyArg_ParseTuple(args, ""_Py_PARSE_INTPTR"i:open_osfhandle",
&handle, &flags)) &handle, &flags)) {
goto exit; goto exit;
}
_return_value = msvcrt_open_osfhandle_impl(module, handle, flags); _return_value = msvcrt_open_osfhandle_impl(module, handle, flags);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -154,11 +159,13 @@ msvcrt_get_osfhandle(PyModuleDef *module, PyObject *arg)
int fd; int fd;
Py_intptr_t _return_value; Py_intptr_t _return_value;
if (!PyArg_Parse(arg, "i:get_osfhandle", &fd)) if (!PyArg_Parse(arg, "i:get_osfhandle", &fd)) {
goto exit; goto exit;
}
_return_value = msvcrt_get_osfhandle_impl(module, fd); _return_value = msvcrt_get_osfhandle_impl(module, fd);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromVoidPtr((void *)_return_value); return_value = PyLong_FromVoidPtr((void *)_return_value);
exit: exit:
@ -184,8 +191,9 @@ msvcrt_kbhit(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
long _return_value; long _return_value;
_return_value = msvcrt_kbhit_impl(module); _return_value = msvcrt_kbhit_impl(module);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -312,8 +320,9 @@ msvcrt_putch(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
char char_value; char char_value;
if (!PyArg_Parse(arg, "c:putch", &char_value)) if (!PyArg_Parse(arg, "c:putch", &char_value)) {
goto exit; goto exit;
}
return_value = msvcrt_putch_impl(module, char_value); return_value = msvcrt_putch_impl(module, char_value);
exit: exit:
@ -338,8 +347,9 @@ msvcrt_putwch(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int unicode_char; int unicode_char;
if (!PyArg_Parse(arg, "C:putwch", &unicode_char)) if (!PyArg_Parse(arg, "C:putwch", &unicode_char)) {
goto exit; goto exit;
}
return_value = msvcrt_putwch_impl(module, unicode_char); return_value = msvcrt_putwch_impl(module, unicode_char);
exit: exit:
@ -368,8 +378,9 @@ msvcrt_ungetch(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
char char_value; char char_value;
if (!PyArg_Parse(arg, "c:ungetch", &char_value)) if (!PyArg_Parse(arg, "c:ungetch", &char_value)) {
goto exit; goto exit;
}
return_value = msvcrt_ungetch_impl(module, char_value); return_value = msvcrt_ungetch_impl(module, char_value);
exit: exit:
@ -394,8 +405,9 @@ msvcrt_ungetwch(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int unicode_char; int unicode_char;
if (!PyArg_Parse(arg, "C:ungetwch", &unicode_char)) if (!PyArg_Parse(arg, "C:ungetwch", &unicode_char)) {
goto exit; goto exit;
}
return_value = msvcrt_ungetwch_impl(module, unicode_char); return_value = msvcrt_ungetwch_impl(module, unicode_char);
exit: exit:
@ -427,11 +439,13 @@ msvcrt_CrtSetReportFile(PyModuleDef *module, PyObject *args)
long _return_value; long _return_value;
if (!PyArg_ParseTuple(args, "ii:CrtSetReportFile", if (!PyArg_ParseTuple(args, "ii:CrtSetReportFile",
&type, &file)) &type, &file)) {
goto exit; goto exit;
}
_return_value = msvcrt_CrtSetReportFile_impl(module, type, file); _return_value = msvcrt_CrtSetReportFile_impl(module, type, file);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -465,11 +479,13 @@ msvcrt_CrtSetReportMode(PyModuleDef *module, PyObject *args)
long _return_value; long _return_value;
if (!PyArg_ParseTuple(args, "ii:CrtSetReportMode", if (!PyArg_ParseTuple(args, "ii:CrtSetReportMode",
&type, &mode)) &type, &mode)) {
goto exit; goto exit;
}
_return_value = msvcrt_CrtSetReportMode_impl(module, type, mode); _return_value = msvcrt_CrtSetReportMode_impl(module, type, mode);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -501,11 +517,13 @@ msvcrt_set_error_mode(PyModuleDef *module, PyObject *arg)
int mode; int mode;
long _return_value; long _return_value;
if (!PyArg_Parse(arg, "i:set_error_mode", &mode)) if (!PyArg_Parse(arg, "i:set_error_mode", &mode)) {
goto exit; goto exit;
}
_return_value = msvcrt_set_error_mode_impl(module, mode); _return_value = msvcrt_set_error_mode_impl(module, mode);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong(_return_value); return_value = PyLong_FromLong(_return_value);
exit: exit:
@ -532,8 +550,9 @@ msvcrt_SetErrorMode(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
unsigned int mode; unsigned int mode;
if (!PyArg_Parse(arg, "I:SetErrorMode", &mode)) if (!PyArg_Parse(arg, "I:SetErrorMode", &mode)) {
goto exit; goto exit;
}
return_value = msvcrt_SetErrorMode_impl(module, mode); return_value = msvcrt_SetErrorMode_impl(module, mode);
exit: exit:
@ -551,4 +570,4 @@ exit:
#ifndef MSVCRT_SET_ERROR_MODE_METHODDEF #ifndef MSVCRT_SET_ERROR_MODE_METHODDEF
#define MSVCRT_SET_ERROR_MODE_METHODDEF #define MSVCRT_SET_ERROR_MODE_METHODDEF
#endif /* !defined(MSVCRT_SET_ERROR_MODE_METHODDEF) */ #endif /* !defined(MSVCRT_SET_ERROR_MODE_METHODDEF) */
/*[clinic end generated code: output=16613d3119a1fd44 input=a9049054013a1b77]*/ /*[clinic end generated code: output=636de3460aecbca7 input=a9049054013a1b77]*/

86
PC/clinic/winreg.c.h
View File

@ -93,8 +93,9 @@ winreg_HKEYType___exit__(PyHKEYObject *self, PyObject *args, PyObject *kwargs)
PyObject *traceback; PyObject *traceback;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:__exit__", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:__exit__", _keywords,
&exc_type, &exc_value, &traceback)) &exc_type, &exc_value, &traceback)) {
goto exit; goto exit;
}
return_value = winreg_HKEYType___exit___impl(self, exc_type, exc_value, traceback); return_value = winreg_HKEYType___exit___impl(self, exc_type, exc_value, traceback);
exit: exit:
@ -147,11 +148,13 @@ winreg_ConnectRegistry(PyModuleDef *module, PyObject *args)
HKEY _return_value; HKEY _return_value;
if (!PyArg_ParseTuple(args, "ZO&:ConnectRegistry", if (!PyArg_ParseTuple(args, "ZO&:ConnectRegistry",
&computer_name, clinic_HKEY_converter, &key)) &computer_name, clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
_return_value = winreg_ConnectRegistry_impl(module, computer_name, key); _return_value = winreg_ConnectRegistry_impl(module, computer_name, key);
if (_return_value == NULL) if (_return_value == NULL) {
goto exit; goto exit;
}
return_value = PyHKEY_FromHKEY(_return_value); return_value = PyHKEY_FromHKEY(_return_value);
exit: exit:
@ -192,11 +195,13 @@ winreg_CreateKey(PyModuleDef *module, PyObject *args)
HKEY _return_value; HKEY _return_value;
if (!PyArg_ParseTuple(args, "O&Z:CreateKey", if (!PyArg_ParseTuple(args, "O&Z:CreateKey",
clinic_HKEY_converter, &key, &sub_key)) clinic_HKEY_converter, &key, &sub_key)) {
goto exit; goto exit;
}
_return_value = winreg_CreateKey_impl(module, key, sub_key); _return_value = winreg_CreateKey_impl(module, key, sub_key);
if (_return_value == NULL) if (_return_value == NULL) {
goto exit; goto exit;
}
return_value = PyHKEY_FromHKEY(_return_value); return_value = PyHKEY_FromHKEY(_return_value);
exit: exit:
@ -247,11 +252,13 @@ winreg_CreateKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
HKEY _return_value; HKEY _return_value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:CreateKeyEx", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:CreateKeyEx", _keywords,
clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) {
goto exit; goto exit;
}
_return_value = winreg_CreateKeyEx_impl(module, key, sub_key, reserved, access); _return_value = winreg_CreateKeyEx_impl(module, key, sub_key, reserved, access);
if (_return_value == NULL) if (_return_value == NULL) {
goto exit; goto exit;
}
return_value = PyHKEY_FromHKEY(_return_value); return_value = PyHKEY_FromHKEY(_return_value);
exit: exit:
@ -290,8 +297,9 @@ winreg_DeleteKey(PyModuleDef *module, PyObject *args)
Py_UNICODE *sub_key; Py_UNICODE *sub_key;
if (!PyArg_ParseTuple(args, "O&u:DeleteKey", if (!PyArg_ParseTuple(args, "O&u:DeleteKey",
clinic_HKEY_converter, &key, &sub_key)) clinic_HKEY_converter, &key, &sub_key)) {
goto exit; goto exit;
}
return_value = winreg_DeleteKey_impl(module, key, sub_key); return_value = winreg_DeleteKey_impl(module, key, sub_key);
exit: exit:
@ -341,8 +349,9 @@ winreg_DeleteKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int reserved = 0; int reserved = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&u|ii:DeleteKeyEx", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&u|ii:DeleteKeyEx", _keywords,
clinic_HKEY_converter, &key, &sub_key, &access, &reserved)) clinic_HKEY_converter, &key, &sub_key, &access, &reserved)) {
goto exit; goto exit;
}
return_value = winreg_DeleteKeyEx_impl(module, key, sub_key, access, reserved); return_value = winreg_DeleteKeyEx_impl(module, key, sub_key, access, reserved);
exit: exit:
@ -374,8 +383,9 @@ winreg_DeleteValue(PyModuleDef *module, PyObject *args)
Py_UNICODE *value; Py_UNICODE *value;
if (!PyArg_ParseTuple(args, "O&Z:DeleteValue", if (!PyArg_ParseTuple(args, "O&Z:DeleteValue",
clinic_HKEY_converter, &key, &value)) clinic_HKEY_converter, &key, &value)) {
goto exit; goto exit;
}
return_value = winreg_DeleteValue_impl(module, key, value); return_value = winreg_DeleteValue_impl(module, key, value);
exit: exit:
@ -411,8 +421,9 @@ winreg_EnumKey(PyModuleDef *module, PyObject *args)
int index; int index;
if (!PyArg_ParseTuple(args, "O&i:EnumKey", if (!PyArg_ParseTuple(args, "O&i:EnumKey",
clinic_HKEY_converter, &key, &index)) clinic_HKEY_converter, &key, &index)) {
goto exit; goto exit;
}
return_value = winreg_EnumKey_impl(module, key, index); return_value = winreg_EnumKey_impl(module, key, index);
exit: exit:
@ -457,8 +468,9 @@ winreg_EnumValue(PyModuleDef *module, PyObject *args)
int index; int index;
if (!PyArg_ParseTuple(args, "O&i:EnumValue", if (!PyArg_ParseTuple(args, "O&i:EnumValue",
clinic_HKEY_converter, &key, &index)) clinic_HKEY_converter, &key, &index)) {
goto exit; goto exit;
}
return_value = winreg_EnumValue_impl(module, key, index); return_value = winreg_EnumValue_impl(module, key, index);
exit: exit:
@ -483,8 +495,9 @@ winreg_ExpandEnvironmentStrings(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
Py_UNICODE *string; Py_UNICODE *string;
if (!PyArg_Parse(arg, "u:ExpandEnvironmentStrings", &string)) if (!PyArg_Parse(arg, "u:ExpandEnvironmentStrings", &string)) {
goto exit; goto exit;
}
return_value = winreg_ExpandEnvironmentStrings_impl(module, string); return_value = winreg_ExpandEnvironmentStrings_impl(module, string);
exit: exit:
@ -522,8 +535,9 @@ winreg_FlushKey(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HKEY key; HKEY key;
if (!PyArg_Parse(arg, "O&:FlushKey", clinic_HKEY_converter, &key)) if (!PyArg_Parse(arg, "O&:FlushKey", clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
return_value = winreg_FlushKey_impl(module, key); return_value = winreg_FlushKey_impl(module, key);
exit: exit:
@ -574,8 +588,9 @@ winreg_LoadKey(PyModuleDef *module, PyObject *args)
Py_UNICODE *file_name; Py_UNICODE *file_name;
if (!PyArg_ParseTuple(args, "O&uu:LoadKey", if (!PyArg_ParseTuple(args, "O&uu:LoadKey",
clinic_HKEY_converter, &key, &sub_key, &file_name)) clinic_HKEY_converter, &key, &sub_key, &file_name)) {
goto exit; goto exit;
}
return_value = winreg_LoadKey_impl(module, key, sub_key, file_name); return_value = winreg_LoadKey_impl(module, key, sub_key, file_name);
exit: exit:
@ -620,11 +635,13 @@ winreg_OpenKey(PyModuleDef *module, PyObject *args, PyObject *kwargs)
HKEY _return_value; HKEY _return_value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:OpenKey", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:OpenKey", _keywords,
clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) {
goto exit; goto exit;
}
_return_value = winreg_OpenKey_impl(module, key, sub_key, reserved, access); _return_value = winreg_OpenKey_impl(module, key, sub_key, reserved, access);
if (_return_value == NULL) if (_return_value == NULL) {
goto exit; goto exit;
}
return_value = PyHKEY_FromHKEY(_return_value); return_value = PyHKEY_FromHKEY(_return_value);
exit: exit:
@ -669,11 +686,13 @@ winreg_OpenKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
HKEY _return_value; HKEY _return_value;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:OpenKeyEx", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Z|ii:OpenKeyEx", _keywords,
clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) clinic_HKEY_converter, &key, &sub_key, &reserved, &access)) {
goto exit; goto exit;
}
_return_value = winreg_OpenKeyEx_impl(module, key, sub_key, reserved, access); _return_value = winreg_OpenKeyEx_impl(module, key, sub_key, reserved, access);
if (_return_value == NULL) if (_return_value == NULL) {
goto exit; goto exit;
}
return_value = PyHKEY_FromHKEY(_return_value); return_value = PyHKEY_FromHKEY(_return_value);
exit: exit:
@ -707,8 +726,9 @@ winreg_QueryInfoKey(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HKEY key; HKEY key;
if (!PyArg_Parse(arg, "O&:QueryInfoKey", clinic_HKEY_converter, &key)) if (!PyArg_Parse(arg, "O&:QueryInfoKey", clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
return_value = winreg_QueryInfoKey_impl(module, key); return_value = winreg_QueryInfoKey_impl(module, key);
exit: exit:
@ -749,8 +769,9 @@ winreg_QueryValue(PyModuleDef *module, PyObject *args)
Py_UNICODE *sub_key; Py_UNICODE *sub_key;
if (!PyArg_ParseTuple(args, "O&Z:QueryValue", if (!PyArg_ParseTuple(args, "O&Z:QueryValue",
clinic_HKEY_converter, &key, &sub_key)) clinic_HKEY_converter, &key, &sub_key)) {
goto exit; goto exit;
}
return_value = winreg_QueryValue_impl(module, key, sub_key); return_value = winreg_QueryValue_impl(module, key, sub_key);
exit: exit:
@ -787,8 +808,9 @@ winreg_QueryValueEx(PyModuleDef *module, PyObject *args)
Py_UNICODE *name; Py_UNICODE *name;
if (!PyArg_ParseTuple(args, "O&Z:QueryValueEx", if (!PyArg_ParseTuple(args, "O&Z:QueryValueEx",
clinic_HKEY_converter, &key, &name)) clinic_HKEY_converter, &key, &name)) {
goto exit; goto exit;
}
return_value = winreg_QueryValueEx_impl(module, key, name); return_value = winreg_QueryValueEx_impl(module, key, name);
exit: exit:
@ -830,8 +852,9 @@ winreg_SaveKey(PyModuleDef *module, PyObject *args)
Py_UNICODE *file_name; Py_UNICODE *file_name;
if (!PyArg_ParseTuple(args, "O&u:SaveKey", if (!PyArg_ParseTuple(args, "O&u:SaveKey",
clinic_HKEY_converter, &key, &file_name)) clinic_HKEY_converter, &key, &file_name)) {
goto exit; goto exit;
}
return_value = winreg_SaveKey_impl(module, key, file_name); return_value = winreg_SaveKey_impl(module, key, file_name);
exit: exit:
@ -883,8 +906,9 @@ winreg_SetValue(PyModuleDef *module, PyObject *args)
Py_ssize_clean_t value_length; Py_ssize_clean_t value_length;
if (!PyArg_ParseTuple(args, "O&Zku#:SetValue", if (!PyArg_ParseTuple(args, "O&Zku#:SetValue",
clinic_HKEY_converter, &key, &sub_key, &type, &value, &value_length)) clinic_HKEY_converter, &key, &sub_key, &type, &value, &value_length)) {
goto exit; goto exit;
}
return_value = winreg_SetValue_impl(module, key, sub_key, type, value, value_length); return_value = winreg_SetValue_impl(module, key, sub_key, type, value, value_length);
exit: exit:
@ -952,8 +976,9 @@ winreg_SetValueEx(PyModuleDef *module, PyObject *args)
PyObject *value; PyObject *value;
if (!PyArg_ParseTuple(args, "O&ZOkO:SetValueEx", if (!PyArg_ParseTuple(args, "O&ZOkO:SetValueEx",
clinic_HKEY_converter, &key, &value_name, &reserved, &type, &value)) clinic_HKEY_converter, &key, &value_name, &reserved, &type, &value)) {
goto exit; goto exit;
}
return_value = winreg_SetValueEx_impl(module, key, value_name, reserved, type, value); return_value = winreg_SetValueEx_impl(module, key, value_name, reserved, type, value);
exit: exit:
@ -987,8 +1012,9 @@ winreg_DisableReflectionKey(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HKEY key; HKEY key;
if (!PyArg_Parse(arg, "O&:DisableReflectionKey", clinic_HKEY_converter, &key)) if (!PyArg_Parse(arg, "O&:DisableReflectionKey", clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
return_value = winreg_DisableReflectionKey_impl(module, key); return_value = winreg_DisableReflectionKey_impl(module, key);
exit: exit:
@ -1020,8 +1046,9 @@ winreg_EnableReflectionKey(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HKEY key; HKEY key;
if (!PyArg_Parse(arg, "O&:EnableReflectionKey", clinic_HKEY_converter, &key)) if (!PyArg_Parse(arg, "O&:EnableReflectionKey", clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
return_value = winreg_EnableReflectionKey_impl(module, key); return_value = winreg_EnableReflectionKey_impl(module, key);
exit: exit:
@ -1051,11 +1078,12 @@ winreg_QueryReflectionKey(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
HKEY key; HKEY key;
if (!PyArg_Parse(arg, "O&:QueryReflectionKey", clinic_HKEY_converter, &key)) if (!PyArg_Parse(arg, "O&:QueryReflectionKey", clinic_HKEY_converter, &key)) {
goto exit; goto exit;
}
return_value = winreg_QueryReflectionKey_impl(module, key); return_value = winreg_QueryReflectionKey_impl(module, key);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=0b71782e9b37b12a input=a9049054013a1b77]*/ /*[clinic end generated code: output=ca128bfa212d8d1f input=a9049054013a1b77]*/

11
PC/clinic/winsound.c.h
View File

@ -27,8 +27,9 @@ winsound_PlaySound(PyModuleDef *module, PyObject *args)
int flags; int flags;
if (!PyArg_ParseTuple(args, "Zi:PlaySound", if (!PyArg_ParseTuple(args, "Zi:PlaySound",
&sound, &flags)) &sound, &flags)) {
goto exit; goto exit;
}
return_value = winsound_PlaySound_impl(module, sound, flags); return_value = winsound_PlaySound_impl(module, sound, flags);
exit: exit:
@ -61,8 +62,9 @@ winsound_Beep(PyModuleDef *module, PyObject *args)
int duration; int duration;
if (!PyArg_ParseTuple(args, "ii:Beep", if (!PyArg_ParseTuple(args, "ii:Beep",
&frequency, &duration)) &frequency, &duration)) {
goto exit; goto exit;
}
return_value = winsound_Beep_impl(module, frequency, duration); return_value = winsound_Beep_impl(module, frequency, duration);
exit: exit:
@ -90,11 +92,12 @@ winsound_MessageBeep(PyModuleDef *module, PyObject *args)
int x = MB_OK; int x = MB_OK;
if (!PyArg_ParseTuple(args, "|i:MessageBeep", if (!PyArg_ParseTuple(args, "|i:MessageBeep",
&x)) &x)) {
goto exit; goto exit;
}
return_value = winsound_MessageBeep_impl(module, x); return_value = winsound_MessageBeep_impl(module, x);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=c5b018ac9dc1f500 input=a9049054013a1b77]*/ /*[clinic end generated code: output=a5f53e42d4396bb4 input=a9049054013a1b77]*/

44
Python/clinic/bltinmodule.c.h
View File

@ -94,8 +94,9 @@ builtin_format(PyModuleDef *module, PyObject *args)
PyObject *format_spec = NULL; PyObject *format_spec = NULL;
if (!PyArg_ParseTuple(args, "O|U:format", if (!PyArg_ParseTuple(args, "O|U:format",
&value, &format_spec)) &value, &format_spec)) {
goto exit; goto exit;
}
return_value = builtin_format_impl(module, value, format_spec); return_value = builtin_format_impl(module, value, format_spec);
exit: exit:
@ -120,8 +121,9 @@ builtin_chr(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
int i; int i;
if (!PyArg_Parse(arg, "i:chr", &i)) if (!PyArg_Parse(arg, "i:chr", &i)) {
goto exit; goto exit;
}
return_value = builtin_chr_impl(module, i); return_value = builtin_chr_impl(module, i);
exit: exit:
@ -167,8 +169,9 @@ builtin_compile(PyModuleDef *module, PyObject *args, PyObject *kwargs)
int optimize = -1; int optimize = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO&s|iii:compile", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO&s|iii:compile", _keywords,
&source, PyUnicode_FSDecoder, &filename, &mode, &flags, &dont_inherit, &optimize)) &source, PyUnicode_FSDecoder, &filename, &mode, &flags, &dont_inherit, &optimize)) {
goto exit; goto exit;
}
return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize); return_value = builtin_compile_impl(module, source, filename, mode, flags, dont_inherit, optimize);
exit: exit:
@ -196,8 +199,9 @@ builtin_divmod(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "divmod", if (!PyArg_UnpackTuple(args, "divmod",
2, 2, 2, 2,
&x, &y)) &x, &y)) {
goto exit; goto exit;
}
return_value = builtin_divmod_impl(module, x, y); return_value = builtin_divmod_impl(module, x, y);
exit: exit:
@ -233,8 +237,9 @@ builtin_eval(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "eval", if (!PyArg_UnpackTuple(args, "eval",
1, 3, 1, 3,
&source, &globals, &locals)) &source, &globals, &locals)) {
goto exit; goto exit;
}
return_value = builtin_eval_impl(module, source, globals, locals); return_value = builtin_eval_impl(module, source, globals, locals);
exit: exit:
@ -270,8 +275,9 @@ builtin_exec(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "exec", if (!PyArg_UnpackTuple(args, "exec",
1, 3, 1, 3,
&source, &globals, &locals)) &source, &globals, &locals)) {
goto exit; goto exit;
}
return_value = builtin_exec_impl(module, source, globals, locals); return_value = builtin_exec_impl(module, source, globals, locals);
exit: exit:
@ -322,8 +328,9 @@ builtin_hasattr(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "hasattr", if (!PyArg_UnpackTuple(args, "hasattr",
2, 2, 2, 2,
&obj, &name)) &obj, &name)) {
goto exit; goto exit;
}
return_value = builtin_hasattr_impl(module, obj, name); return_value = builtin_hasattr_impl(module, obj, name);
exit: exit:
@ -367,8 +374,9 @@ builtin_setattr(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "setattr", if (!PyArg_UnpackTuple(args, "setattr",
3, 3, 3, 3,
&obj, &name, &value)) &obj, &name, &value)) {
goto exit; goto exit;
}
return_value = builtin_setattr_impl(module, obj, name, value); return_value = builtin_setattr_impl(module, obj, name, value);
exit: exit:
@ -398,8 +406,9 @@ builtin_delattr(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "delattr", if (!PyArg_UnpackTuple(args, "delattr",
2, 2, 2, 2,
&obj, &name)) &obj, &name)) {
goto exit; goto exit;
}
return_value = builtin_delattr_impl(module, obj, name); return_value = builtin_delattr_impl(module, obj, name);
exit: exit:
@ -507,8 +516,9 @@ builtin_pow(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "pow", if (!PyArg_UnpackTuple(args, "pow",
2, 3, 2, 3,
&x, &y, &z)) &x, &y, &z)) {
goto exit; goto exit;
}
return_value = builtin_pow_impl(module, x, y, z); return_value = builtin_pow_impl(module, x, y, z);
exit: exit:
@ -541,8 +551,9 @@ builtin_input(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "input", if (!PyArg_UnpackTuple(args, "input",
0, 1, 0, 1,
&prompt)) &prompt)) {
goto exit; goto exit;
}
return_value = builtin_input_impl(module, prompt); return_value = builtin_input_impl(module, prompt);
exit: exit:
@ -585,8 +596,9 @@ builtin_sum(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "sum", if (!PyArg_UnpackTuple(args, "sum",
1, 2, 1, 2,
&iterable, &start)) &iterable, &start)) {
goto exit; goto exit;
}
return_value = builtin_sum_impl(module, iterable, start); return_value = builtin_sum_impl(module, iterable, start);
exit: exit:
@ -619,8 +631,9 @@ builtin_isinstance(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "isinstance", if (!PyArg_UnpackTuple(args, "isinstance",
2, 2, 2, 2,
&obj, &class_or_tuple)) &obj, &class_or_tuple)) {
goto exit; goto exit;
}
return_value = builtin_isinstance_impl(module, obj, class_or_tuple); return_value = builtin_isinstance_impl(module, obj, class_or_tuple);
exit: exit:
@ -653,11 +666,12 @@ builtin_issubclass(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "issubclass", if (!PyArg_UnpackTuple(args, "issubclass",
2, 2, 2, 2,
&cls, &class_or_tuple)) &cls, &class_or_tuple)) {
goto exit; goto exit;
}
return_value = builtin_issubclass_impl(module, cls, class_or_tuple); return_value = builtin_issubclass_impl(module, cls, class_or_tuple);
exit: exit:
return return_value; return return_value;
} }
/*[clinic end generated code: output=4bef16b6aa432879 input=a9049054013a1b77]*/ /*[clinic end generated code: output=940f25126caf8166 input=a9049054013a1b77]*/

29
Python/clinic/import.c.h
View File

@ -89,8 +89,9 @@ _imp__fix_co_filename(PyModuleDef *module, PyObject *args)
PyObject *path; PyObject *path;
if (!PyArg_ParseTuple(args, "O!U:_fix_co_filename", if (!PyArg_ParseTuple(args, "O!U:_fix_co_filename",
&PyCode_Type, &code, &path)) &PyCode_Type, &code, &path)) {
goto exit; goto exit;
}
return_value = _imp__fix_co_filename_impl(module, code, path); return_value = _imp__fix_co_filename_impl(module, code, path);
exit: exit:
@ -142,8 +143,9 @@ _imp_init_frozen(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *name; PyObject *name;
if (!PyArg_Parse(arg, "U:init_frozen", &name)) if (!PyArg_Parse(arg, "U:init_frozen", &name)) {
goto exit; goto exit;
}
return_value = _imp_init_frozen_impl(module, name); return_value = _imp_init_frozen_impl(module, name);
exit: exit:
@ -168,8 +170,9 @@ _imp_get_frozen_object(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *name; PyObject *name;
if (!PyArg_Parse(arg, "U:get_frozen_object", &name)) if (!PyArg_Parse(arg, "U:get_frozen_object", &name)) {
goto exit; goto exit;
}
return_value = _imp_get_frozen_object_impl(module, name); return_value = _imp_get_frozen_object_impl(module, name);
exit: exit:
@ -194,8 +197,9 @@ _imp_is_frozen_package(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *name; PyObject *name;
if (!PyArg_Parse(arg, "U:is_frozen_package", &name)) if (!PyArg_Parse(arg, "U:is_frozen_package", &name)) {
goto exit; goto exit;
}
return_value = _imp_is_frozen_package_impl(module, name); return_value = _imp_is_frozen_package_impl(module, name);
exit: exit:
@ -220,8 +224,9 @@ _imp_is_builtin(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *name; PyObject *name;
if (!PyArg_Parse(arg, "U:is_builtin", &name)) if (!PyArg_Parse(arg, "U:is_builtin", &name)) {
goto exit; goto exit;
}
return_value = _imp_is_builtin_impl(module, name); return_value = _imp_is_builtin_impl(module, name);
exit: exit:
@ -246,8 +251,9 @@ _imp_is_frozen(PyModuleDef *module, PyObject *arg)
PyObject *return_value = NULL; PyObject *return_value = NULL;
PyObject *name; PyObject *name;
if (!PyArg_Parse(arg, "U:is_frozen", &name)) if (!PyArg_Parse(arg, "U:is_frozen", &name)) {
goto exit; goto exit;
}
return_value = _imp_is_frozen_impl(module, name); return_value = _imp_is_frozen_impl(module, name);
exit: exit:
@ -277,8 +283,9 @@ _imp_create_dynamic(PyModuleDef *module, PyObject *args)
if (!PyArg_UnpackTuple(args, "create_dynamic", if (!PyArg_UnpackTuple(args, "create_dynamic",
1, 2, 1, 2,
&spec, &file)) &spec, &file)) {
goto exit; goto exit;
}
return_value = _imp_create_dynamic_impl(module, spec, file); return_value = _imp_create_dynamic_impl(module, spec, file);
exit: exit:
@ -308,8 +315,9 @@ _imp_exec_dynamic(PyModuleDef *module, PyObject *mod)
int _return_value; int _return_value;
_return_value = _imp_exec_dynamic_impl(module, mod); _return_value = _imp_exec_dynamic_impl(module, mod);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -337,8 +345,9 @@ _imp_exec_builtin(PyModuleDef *module, PyObject *mod)
int _return_value; int _return_value;
_return_value = _imp_exec_builtin_impl(module, mod); _return_value = _imp_exec_builtin_impl(module, mod);
if ((_return_value == -1) && PyErr_Occurred()) if ((_return_value == -1) && PyErr_Occurred()) {
goto exit; goto exit;
}
return_value = PyLong_FromLong((long)_return_value); return_value = PyLong_FromLong((long)_return_value);
exit: exit:
@ -352,4 +361,4 @@ exit:
#ifndef _IMP_EXEC_DYNAMIC_METHODDEF #ifndef _IMP_EXEC_DYNAMIC_METHODDEF
#define _IMP_EXEC_DYNAMIC_METHODDEF #define _IMP_EXEC_DYNAMIC_METHODDEF
#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */ #endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
/*[clinic end generated code: output=32324a5e46cdfc4b input=a9049054013a1b77]*/ /*[clinic end generated code: output=22a7225925755674 input=a9049054013a1b77]*/

35
Tools/clinic/clinic.py
View File

@ -797,8 +797,9 @@ class CLanguage(Language):
""" % argname) """ % argname)
parser_definition = parser_body(parser_prototype, normalize_snippet(""" parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) {{
goto exit; goto exit;
}}
""" % argname, indent=4)) """ % argname, indent=4))
elif has_option_groups: elif has_option_groups:
@ -822,8 +823,9 @@ class CLanguage(Language):
parser_definition = parser_body(parser_prototype, normalize_snippet(""" parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_UnpackTuple(args, "{name}", if (!PyArg_UnpackTuple(args, "{name}",
{unpack_min}, {unpack_max}, {unpack_min}, {unpack_max},
{parse_arguments})) {parse_arguments})) {{
goto exit; goto exit;
}}
""", indent=4)) """, indent=4))
elif positional: elif positional:
@ -835,8 +837,9 @@ class CLanguage(Language):
parser_definition = parser_body(parser_prototype, normalize_snippet(""" parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_ParseTuple(args, "{format_units}:{name}", if (!PyArg_ParseTuple(args, "{format_units}:{name}",
{parse_arguments})) {parse_arguments})) {{
goto exit; goto exit;
}}
""", indent=4)) """, indent=4))
else: else:
@ -847,13 +850,15 @@ class CLanguage(Language):
body = normalize_snippet(""" body = normalize_snippet("""
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "{format_units}:{name}", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "{format_units}:{name}", _keywords,
{parse_arguments})) {parse_arguments})) {{
goto exit; goto exit;
}}
""", indent=4) """, indent=4)
parser_definition = parser_body(parser_prototype, normalize_snippet(""" parser_definition = parser_body(parser_prototype, normalize_snippet("""
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "{format_units}:{name}", _keywords, if (!PyArg_ParseTupleAndKeywords(args, kwargs, "{format_units}:{name}", _keywords,
{parse_arguments})) {parse_arguments})) {{
goto exit; goto exit;
}}
""", indent=4)) """, indent=4))
parser_definition = insert_keywords(parser_definition) parser_definition = insert_keywords(parser_definition)
@ -878,13 +883,15 @@ class CLanguage(Language):
if not parses_keywords: if not parses_keywords:
fields.insert(0, normalize_snippet(""" fields.insert(0, normalize_snippet("""
if ({self_type_check}!_PyArg_NoKeywords("{name}", kwargs)) if ({self_type_check}!_PyArg_NoKeywords("{name}", kwargs)) {{
goto exit; goto exit;
}}
""", indent=4)) """, indent=4))
if not parses_positional: if not parses_positional:
fields.insert(0, normalize_snippet(""" fields.insert(0, normalize_snippet("""
if ({self_type_check}!_PyArg_NoPositional("{name}", args)) if ({self_type_check}!_PyArg_NoPositional("{name}", args)) {{
goto exit; goto exit;
}}
""", indent=4)) """, indent=4))
parser_definition = parser_body(parser_prototype, *fields) parser_definition = parser_body(parser_prototype, *fields)
@ -1032,8 +1039,9 @@ class CLanguage(Language):
s = """ s = """
case {count}: case {count}:
if (!PyArg_ParseTuple(args, "{format_units}:{name}", {parse_arguments})) if (!PyArg_ParseTuple(args, "{format_units}:{name}", {parse_arguments})) {{
goto exit; goto exit;
}}
{group_booleans} {group_booleans}
break; break;
"""[1:] """[1:]
@ -2676,7 +2684,7 @@ class str_converter(CConverter):
def cleanup(self): def cleanup(self):
if self.encoding: if self.encoding:
name = ensure_legal_c_identifier(self.name) name = ensure_legal_c_identifier(self.name)
return "".join(["if (", name, ")\n PyMem_FREE(", name, ");\n"]) return "".join(["if (", name, ") {\n PyMem_FREE(", name, ");\n}\n"])
# #
# This is the fourth or fifth rewrite of registering all the # This is the fourth or fifth rewrite of registering all the
@ -2786,7 +2794,7 @@ class Py_buffer_converter(CConverter):
def cleanup(self): def cleanup(self):
name = ensure_legal_c_identifier(self.name) name = ensure_legal_c_identifier(self.name)
return "".join(["if (", name, ".obj)\n PyBuffer_Release(&", name, ");\n"]) return "".join(["if (", name, ".obj) {\n PyBuffer_Release(&", name, ");\n}\n"])
def correct_name_for_self(f): def correct_name_for_self(f):
@ -2959,10 +2967,10 @@ class CReturnConverter(metaclass=CReturnConverterAutoRegister):
data.return_value = name data.return_value = name
def err_occurred_if(self, expr, data): def err_occurred_if(self, expr, data):
data.return_conversion.append('if (({}) && PyErr_Occurred())\n goto exit;\n'.format(expr)) data.return_conversion.append('if (({}) && PyErr_Occurred()) {{\n goto exit;\n}}\n'.format(expr))
def err_occurred_if_null_pointer(self, variable, data): def err_occurred_if_null_pointer(self, variable, data):
data.return_conversion.append('if ({} == NULL)\n goto exit;\n'.format(variable)) data.return_conversion.append('if ({} == NULL) {{\n goto exit;\n}}\n'.format(variable))
def render(self, function, data): def render(self, function, data):
""" """
@ -2977,8 +2985,9 @@ class NoneType_return_converter(CReturnConverter):
def render(self, function, data): def render(self, function, data):
self.declare(data) self.declare(data)
data.return_conversion.append(''' data.return_conversion.append('''
if (_return_value != Py_None) if (_return_value != Py_None) {
goto exit; goto exit;
}
return_value = Py_None; return_value = Py_None;
Py_INCREF(Py_None); Py_INCREF(Py_None);
'''.strip()) '''.strip())