diff -r eb251e3624df Modules/_codecsmodule.c --- a/Modules/_codecsmodule.c Fri Jan 24 00:33:25 2014 -0500 +++ b/Modules/_codecsmodule.c Fri Jan 24 16:42:14 2014 +0800 @@ -42,6 +42,11 @@ #include #endif +/*[clinic input] +module _codecs +[clinic start generated code]*/ +/*[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/ + /* --- Registry ----------------------------------------------------------- */ PyDoc_STRVAR(register__doc__, @@ -61,75 +66,217 @@ Py_RETURN_NONE; } -PyDoc_STRVAR(lookup__doc__, -"lookup(encoding) -> CodecInfo\n\ -\n\ -Looks up a codec tuple in the Python codec registry and returns\n\ -a CodecInfo object."); - -static -PyObject *codec_lookup(PyObject *self, PyObject *args) +/*[clinic input] +_codecs.lookup + encoding: str + / + +lookup(encoding) -> CodecInfo + +Looks up a codec tuple in the Python codec registry and returns a CodecInfo +object. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_lookup__doc__, +"lookup(encoding)\n" +"lookup(encoding) -> CodecInfo\n" +"\n" +"Looks up a codec tuple in the Python codec registry and returns a CodecInfo\n" +"object."); + +#define _CODECS_LOOKUP_METHODDEF \ + {"lookup", (PyCFunction)_codecs_lookup, METH_VARARGS, _codecs_lookup__doc__}, + +static PyObject * +_codecs_lookup_impl(PyModuleDef *module, const char *encoding); + +static PyObject * +_codecs_lookup(PyModuleDef *module, PyObject *args) { - char *encoding; - - if (!PyArg_ParseTuple(args, "s:lookup", &encoding)) - return NULL; - + PyObject *return_value = NULL; + const char *encoding; + + if (!PyArg_ParseTuple(args, + "s:lookup", + &encoding)) + goto exit; + return_value = _codecs_lookup_impl(module, encoding); + +exit: + return return_value; +} + +static PyObject * +_codecs_lookup_impl(PyModuleDef *module, const char *encoding) +/*[clinic end generated code: checksum=30a97472014f2e933af607168d87d157376a4ade]*/ +{ return _PyCodec_Lookup(encoding); } -PyDoc_STRVAR(encode__doc__, -"encode(obj, [encoding[,errors]]) -> object\n\ -\n\ -Encodes obj using the codec registered for encoding. encoding defaults\n\ -to the default encoding. errors may be given to set a different error\n\ -handling scheme. Default is 'strict' meaning that encoding errors raise\n\ -a ValueError. Other possible values are 'ignore', 'replace' and\n\ -'xmlcharrefreplace' as well as any other name registered with\n\ -codecs.register_error that can handle ValueErrors."); +/*[clinic input] +_codecs.encode + obj: object + [ + encoding: str + [ + errors: str + ] + ] + / + +encode(obj, [encoding[,errors]]) -> object + +Encodes obj using the codec registered for encoding. encoding defaults to the +default encoding. errors may be given to set a different error handling scheme. +Default is 'strict' meaning that encoding errors raise a ValueError. Other +possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any +other name registered with codecs.register_error that can handle ValueErrors. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_encode__doc__, +"encode(obj, [encoding, [errors]])\n" +"encode(obj, [encoding[,errors]]) -> object\n" +"\n" +"Encodes obj using the codec registered for encoding. encoding defaults to the\n" +"default encoding. errors may be given to set a different error handling scheme.\n" +"Default is \'strict\' meaning that encoding errors raise a ValueError. Other\n" +"possible values are \'ignore\', \'replace\' and \'xmlcharrefreplace\' as well as any\n" +"other name registered with codecs.register_error that can handle ValueErrors."); + +#define _CODECS_ENCODE_METHODDEF \ + {"encode", (PyCFunction)_codecs_encode, METH_VARARGS, _codecs_encode__doc__}, static PyObject * -codec_encode(PyObject *self, PyObject *args) +_codecs_encode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors); + +static PyObject * +_codecs_encode(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; + PyObject *obj; + int group_right_1 = 0; const char *encoding = NULL; + int group_right_2 = 0; const char *errors = NULL; - PyObject *v; - - if (!PyArg_ParseTuple(args, "O|ss:encode", &v, &encoding, &errors)) - return NULL; - + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:encode", &obj)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Os:encode", &obj, &encoding)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Oss:encode", &obj, &encoding, &errors)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.encode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_encode_impl(module, obj, group_right_1, encoding, group_right_2, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_encode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors) +/*[clinic end generated code: checksum=d0b39a3c88fb948bfa5bb77b234dd50df4eb9f5d]*/ +{ if (encoding == NULL) encoding = PyUnicode_GetDefaultEncoding(); /* Encode via the codec registry */ - return PyCodec_Encode(v, encoding, errors); + return PyCodec_Encode(obj, encoding, errors); } -PyDoc_STRVAR(decode__doc__, -"decode(obj, [encoding[,errors]]) -> object\n\ -\n\ -Decodes obj using the codec registered for encoding. encoding defaults\n\ -to the default encoding. errors may be given to set a different error\n\ -handling scheme. Default is 'strict' meaning that encoding errors raise\n\ -a ValueError. Other possible values are 'ignore' and 'replace'\n\ -as well as any other name registered with codecs.register_error that is\n\ -able to handle ValueErrors."); +/*[clinic input] +_codecs.decode + obj: object + [ + encoding: str + [ + errors: str + ] + ] + / + +decode(obj, [encoding[,errors]]) -> object + +Decodes obj using the codec registered for encoding. encoding defaults to the +default encoding. errors may be given to set a different error handling scheme. +Default is 'strict' meaning that encoding errors raise a ValueError. Other +possible values are 'ignore' and 'replace' as well as any other name registered +with codecs.register_error that is able to handle ValueErrors. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_decode__doc__, +"decode(obj, [encoding, [errors]])\n" +"decode(obj, [encoding[,errors]]) -> object\n" +"\n" +"Decodes obj using the codec registered for encoding. encoding defaults to the\n" +"default encoding. errors may be given to set a different error handling scheme.\n" +"Default is \'strict\' meaning that encoding errors raise a ValueError. Other\n" +"possible values are \'ignore\' and \'replace\' as well as any other name registered\n" +"with codecs.register_error that is able to handle ValueErrors."); + +#define _CODECS_DECODE_METHODDEF \ + {"decode", (PyCFunction)_codecs_decode, METH_VARARGS, _codecs_decode__doc__}, static PyObject * -codec_decode(PyObject *self, PyObject *args) +_codecs_decode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors); + +static PyObject * +_codecs_decode(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; + PyObject *obj; + int group_right_1 = 0; const char *encoding = NULL; + int group_right_2 = 0; const char *errors = NULL; - PyObject *v; - - if (!PyArg_ParseTuple(args, "O|ss:decode", &v, &encoding, &errors)) - return NULL; - + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:decode", &obj)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Os:decode", &obj, &encoding)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Oss:decode", &obj, &encoding, &errors)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_decode_impl(module, obj, group_right_1, encoding, group_right_2, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_decode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors) +/*[clinic end generated code: checksum=8b9f34033e782db99bb2837e1f2decc3f184db5f]*/ +{ if (encoding == NULL) encoding = PyUnicode_GetDefaultEncoding(); /* Decode via the codec registry */ - return PyCodec_Decode(v, encoding, errors); + return PyCodec_Decode(obj, encoding, errors); } /* --- Helpers ------------------------------------------------------------ */ @@ -147,35 +294,115 @@ } /* --- String codecs ------------------------------------------------------ */ +/*[clinic input] +_codecs.escape_decode + data: str(length=True) + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_escape_decode__doc__, +"escape_decode(data, [errors])"); + +#define _CODECS_ESCAPE_DECODE_METHODDEF \ + {"escape_decode", (PyCFunction)_codecs_escape_decode, METH_VARARGS, _codecs_escape_decode__doc__}, + static PyObject * -escape_decode(PyObject *self, - PyObject *args) +_codecs_escape_decode_impl(PyModuleDef *module, const char *data, Py_ssize_clean_t data_length, int group_right_1, const char *errors); + +static PyObject * +_codecs_escape_decode(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; + const char *data; + Py_ssize_clean_t data_length; + int group_right_1 = 0; const char *errors = NULL; - const char *data; - Py_ssize_t size; - - if (!PyArg_ParseTuple(args, "s#|z:escape_decode", - &data, &size, &errors)) - return NULL; - return codec_tuple(PyBytes_DecodeEscape(data, size, errors, 0, NULL), - size); + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s#:escape_decode", &data, &data_length)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "s#z:escape_decode", &data, &data_length, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.escape_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_escape_decode_impl(module, data, data_length, group_right_1, errors); + +exit: + return return_value; } static PyObject * -escape_encode(PyObject *self, - PyObject *args) +_codecs_escape_decode_impl(PyModuleDef *module, const char *data, Py_ssize_clean_t data_length, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=46a5eebe35721375a144fb74ac87fa7268f35f0e]*/ { + return codec_tuple(PyBytes_DecodeEscape(data, data_length, errors, 0, NULL), + data_length); +} + +/*[clinic input] +_codecs.escape_encode + str: object(subclass_of='&PyBytes_Type') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_escape_encode__doc__, +"escape_encode(str, [errors])"); + +#define _CODECS_ESCAPE_ENCODE_METHODDEF \ + {"escape_encode", (PyCFunction)_codecs_escape_encode, METH_VARARGS, _codecs_escape_encode__doc__}, + +static PyObject * +_codecs_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_escape_encode(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; PyObject *str; + int group_right_1 = 0; + const char *errors = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O!:escape_encode", &PyBytes_Type, &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "O!z:escape_encode", &PyBytes_Type, &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.escape_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_escape_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=776a8f71580582821da774eccdd9c9d92aa31a3a]*/ +{ Py_ssize_t size; Py_ssize_t newsize; - const char *errors = NULL; PyObject *v; - if (!PyArg_ParseTuple(args, "O!|z:escape_encode", - &PyBytes_Type, &str, &errors)) - return NULL; - size = PyBytes_GET_SIZE(str); if (size > PY_SSIZE_T_MAX / 4) { PyErr_SetString(PyExc_OverflowError, @@ -224,20 +451,59 @@ } /* --- Decoder ------------------------------------------------------------ */ +/*[clinic input] +_codecs.unicode_internal_decode + obj: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_unicode_internal_decode__doc__, +"unicode_internal_decode(obj, [errors])"); + +#define _CODECS_UNICODE_INTERNAL_DECODE_METHODDEF \ + {"unicode_internal_decode", (PyCFunction)_codecs_unicode_internal_decode, METH_VARARGS, _codecs_unicode_internal_decode__doc__}, static PyObject * -unicode_internal_decode(PyObject *self, - PyObject *args) +_codecs_unicode_internal_decode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *errors); + +static PyObject * +_codecs_unicode_internal_decode(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; PyObject *obj; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_internal_decode", &obj)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_internal_decode", &obj, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.unicode_internal_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_unicode_internal_decode_impl(module, obj, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_unicode_internal_decode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=63b483ac76a03d65b5dfbee35dc36b5005b0c167]*/ +{ const char *data; Py_ssize_t size; - if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode", - &obj, &errors)) - return NULL; - if (PyUnicode_Check(obj)) { if (PyUnicode_READY(obj) < 0) return NULL; @@ -253,118 +519,382 @@ } } +/*[clinic input] +_codecs.utf_7_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_7_decode__doc__, +"utf_7_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_7_DECODE_METHODDEF \ + {"utf_7_decode", (PyCFunction)_codecs_utf_7_decode, METH_VARARGS, _codecs_utf_7_decode__doc__}, + static PyObject * -utf_7_decode(PyObject *self, - PyObject *args) +_codecs_utf_7_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_7_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int final = 0; - Py_ssize_t consumed; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_7_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_7_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_7_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_7_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_7_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_7_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=fb8d5211644e77ea89cc29ca73f2c8f4cf70a428]*/ +{ + Py_ssize_t consumed = pbuf->len; PyObject *decoded = NULL; - if (!PyArg_ParseTuple(args, "y*|zi:utf_7_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; - - decoded = PyUnicode_DecodeUTF7Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF7Stateful(pbuf->buf, pbuf->len, errors, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_8_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_8_decode__doc__, +"utf_8_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_8_DECODE_METHODDEF \ + {"utf_8_decode", (PyCFunction)_codecs_utf_8_decode, METH_VARARGS, _codecs_utf_8_decode__doc__}, + static PyObject * -utf_8_decode(PyObject *self, - PyObject *args) +_codecs_utf_8_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_8_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int final = 0; - Py_ssize_t consumed; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_8_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_8_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_8_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_8_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_8_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_8_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=add50aea5544efeab76d7d378058b2a27b3ad1d2]*/ +{ + Py_ssize_t consumed = pbuf->len; PyObject *decoded = NULL; - if (!PyArg_ParseTuple(args, "y*|zi:utf_8_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; - - decoded = PyUnicode_DecodeUTF8Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF8Stateful(pbuf->buf, pbuf->len, errors, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_16_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_decode__doc__, +"utf_16_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_16_DECODE_METHODDEF \ + {"utf_16_decode", (PyCFunction)_codecs_utf_16_decode, METH_VARARGS, _codecs_utf_16_decode__doc__}, + static PyObject * -utf_16_decode(PyObject *self, - PyObject *args) +_codecs_utf_16_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_16_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_16_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_16_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=ac2e640aa8258b987af80f068a3d08f03706ba6d]*/ +{ int byteorder = 0; - int final = 0; - Py_ssize_t consumed; PyObject *decoded; - - if (!PyArg_ParseTuple(args, "y*|zi:utf_16_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF16Stateful(pbuf.buf, pbuf.len, errors, + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; + + decoded = PyUnicode_DecodeUTF16Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_16_le_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_le_decode__doc__, +"utf_16_le_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_16_LE_DECODE_METHODDEF \ + {"utf_16_le_decode", (PyCFunction)_codecs_utf_16_le_decode, METH_VARARGS, _codecs_utf_16_le_decode__doc__}, + static PyObject * -utf_16_le_decode(PyObject *self, - PyObject *args) +_codecs_utf_16_le_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_16_le_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_le_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_le_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_le_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_le_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_16_le_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_16_le_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=38b8b1cb7df00a9a699c4db62f4210c054746f50]*/ +{ int byteorder = -1; - int final = 0; - Py_ssize_t consumed; + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; PyObject *decoded = NULL; - if (!PyArg_ParseTuple(args, "y*|zi:utf_16_le_decode", - &pbuf, &errors, &final)) - return NULL; - - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF16Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF16Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_16_be_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_be_decode__doc__, +"utf_16_be_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_16_BE_DECODE_METHODDEF \ + {"utf_16_be_decode", (PyCFunction)_codecs_utf_16_be_decode, METH_VARARGS, _codecs_utf_16_be_decode__doc__}, + static PyObject * -utf_16_be_decode(PyObject *self, - PyObject *args) +_codecs_utf_16_be_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_16_be_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_be_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_be_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_be_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_be_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_16_be_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_16_be_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=55212129c0d6414173a0a89d5cb11b4b3ce7d1f7]*/ +{ int byteorder = 1; - int final = 0; - Py_ssize_t consumed; + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; PyObject *decoded = NULL; - if (!PyArg_ParseTuple(args, "y*|zi:utf_16_be_decode", - &pbuf, &errors, &final)) - return NULL; - - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF16Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF16Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -377,25 +907,89 @@ being the value in effect at the end of data. */ +/*[clinic input] +_codecs.utf_16_ex_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + [ + final: int = 0 + ] + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_ex_decode__doc__, +"utf_16_ex_decode(pbuf, [errors, [byteorder=0, [final=0]]])"); + +#define _CODECS_UTF_16_EX_DECODE_METHODDEF \ + {"utf_16_ex_decode", (PyCFunction)_codecs_utf_16_ex_decode, METH_VARARGS, _codecs_utf_16_ex_decode__doc__}, static PyObject * -utf_16_ex_decode(PyObject *self, - PyObject *args) +_codecs_utf_16_ex_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int byteorder, int group_right_3, int final); + +static PyObject * +_codecs_utf_16_ex_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int byteorder = 0; + int group_right_3 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_ex_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_ex_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_ex_decode", &pbuf, &errors, &byteorder)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + case 4: + if (!PyArg_ParseTuple(args, "y*zii:utf_16_ex_decode", &pbuf, &errors, &byteorder, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + group_right_3 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_ex_decode requires 1 to 4 arguments"); + goto exit; + } + return_value = _codecs_utf_16_ex_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, byteorder, group_right_3, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_16_ex_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int byteorder, int group_right_3, int final) +/*[clinic end generated code: checksum=cf8d80890fd043490585cb01fabe916a182d72e0]*/ +{ PyObject *unicode, *tuple; - int final = 0; - Py_ssize_t consumed; - - if (!PyArg_ParseTuple(args, "y*|zii:utf_16_ex_decode", - &pbuf, &errors, &byteorder, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - unicode = PyUnicode_DecodeUTF16Stateful(pbuf.buf, pbuf.len, errors, + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; + + unicode = PyUnicode_DecodeUTF16Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (unicode == NULL) return NULL; tuple = Py_BuildValue("Oni", unicode, consumed, byteorder); @@ -403,70 +997,232 @@ return tuple; } +/*[clinic input] +_codecs.utf_32_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_decode__doc__, +"utf_32_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_32_DECODE_METHODDEF \ + {"utf_32_decode", (PyCFunction)_codecs_utf_32_decode, METH_VARARGS, _codecs_utf_32_decode__doc__}, + static PyObject * -utf_32_decode(PyObject *self, - PyObject *args) +_codecs_utf_32_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_32_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_32_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_32_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=6dfac79d253986342a1797fda8c5312a2c75a617]*/ +{ int byteorder = 0; - int final = 0; - Py_ssize_t consumed; + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; PyObject *decoded; - if (!PyArg_ParseTuple(args, "y*|zi:utf_32_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF32Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF32Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_32_le_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_le_decode__doc__, +"utf_32_le_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_32_LE_DECODE_METHODDEF \ + {"utf_32_le_decode", (PyCFunction)_codecs_utf_32_le_decode, METH_VARARGS, _codecs_utf_32_le_decode__doc__}, + static PyObject * -utf_32_le_decode(PyObject *self, - PyObject *args) +_codecs_utf_32_le_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_32_le_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_le_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_le_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_le_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_le_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_32_le_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_32_le_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=5eaddc8d185e23f8d0f48af6f444bbcc22af557b]*/ +{ int byteorder = -1; - int final = 0; - Py_ssize_t consumed; + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; PyObject *decoded; - if (!PyArg_ParseTuple(args, "y*|zi:utf_32_le_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF32Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF32Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.utf_32_be_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_be_decode__doc__, +"utf_32_be_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_UTF_32_BE_DECODE_METHODDEF \ + {"utf_32_be_decode", (PyCFunction)_codecs_utf_32_be_decode, METH_VARARGS, _codecs_utf_32_be_decode__doc__}, + static PyObject * -utf_32_be_decode(PyObject *self, - PyObject *args) +_codecs_utf_32_be_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_utf_32_be_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_be_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_be_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_be_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_be_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_32_be_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_32_be_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=474fac06a0588484b5b1b422276feabba83b8055]*/ +{ int byteorder = 1; - int final = 0; - Py_ssize_t consumed; + /* This is overwritten unless final is true. */ + Py_ssize_t consumed = pbuf->len; PyObject *decoded; - if (!PyArg_ParseTuple(args, "y*|zi:utf_32_be_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - decoded = PyUnicode_DecodeUTF32Stateful(pbuf.buf, pbuf.len, errors, + decoded = PyUnicode_DecodeUTF32Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -479,25 +1235,88 @@ being the value in effect at the end of data. */ +/*[clinic input] +_codecs.utf_32_ex_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + [ + final: int = 0 + ] + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_ex_decode__doc__, +"utf_32_ex_decode(pbuf, [errors, [byteorder=0, [final=0]]])"); + +#define _CODECS_UTF_32_EX_DECODE_METHODDEF \ + {"utf_32_ex_decode", (PyCFunction)_codecs_utf_32_ex_decode, METH_VARARGS, _codecs_utf_32_ex_decode__doc__}, static PyObject * -utf_32_ex_decode(PyObject *self, - PyObject *args) +_codecs_utf_32_ex_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int byteorder, int group_right_3, int final); + +static PyObject * +_codecs_utf_32_ex_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int byteorder = 0; + int group_right_3 = 0; + int final = 0; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_ex_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_ex_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_ex_decode", &pbuf, &errors, &byteorder)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + case 4: + if (!PyArg_ParseTuple(args, "y*zii:utf_32_ex_decode", &pbuf, &errors, &byteorder, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + group_right_3 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_ex_decode requires 1 to 4 arguments"); + goto exit; + } + return_value = _codecs_utf_32_ex_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, byteorder, group_right_3, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_utf_32_ex_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int byteorder, int group_right_3, int final) +/*[clinic end generated code: checksum=624b710f4ffbcd8c8e7b44646d281b31aa371ca9]*/ +{ PyObject *unicode, *tuple; - int final = 0; - Py_ssize_t consumed; - - if (!PyArg_ParseTuple(args, "y*|zii:utf_32_ex_decode", - &pbuf, &errors, &byteorder, &final)) - return NULL; - consumed = pbuf.len; /* This is overwritten unless final is true. */ - unicode = PyUnicode_DecodeUTF32Stateful(pbuf.buf, pbuf.len, errors, + Py_ssize_t consumed = pbuf->len; + + unicode = PyUnicode_DecodeUTF32Stateful(pbuf->buf, pbuf->len, errors, &byteorder, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); if (unicode == NULL) return NULL; tuple = Py_BuildValue("Oni", unicode, consumed, byteorder); @@ -505,139 +1324,465 @@ return tuple; } +/*[clinic input] +_codecs.unicode_escape_decode + pbuf: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_unicode_escape_decode__doc__, +"unicode_escape_decode(pbuf, [errors])"); + +#define _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \ + {"unicode_escape_decode", (PyCFunction)_codecs_unicode_escape_decode, METH_VARARGS, _codecs_unicode_escape_decode__doc__}, + static PyObject * -unicode_escape_decode(PyObject *self, - PyObject *args) +_codecs_unicode_escape_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_unicode_escape_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; - PyObject *unicode; - - if (!PyArg_ParseTuple(args, "s*|z:unicode_escape_decode", - &pbuf, &errors)) - return NULL; - - unicode = PyUnicode_DecodeUnicodeEscape(pbuf.buf, pbuf.len, errors); - PyBuffer_Release(&pbuf); - return codec_tuple(unicode, pbuf.len); + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:unicode_escape_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:unicode_escape_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.unicode_escape_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_unicode_escape_decode_impl(module, &pbuf, group_right_1, errors); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -raw_unicode_escape_decode(PyObject *self, - PyObject *args) +_codecs_unicode_escape_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=a4f1ad6cef16d28d42d71d23f65ebeb86706ef18]*/ { - Py_buffer pbuf; + PyObject *unicode; + + unicode = PyUnicode_DecodeUnicodeEscape(pbuf->buf, pbuf->len, errors); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.raw_unicode_escape_decode + pbuf: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_raw_unicode_escape_decode__doc__, +"raw_unicode_escape_decode(pbuf, [errors])"); + +#define _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \ + {"raw_unicode_escape_decode", (PyCFunction)_codecs_raw_unicode_escape_decode, METH_VARARGS, _codecs_raw_unicode_escape_decode__doc__}, + +static PyObject * +_codecs_raw_unicode_escape_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_raw_unicode_escape_decode(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:raw_unicode_escape_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:raw_unicode_escape_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.raw_unicode_escape_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_raw_unicode_escape_decode_impl(module, &pbuf, group_right_1, errors); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_raw_unicode_escape_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=4318adec615aba60c57c4fe9403b25b564343d3d]*/ +{ PyObject *unicode; - if (!PyArg_ParseTuple(args, "s*|z:raw_unicode_escape_decode", - &pbuf, &errors)) - return NULL; - - unicode = PyUnicode_DecodeRawUnicodeEscape(pbuf.buf, pbuf.len, errors); - PyBuffer_Release(&pbuf); - return codec_tuple(unicode, pbuf.len); + unicode = PyUnicode_DecodeRawUnicodeEscape(pbuf->buf, pbuf->len, errors); + return codec_tuple(unicode, pbuf->len); } +/*[clinic input] +_codecs.latin_1_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_latin_1_decode__doc__, +"latin_1_decode(pbuf, [errors])"); + +#define _CODECS_LATIN_1_DECODE_METHODDEF \ + {"latin_1_decode", (PyCFunction)_codecs_latin_1_decode, METH_VARARGS, _codecs_latin_1_decode__doc__}, + static PyObject * -latin_1_decode(PyObject *self, - PyObject *args) +_codecs_latin_1_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_latin_1_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; + const char *errors = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:latin_1_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:latin_1_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.latin_1_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_latin_1_decode_impl(module, &pbuf, group_right_1, errors); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_latin_1_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=92c11e59f33c3fd2792c500207a4eb225c63691e]*/ +{ PyObject *unicode; + + unicode = PyUnicode_DecodeLatin1(pbuf->buf, pbuf->len, errors); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.ascii_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_ascii_decode__doc__, +"ascii_decode(pbuf, [errors])"); + +#define _CODECS_ASCII_DECODE_METHODDEF \ + {"ascii_decode", (PyCFunction)_codecs_ascii_decode, METH_VARARGS, _codecs_ascii_decode__doc__}, + +static PyObject * +_codecs_ascii_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_ascii_decode(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "y*|z:latin_1_decode", - &pbuf, &errors)) - return NULL; - - unicode = PyUnicode_DecodeLatin1(pbuf.buf, pbuf.len, errors); - PyBuffer_Release(&pbuf); - return codec_tuple(unicode, pbuf.len); + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:ascii_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:ascii_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.ascii_decode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_ascii_decode_impl(module, &pbuf, group_right_1, errors); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -ascii_decode(PyObject *self, - PyObject *args) +_codecs_ascii_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=3393779d2d8b1006cf9543c15a58c69dc3124be7]*/ { - Py_buffer pbuf; PyObject *unicode; + + unicode = PyUnicode_DecodeASCII(pbuf->buf, pbuf->len, errors); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.charmap_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + mapping: object = NULL + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_charmap_decode__doc__, +"charmap_decode(pbuf, [errors, [mapping=None]])"); + +#define _CODECS_CHARMAP_DECODE_METHODDEF \ + {"charmap_decode", (PyCFunction)_codecs_charmap_decode, METH_VARARGS, _codecs_charmap_decode__doc__}, + +static PyObject * +_codecs_charmap_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, PyObject *mapping); + +static PyObject * +_codecs_charmap_decode(PyModuleDef *module, PyObject *args) +{ + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; - - if (!PyArg_ParseTuple(args, "y*|z:ascii_decode", - &pbuf, &errors)) - return NULL; - - unicode = PyUnicode_DecodeASCII(pbuf.buf, pbuf.len, errors); - PyBuffer_Release(&pbuf); - return codec_tuple(unicode, pbuf.len); + int group_right_2 = 0; + PyObject *mapping = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:charmap_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:charmap_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zO:charmap_decode", &pbuf, &errors, &mapping)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.charmap_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_charmap_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, mapping); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -charmap_decode(PyObject *self, - PyObject *args) +_codecs_charmap_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, PyObject *mapping) +/*[clinic end generated code: checksum=4a50bbf5d762a8fbf46f6cdaec7d44a4818a8e73]*/ { - Py_buffer pbuf; PyObject *unicode; - const char *errors = NULL; - PyObject *mapping = NULL; - - if (!PyArg_ParseTuple(args, "y*|zO:charmap_decode", - &pbuf, &errors, &mapping)) - return NULL; + if (mapping == Py_None) mapping = NULL; - unicode = PyUnicode_DecodeCharmap(pbuf.buf, pbuf.len, mapping, errors); - PyBuffer_Release(&pbuf); - return codec_tuple(unicode, pbuf.len); + unicode = PyUnicode_DecodeCharmap(pbuf->buf, pbuf->len, mapping, errors); + return codec_tuple(unicode, pbuf->len); } #ifdef HAVE_MBCS +/*[clinic input] +_codecs.mbcs_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_mbcs_decode__doc__, +"mbcs_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_MBCS_DECODE_METHODDEF \ + {"mbcs_decode", (PyCFunction)_codecs_mbcs_decode, METH_VARARGS, _codecs_mbcs_decode__doc__}, + static PyObject * -mbcs_decode(PyObject *self, - PyObject *args) +_codecs_mbcs_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_mbcs_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int final = 0; - Py_ssize_t consumed; - PyObject *decoded = NULL; - - if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode", - &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; - - decoded = PyUnicode_DecodeMBCSStateful(pbuf.buf, pbuf.len, errors, - final ? NULL : &consumed); - PyBuffer_Release(&pbuf); + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:mbcs_decode", &pbuf)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:mbcs_decode", &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:mbcs_decode", &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.mbcs_decode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_mbcs_decode_impl(module, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_mbcs_decode_impl(PyModuleDef *module, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=53961576260d19c1e713465601c65f6e00cefb46]*/ +{ + Py_ssize_t consumed = pbuf->len; + PyObject *decoded = PyUnicode_DecodeMBCSStateful(pbuf->buf, pbuf->len, + errors, final ? NULL : &consumed); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.code_page_decode + codepage: int + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_code_page_decode__doc__, +"code_page_decode(codepage, pbuf, [errors, [final=0]])"); + +#define _CODECS_CODE_PAGE_DECODE_METHODDEF \ + {"code_page_decode", (PyCFunction)_codecs_code_page_decode, METH_VARARGS, _codecs_code_page_decode__doc__}, + static PyObject * -code_page_decode(PyObject *self, - PyObject *args) +_codecs_code_page_decode_impl(PyModuleDef *module, int codepage, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_code_page_decode(PyModuleDef *module, PyObject *args) { - Py_buffer pbuf; + PyObject *return_value = NULL; + int codepage; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int final = 0; - Py_ssize_t consumed; - PyObject *decoded = NULL; - int code_page; - - if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode", - &code_page, &pbuf, &errors, &final)) - return NULL; - consumed = pbuf.len; - - decoded = PyUnicode_DecodeCodePageStateful(code_page, - pbuf.buf, pbuf.len, errors, - final ? NULL : &consumed); - PyBuffer_Release(&pbuf); + + switch (PyTuple_GET_SIZE(args)) { + case 2: + if (!PyArg_ParseTuple(args, "iy*:code_page_decode", &codepage, &pbuf)) + goto exit; + break; + case 3: + if (!PyArg_ParseTuple(args, "iy*z:code_page_decode", &codepage, &pbuf, &errors)) + goto exit; + group_right_1 = 1; + break; + case 4: + if (!PyArg_ParseTuple(args, "iy*zi:code_page_decode", &codepage, &pbuf, &errors, &final)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.code_page_decode requires 2 to 4 arguments"); + goto exit; + } + return_value = _codecs_code_page_decode_impl(module, codepage, &pbuf, group_right_1, errors, group_right_2, final); + +exit: + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_code_page_decode_impl(PyModuleDef *module, int codepage, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=3342d8bf89a0951b7b76012402c498ef291eea8d]*/ +{ + Py_ssize_t consumed = pbuf->len; + PyObject *decoded = PyUnicode_DecodeCodePageStateful(code_page, pbuf->buf, + pbuf->len, errors, final ? NULL : &consumed); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -647,33 +1792,117 @@ /* --- Encoder ------------------------------------------------------------ */ +/*[clinic input] +_codecs.readbuffer_encode + pdata: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_readbuffer_encode__doc__, +"readbuffer_encode(pdata, [errors])"); + +#define _CODECS_READBUFFER_ENCODE_METHODDEF \ + {"readbuffer_encode", (PyCFunction)_codecs_readbuffer_encode, METH_VARARGS, _codecs_readbuffer_encode__doc__}, + static PyObject * -readbuffer_encode(PyObject *self, - PyObject *args) +_codecs_readbuffer_encode_impl(PyModuleDef *module, Py_buffer *pdata, int group_right_1, const char *errors); + +static PyObject * +_codecs_readbuffer_encode(PyModuleDef *module, PyObject *args) { - Py_buffer pdata; - const char *data; - Py_ssize_t size; + PyObject *return_value = NULL; + Py_buffer pdata = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; - PyObject *result; - - if (!PyArg_ParseTuple(args, "s*|z:readbuffer_encode", - &pdata, &errors)) - return NULL; - data = pdata.buf; - size = pdata.len; - - result = PyBytes_FromStringAndSize(data, size); - PyBuffer_Release(&pdata); + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:readbuffer_encode", &pdata)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:readbuffer_encode", &pdata, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.readbuffer_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_readbuffer_encode_impl(module, &pdata, group_right_1, errors); + +exit: + /* Cleanup for pdata */ + if (pdata.obj) + PyBuffer_Release(&pdata); + + return return_value; +} + +static PyObject * +_codecs_readbuffer_encode_impl(PyModuleDef *module, Py_buffer *pdata, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=5fa6347ac504043813ffc37cf2984fd8e67ef8c4]*/ +{ + const char *data = pdata->buf; + Py_ssize_t size = pdata->len; + PyObject *result = PyBytes_FromStringAndSize(data, size); + return codec_tuple(result, size); } +/*[clinic input] +_codecs.unicode_internal_encode + obj: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_unicode_internal_encode__doc__, +"unicode_internal_encode(obj, [errors])"); + +#define _CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF \ + {"unicode_internal_encode", (PyCFunction)_codecs_unicode_internal_encode, METH_VARARGS, _codecs_unicode_internal_encode__doc__}, + static PyObject * -unicode_internal_encode(PyObject *self, - PyObject *args) +_codecs_unicode_internal_encode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *errors); + +static PyObject * +_codecs_unicode_internal_encode(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; PyObject *obj; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_internal_encode", &obj)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_internal_encode", &obj, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.unicode_internal_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_unicode_internal_encode_impl(module, obj, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_unicode_internal_encode_impl(PyModuleDef *module, PyObject *obj, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=b56652e1cf6c2b61773e72bb7f099b39eaf1d69c]*/ +{ const char *data; Py_ssize_t len, size; @@ -682,10 +1911,6 @@ 1)) return NULL; - if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode", - &obj, &errors)) - return NULL; - if (PyUnicode_Check(obj)) { Py_UNICODE *u; @@ -708,16 +1933,57 @@ } } +/*[clinic input] +_codecs.utf_7_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_7_encode__doc__, +"utf_7_encode(str, [errors])"); + +#define _CODECS_UTF_7_ENCODE_METHODDEF \ + {"utf_7_encode", (PyCFunction)_codecs_utf_7_encode, METH_VARARGS, _codecs_utf_7_encode__doc__}, + static PyObject * -utf_7_encode(PyObject *self, - PyObject *args) +_codecs_utf_7_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_7_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_7_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_7_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_7_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_7_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_7_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_7_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=0adb177420a46221b0c134915739071a9e6286ee]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -730,16 +1996,57 @@ return v; } +/*[clinic input] +_codecs.utf_8_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_8_encode__doc__, +"utf_8_encode(str, [errors])"); + +#define _CODECS_UTF_8_ENCODE_METHODDEF \ + {"utf_8_encode", (PyCFunction)_codecs_utf_8_encode, METH_VARARGS, _codecs_utf_8_encode__doc__}, + static PyObject * -utf_8_encode(PyObject *self, - PyObject *args) +_codecs_utf_8_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_8_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_8_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_8_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_8_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_8_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_8_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_8_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=44a237cb52631e88c3e84c2445448b8793d8a505]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -759,17 +2066,68 @@ */ +/*[clinic input] +_codecs.utf_16_encode + str: object + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_encode__doc__, +"utf_16_encode(str, [errors, [byteorder=0]])"); + +#define _CODECS_UTF_16_ENCODE_METHODDEF \ + {"utf_16_encode", (PyCFunction)_codecs_utf_16_encode, METH_VARARGS, _codecs_utf_16_encode__doc__}, + static PyObject * -utf_16_encode(PyObject *self, - PyObject *args) +_codecs_utf_16_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder); + +static PyObject * +_codecs_utf_16_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int byteorder = 0; - if (!PyArg_ParseTuple(args, "O|zi:utf_16_encode", - &str, &errors, &byteorder)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Ozi:utf_16_encode", &str, &errors, &byteorder)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_encode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_16_encode_impl(module, str, group_right_1, errors, group_right_2, byteorder); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_16_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder) +/*[clinic end generated code: checksum=3814b7b920c36d78abf45fa739de37919cdadff7]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -782,16 +2140,57 @@ return v; } +/*[clinic input] +_codecs.utf_16_le_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_le_encode__doc__, +"utf_16_le_encode(str, [errors])"); + +#define _CODECS_UTF_16_LE_ENCODE_METHODDEF \ + {"utf_16_le_encode", (PyCFunction)_codecs_utf_16_le_encode, METH_VARARGS, _codecs_utf_16_le_encode__doc__}, + static PyObject * -utf_16_le_encode(PyObject *self, - PyObject *args) +_codecs_utf_16_le_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_16_le_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_16_le_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_le_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_le_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_le_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_16_le_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_16_le_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=e7008222f9977614693b23dc891b6b7846bf4e3a]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -804,16 +2203,57 @@ return v; } +/*[clinic input] +_codecs.utf_16_be_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_16_be_encode__doc__, +"utf_16_be_encode(str, [errors])"); + +#define _CODECS_UTF_16_BE_ENCODE_METHODDEF \ + {"utf_16_be_encode", (PyCFunction)_codecs_utf_16_be_encode, METH_VARARGS, _codecs_utf_16_be_encode__doc__}, + static PyObject * -utf_16_be_encode(PyObject *self, - PyObject *args) +_codecs_utf_16_be_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_16_be_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_16_be_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_be_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_be_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_16_be_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_16_be_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_16_be_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=d589cdff0141f3587ed19012e7d9ec881191eb9a]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -833,17 +2273,68 @@ */ +/*[clinic input] +_codecs.utf_32_encode + str: object + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_encode__doc__, +"utf_32_encode(str, [errors, [byteorder=0]])"); + +#define _CODECS_UTF_32_ENCODE_METHODDEF \ + {"utf_32_encode", (PyCFunction)_codecs_utf_32_encode, METH_VARARGS, _codecs_utf_32_encode__doc__}, + static PyObject * -utf_32_encode(PyObject *self, - PyObject *args) +_codecs_utf_32_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder); + +static PyObject * +_codecs_utf_32_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; int byteorder = 0; - if (!PyArg_ParseTuple(args, "O|zi:utf_32_encode", - &str, &errors, &byteorder)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Ozi:utf_32_encode", &str, &errors, &byteorder)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_encode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_utf_32_encode_impl(module, str, group_right_1, errors, group_right_2, byteorder); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_32_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder) +/*[clinic end generated code: checksum=d0408eb2e13407d42c9bff4ac743adf323eb5d07]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -856,16 +2347,57 @@ return v; } +/*[clinic input] +_codecs.utf_32_le_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_le_encode__doc__, +"utf_32_le_encode(str, [errors])"); + +#define _CODECS_UTF_32_LE_ENCODE_METHODDEF \ + {"utf_32_le_encode", (PyCFunction)_codecs_utf_32_le_encode, METH_VARARGS, _codecs_utf_32_le_encode__doc__}, + static PyObject * -utf_32_le_encode(PyObject *self, - PyObject *args) +_codecs_utf_32_le_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_32_le_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_32_le_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_le_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_le_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_le_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_32_le_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_32_le_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=e5834ba689c39ee25c7a52321fd22753825a2419]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -878,16 +2410,57 @@ return v; } +/*[clinic input] +_codecs.utf_32_be_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_utf_32_be_encode__doc__, +"utf_32_be_encode(str, [errors])"); + +#define _CODECS_UTF_32_BE_ENCODE_METHODDEF \ + {"utf_32_be_encode", (PyCFunction)_codecs_utf_32_be_encode, METH_VARARGS, _codecs_utf_32_be_encode__doc__}, + static PyObject * -utf_32_be_encode(PyObject *self, - PyObject *args) +_codecs_utf_32_be_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_utf_32_be_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:utf_32_be_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_be_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_be_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.utf_32_be_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_utf_32_be_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_utf_32_be_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=8912bd32497f10586ea9197e04f875738122b617]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -900,16 +2473,57 @@ return v; } +/*[clinic input] +_codecs.unicode_escape_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_unicode_escape_encode__doc__, +"unicode_escape_encode(str, [errors])"); + +#define _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \ + {"unicode_escape_encode", (PyCFunction)_codecs_unicode_escape_encode, METH_VARARGS, _codecs_unicode_escape_encode__doc__}, + static PyObject * -unicode_escape_encode(PyObject *self, - PyObject *args) +_codecs_unicode_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_unicode_escape_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:unicode_escape_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_escape_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_escape_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.unicode_escape_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_unicode_escape_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_unicode_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=82b11223740ed15333384a1582822fca9df5d6d9]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -922,16 +2536,57 @@ return v; } +/*[clinic input] +_codecs.raw_unicode_escape_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_raw_unicode_escape_encode__doc__, +"raw_unicode_escape_encode(str, [errors])"); + +#define _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \ + {"raw_unicode_escape_encode", (PyCFunction)_codecs_raw_unicode_escape_encode, METH_VARARGS, _codecs_raw_unicode_escape_encode__doc__}, + static PyObject * -raw_unicode_escape_encode(PyObject *self, - PyObject *args) +_codecs_raw_unicode_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_raw_unicode_escape_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:raw_unicode_escape_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:raw_unicode_escape_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:raw_unicode_escape_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.raw_unicode_escape_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_raw_unicode_escape_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_raw_unicode_escape_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=b31ba35ce628f21cceb0ea48a59ebd923327bdb7]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -944,16 +2599,57 @@ return v; } +/*[clinic input] +_codecs.latin_1_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_latin_1_encode__doc__, +"latin_1_encode(str, [errors])"); + +#define _CODECS_LATIN_1_ENCODE_METHODDEF \ + {"latin_1_encode", (PyCFunction)_codecs_latin_1_encode, METH_VARARGS, _codecs_latin_1_encode__doc__}, + static PyObject * -latin_1_encode(PyObject *self, - PyObject *args) +_codecs_latin_1_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_latin_1_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:latin_1_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:latin_1_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:latin_1_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.latin_1_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_latin_1_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_latin_1_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=20a26c86f23312b36e740695f6f60c06892e6904]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -966,16 +2662,57 @@ return v; } +/*[clinic input] +_codecs.ascii_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_ascii_encode__doc__, +"ascii_encode(str, [errors])"); + +#define _CODECS_ASCII_ENCODE_METHODDEF \ + {"ascii_encode", (PyCFunction)_codecs_ascii_encode, METH_VARARGS, _codecs_ascii_encode__doc__}, + static PyObject * -ascii_encode(PyObject *self, - PyObject *args) +_codecs_ascii_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_ascii_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:ascii_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:ascii_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:ascii_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.ascii_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_ascii_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_ascii_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=5a33771c2bee9168980a88aaac867026d955d5c2]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -988,17 +2725,69 @@ return v; } +/*[clinic input] +_codecs.charmap_encode + str: object + [ + errors: str(nullable=True) + [ + mapping: object = NULL + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_charmap_encode__doc__, +"charmap_encode(str, [errors, [mapping=None]])"); + +#define _CODECS_CHARMAP_ENCODE_METHODDEF \ + {"charmap_encode", (PyCFunction)_codecs_charmap_encode, METH_VARARGS, _codecs_charmap_encode__doc__}, + static PyObject * -charmap_encode(PyObject *self, - PyObject *args) +_codecs_charmap_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, PyObject *mapping); + +static PyObject * +_codecs_charmap_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; + int group_right_2 = 0; PyObject *mapping = NULL; - if (!PyArg_ParseTuple(args, "O|zO:charmap_encode", - &str, &errors, &mapping)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:charmap_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:charmap_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "OzO:charmap_encode", &str, &errors, &mapping)) + goto exit; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.charmap_encode requires 1 to 3 arguments"); + goto exit; + } + return_value = _codecs_charmap_encode_impl(module, str, group_right_1, errors, group_right_2, mapping); + +exit: + return return_value; +} + +static PyObject * +_codecs_charmap_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors, int group_right_2, PyObject *mapping) +/*[clinic end generated code: checksum=30508a6f4f8d6ea696d7634913d813b6e9c2e3e4]*/ +{ + PyObject *v; + if (mapping == Py_None) mapping = NULL; @@ -1013,27 +2802,97 @@ return v; } -static PyObject* -charmap_build(PyObject *self, PyObject *args) +/*[clinic input] +_codecs.charmap_build + map: unicode + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_charmap_build__doc__, +"charmap_build(map)"); + +#define _CODECS_CHARMAP_BUILD_METHODDEF \ + {"charmap_build", (PyCFunction)_codecs_charmap_build, METH_VARARGS, _codecs_charmap_build__doc__}, + +static PyObject * +_codecs_charmap_build_impl(PyModuleDef *module, PyObject *map); + +static PyObject * +_codecs_charmap_build(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; PyObject *map; - if (!PyArg_ParseTuple(args, "U:charmap_build", &map)) - return NULL; + + if (!PyArg_ParseTuple(args, + "U:charmap_build", + &map)) + goto exit; + return_value = _codecs_charmap_build_impl(module, map); + +exit: + return return_value; +} + +static PyObject * +_codecs_charmap_build_impl(PyModuleDef *module, PyObject *map) +/*[clinic end generated code: checksum=f6388c2f867f028f0d0e0b4992042c219699d557]*/ +{ return PyUnicode_BuildEncodingMap(map); } #ifdef HAVE_MBCS +/*[clinic input] +_codecs.mbcs_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_mbcs_encode__doc__, +"mbcs_encode(str, [errors])"); + +#define _CODECS_MBCS_ENCODE_METHODDEF \ + {"mbcs_encode", (PyCFunction)_codecs_mbcs_encode, METH_VARARGS, _codecs_mbcs_encode__doc__}, + static PyObject * -mbcs_encode(PyObject *self, - PyObject *args) +_codecs_mbcs_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_mbcs_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - if (!PyArg_ParseTuple(args, "O|z:mbcs_encode", - &str, &errors)) - return NULL; + switch (PyTuple_GET_SIZE(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:mbcs_encode", &str)) + goto exit; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:mbcs_encode", &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.mbcs_encode requires 1 to 2 arguments"); + goto exit; + } + return_value = _codecs_mbcs_encode_impl(module, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_mbcs_encode_impl(PyModuleDef *module, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=fd94a4b1b85b9722f0482e8ee886a3ac71e55623]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -1046,17 +2905,59 @@ return v; } +/*[clinic input] +_codecs.code_page_encode + code_page: int + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_code_page_encode__doc__, +"code_page_encode(code_page, str, [errors])"); + +#define _CODECS_CODE_PAGE_ENCODE_METHODDEF \ + {"code_page_encode", (PyCFunction)_codecs_code_page_encode, METH_VARARGS, _codecs_code_page_encode__doc__}, + static PyObject * -code_page_encode(PyObject *self, - PyObject *args) +_codecs_code_page_encode_impl(PyModuleDef *module, int code_page, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_code_page_encode(PyModuleDef *module, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + int code_page; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - int code_page; - - if (!PyArg_ParseTuple(args, "iO|z:code_page_encode", - &code_page, &str, &errors)) - return NULL; + + switch (PyTuple_GET_SIZE(args)) { + case 2: + if (!PyArg_ParseTuple(args, "iO:code_page_encode", &code_page, &str)) + goto exit; + break; + case 3: + if (!PyArg_ParseTuple(args, "iOz:code_page_encode", &code_page, &str, &errors)) + goto exit; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.code_page_encode requires 2 to 3 arguments"); + goto exit; + } + return_value = _codecs_code_page_encode_impl(module, code_page, str, group_right_1, errors); + +exit: + return return_value; +} + +static PyObject * +_codecs_code_page_encode_impl(PyModuleDef *module, int code_page, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=eb31e7f185c267a209444b9afd73050ae87976c6]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -1075,41 +2976,105 @@ /* --- Error handler registry --------------------------------------------- */ -PyDoc_STRVAR(register_error__doc__, -"register_error(errors, handler)\n\ -\n\ -Register the specified error handler under the name\n\ -errors. handler must be a callable object, that\n\ -will be called with an exception instance containing\n\ -information about the location of the encoding/decoding\n\ -error and must return a (replacement, new position) tuple."); - -static PyObject *register_error(PyObject *self, PyObject *args) +/*[clinic input] +_codecs.register_error + name: str + handler: object + / + +register_error(errors, handler) + +Register the specified error handler under the name errors. handler must be a +callable object, that will be called with an exception instance containing +information about the location of the encoding/decoding error and must return a +(replacement, new position) tuple. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_register_error__doc__, +"register_error(name, handler)\n" +"register_error(errors, handler)\n" +"\n" +"Register the specified error handler under the name errors. handler must be a\n" +"callable object, that will be called with an exception instance containing\n" +"information about the location of the encoding/decoding error and must return a\n" +"(replacement, new position) tuple."); + +#define _CODECS_REGISTER_ERROR_METHODDEF \ + {"register_error", (PyCFunction)_codecs_register_error, METH_VARARGS, _codecs_register_error__doc__}, + +static PyObject * +_codecs_register_error_impl(PyModuleDef *module, const char *name, PyObject *handler); + +static PyObject * +_codecs_register_error(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; const char *name; PyObject *handler; - if (!PyArg_ParseTuple(args, "sO:register_error", - &name, &handler)) - return NULL; + if (!PyArg_ParseTuple(args, + "sO:register_error", + &name, &handler)) + goto exit; + return_value = _codecs_register_error_impl(module, name, handler); + +exit: + return return_value; +} + +static PyObject * +_codecs_register_error_impl(PyModuleDef *module, const char *name, PyObject *handler) +/*[clinic end generated code: checksum=03c28e8089d387a8789770fc6dba97c080aa95ac]*/ +{ if (PyCodec_RegisterError(name, handler)) return NULL; Py_RETURN_NONE; } -PyDoc_STRVAR(lookup_error__doc__, -"lookup_error(errors) -> handler\n\ -\n\ -Return the error handler for the specified error handling name\n\ -or raise a LookupError, if no handler exists under this name."); - -static PyObject *lookup_error(PyObject *self, PyObject *args) +/*[clinic input] +_codecs.lookup_error + name: str + / + +lookup_error(errors) -> handler + +Return the error handler for the specified error handling name or raise a +LookupError, if no handler exists under this name. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_lookup_error__doc__, +"lookup_error(name)\n" +"lookup_error(errors) -> handler\n" +"\n" +"Return the error handler for the specified error handling name or raise a\n" +"LookupError, if no handler exists under this name."); + +#define _CODECS_LOOKUP_ERROR_METHODDEF \ + {"lookup_error", (PyCFunction)_codecs_lookup_error, METH_VARARGS, _codecs_lookup_error__doc__}, + +static PyObject * +_codecs_lookup_error_impl(PyModuleDef *module, const char *name); + +static PyObject * +_codecs_lookup_error(PyModuleDef *module, PyObject *args) { + PyObject *return_value = NULL; const char *name; - if (!PyArg_ParseTuple(args, "s:lookup_error", - &name)) - return NULL; + if (!PyArg_ParseTuple(args, + "s:lookup_error", + &name)) + goto exit; + return_value = _codecs_lookup_error_impl(module, name); + +exit: + return return_value; +} + +static PyObject * +_codecs_lookup_error_impl(PyModuleDef *module, const char *name) +/*[clinic end generated code: checksum=e1f61deb25d2c6d1f3a9cd91c302a5e4f89af05a]*/ +{ return PyCodec_LookupError(name); } @@ -1118,56 +3083,51 @@ static PyMethodDef _codecs_functions[] = { {"register", codec_register, METH_O, register__doc__}, - {"lookup", codec_lookup, METH_VARARGS, - lookup__doc__}, - {"encode", codec_encode, METH_VARARGS, - encode__doc__}, - {"decode", codec_decode, METH_VARARGS, - decode__doc__}, - {"escape_encode", escape_encode, METH_VARARGS}, - {"escape_decode", escape_decode, METH_VARARGS}, - {"utf_8_encode", utf_8_encode, METH_VARARGS}, - {"utf_8_decode", utf_8_decode, METH_VARARGS}, - {"utf_7_encode", utf_7_encode, METH_VARARGS}, - {"utf_7_decode", utf_7_decode, METH_VARARGS}, - {"utf_16_encode", utf_16_encode, METH_VARARGS}, - {"utf_16_le_encode", utf_16_le_encode, METH_VARARGS}, - {"utf_16_be_encode", utf_16_be_encode, METH_VARARGS}, - {"utf_16_decode", utf_16_decode, METH_VARARGS}, - {"utf_16_le_decode", utf_16_le_decode, METH_VARARGS}, - {"utf_16_be_decode", utf_16_be_decode, METH_VARARGS}, - {"utf_16_ex_decode", utf_16_ex_decode, METH_VARARGS}, - {"utf_32_encode", utf_32_encode, METH_VARARGS}, - {"utf_32_le_encode", utf_32_le_encode, METH_VARARGS}, - {"utf_32_be_encode", utf_32_be_encode, METH_VARARGS}, - {"utf_32_decode", utf_32_decode, METH_VARARGS}, - {"utf_32_le_decode", utf_32_le_decode, METH_VARARGS}, - {"utf_32_be_decode", utf_32_be_decode, METH_VARARGS}, - {"utf_32_ex_decode", utf_32_ex_decode, METH_VARARGS}, - {"unicode_escape_encode", unicode_escape_encode, METH_VARARGS}, - {"unicode_escape_decode", unicode_escape_decode, METH_VARARGS}, - {"unicode_internal_encode", unicode_internal_encode, METH_VARARGS}, - {"unicode_internal_decode", unicode_internal_decode, METH_VARARGS}, - {"raw_unicode_escape_encode", raw_unicode_escape_encode, METH_VARARGS}, - {"raw_unicode_escape_decode", raw_unicode_escape_decode, METH_VARARGS}, - {"latin_1_encode", latin_1_encode, METH_VARARGS}, - {"latin_1_decode", latin_1_decode, METH_VARARGS}, - {"ascii_encode", ascii_encode, METH_VARARGS}, - {"ascii_decode", ascii_decode, METH_VARARGS}, - {"charmap_encode", charmap_encode, METH_VARARGS}, - {"charmap_decode", charmap_decode, METH_VARARGS}, - {"charmap_build", charmap_build, METH_VARARGS}, - {"readbuffer_encode", readbuffer_encode, METH_VARARGS}, + _CODECS_LOOKUP_METHODDEF + _CODECS_ENCODE_METHODDEF + _CODECS_DECODE_METHODDEF + _CODECS_ESCAPE_ENCODE_METHODDEF + _CODECS_ESCAPE_DECODE_METHODDEF + _CODECS_UTF_8_ENCODE_METHODDEF + _CODECS_UTF_8_DECODE_METHODDEF + _CODECS_UTF_7_ENCODE_METHODDEF + _CODECS_UTF_7_DECODE_METHODDEF + _CODECS_UTF_16_ENCODE_METHODDEF + _CODECS_UTF_16_LE_ENCODE_METHODDEF + _CODECS_UTF_16_BE_ENCODE_METHODDEF + _CODECS_UTF_16_DECODE_METHODDEF + _CODECS_UTF_16_LE_DECODE_METHODDEF + _CODECS_UTF_16_BE_DECODE_METHODDEF + _CODECS_UTF_16_EX_DECODE_METHODDEF + _CODECS_UTF_32_ENCODE_METHODDEF + _CODECS_UTF_32_LE_ENCODE_METHODDEF + _CODECS_UTF_32_BE_ENCODE_METHODDEF + _CODECS_UTF_32_DECODE_METHODDEF + _CODECS_UTF_32_LE_DECODE_METHODDEF + _CODECS_UTF_32_BE_DECODE_METHODDEF + _CODECS_UTF_32_EX_DECODE_METHODDEF + _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF + _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF + _CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF + _CODECS_UNICODE_INTERNAL_DECODE_METHODDEF + _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF + _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF + _CODECS_LATIN_1_ENCODE_METHODDEF + _CODECS_LATIN_1_DECODE_METHODDEF + _CODECS_ASCII_ENCODE_METHODDEF + _CODECS_ASCII_DECODE_METHODDEF + _CODECS_CHARMAP_ENCODE_METHODDEF + _CODECS_CHARMAP_DECODE_METHODDEF + _CODECS_CHARMAP_BUILD_METHODDEF + _CODECS_READBUFFER_ENCODE_METHODDEF #ifdef HAVE_MBCS - {"mbcs_encode", mbcs_encode, METH_VARARGS}, - {"mbcs_decode", mbcs_decode, METH_VARARGS}, - {"code_page_encode", code_page_encode, METH_VARARGS}, - {"code_page_decode", code_page_decode, METH_VARARGS}, + _CODECS_MBCS_ENCODE_METHODDEF + _CODECS_MBCS_DECODE_METHODDEF + _CODECS_CODE_PAGE_ENCODE_METHODDEF + _CODECS_CODE_PAGE_DECODE_METHODDEF #endif - {"register_error", register_error, METH_VARARGS, - register_error__doc__}, - {"lookup_error", lookup_error, METH_VARARGS, - lookup_error__doc__}, + _CODECS_REGISTER_ERROR_METHODDEF + _CODECS_LOOKUP_ERROR_METHODDEF {NULL, NULL} /* sentinel */ };