diff -r a707f3cc0e8e Modules/_codecsmodule.c --- a/Modules/_codecsmodule.c Mon Jan 13 14:24:11 2014 +0200 +++ b/Modules/_codecsmodule.c Mon Jan 13 23:23:36 2014 +0800 @@ -42,6 +42,12 @@ #include #endif +/*[clinic input] +module _codecs +class _codecs.Codecs +[clinic start generated code]*/ +/*[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/ + /* --- Registry ----------------------------------------------------------- */ PyDoc_STRVAR(register__doc__, @@ -61,75 +67,215 @@ 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.Codecs.lookup + encoding: str + / + +Looks up an encoding. + +Looks up a codec tuple in the Python codec registry and returns a CodecInfo +object. +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_lookup__doc__, +"lookup(encoding)\n" +"Looks up an encoding.\n" +"\n" +"Looks up a codec tuple in the Python codec registry and returns a CodecInfo\n" +"object."); + +#define _CODECS_CODECS_LOOKUP_METHODDEF \ + {"lookup", (PyCFunction)_codecs_Codecs_lookup, METH_VARARGS, _codecs_Codecs_lookup__doc__}, + +static PyObject * +_codecs_Codecs_lookup_impl(PyObject *self, const char *encoding); + +static PyObject * +_codecs_Codecs_lookup(PyObject *self, 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_Codecs_lookup_impl(self, encoding); + +exit: + return return_value; +} + +static PyObject * +_codecs_Codecs_lookup_impl(PyObject *self, const char *encoding) +/*[clinic end generated code: checksum=b68ced685fd46f0cc233b29e343223b4eaac86d7]*/ +{ 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.Codecs.encode + obj: object + [ + encoding: str + [ + errors: str + ] + ] + / + +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_Codecs_encode__doc__, +"encode(obj, [encoding, [errors]])\n" +"Encodes obj using the codec registered for encoding.\n" +"\n" +"encoding defaults to the default encoding. errors may be given to set a\n" +"different error handling scheme. Default is \'strict\' meaning that encoding\n" +"errors raise 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."); + +#define _CODECS_CODECS_ENCODE_METHODDEF \ + {"encode", (PyCFunction)_codecs_Codecs_encode, METH_VARARGS, _codecs_Codecs_encode__doc__}, static PyObject * -codec_encode(PyObject *self, PyObject *args) +_codecs_Codecs_encode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors); + +static PyObject * +_codecs_Codecs_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:encode", &obj)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Os:encode", &obj, &encoding)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Oss:encode", &obj, &encoding, &errors)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.encode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_encode_impl(self, obj, group_right_1, encoding, group_right_2, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_encode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors) +/*[clinic end generated code: checksum=5e09245ea83ae503ab82e658194a8b11713f9087]*/ +{ 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.Codecs.decode + obj: object + [ + encoding: str + [ + errors: str + ] + ] + / + +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_Codecs_decode__doc__, +"decode(obj, [encoding, [errors]])\n" +"Decodes obj using the codec registered for encoding.\n" +"\n" +"encoding defaults to the default encoding. errors may be given to set a\n" +"different error handling scheme. Default is \'strict\' meaning that encoding\n" +"errors raise 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."); + +#define _CODECS_CODECS_DECODE_METHODDEF \ + {"decode", (PyCFunction)_codecs_Codecs_decode, METH_VARARGS, _codecs_Codecs_decode__doc__}, static PyObject * -codec_decode(PyObject *self, PyObject *args) +_codecs_Codecs_decode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors); + +static PyObject * +_codecs_Codecs_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:decode", &obj)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Os:decode", &obj, &encoding)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Oss:decode", &obj, &encoding, &errors)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_decode_impl(self, obj, group_right_1, encoding, group_right_2, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_decode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *encoding, int group_right_2, const char *errors) +/*[clinic end generated code: checksum=26e9991555f0b60c6eb70d7408b027d788a338d4]*/ +{ 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 +293,113 @@ } /* --- String codecs ------------------------------------------------------ */ +/*[clinic input] +_codecs.Codecs.escape_decode + data: str(length=True) + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_escape_decode__doc__, +"escape_decode(data, [errors])"); + +#define _CODECS_CODECS_ESCAPE_DECODE_METHODDEF \ + {"escape_decode", (PyCFunction)_codecs_Codecs_escape_decode, METH_VARARGS, _codecs_Codecs_escape_decode__doc__}, + static PyObject * -escape_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_escape_decode_impl(PyObject *self, const char *data, Py_ssize_clean_t data_length, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_escape_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s#:escape_decode", &data, &data_length)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "s#z:escape_decode", &data, &data_length, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.escape_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_escape_decode_impl(self, data, data_length, group_right_1, errors); + + return return_value; } static PyObject * -escape_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_escape_decode_impl(PyObject *self, const char *data, Py_ssize_clean_t data_length, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=2ac63e14d21c21cabf3f0cac826d6e02c16b4d8b]*/ { + return codec_tuple(PyBytes_DecodeEscape(data, data_length, errors, 0, NULL), + data_length); +} + +/*[clinic input] +_codecs.Codecs.escape_encode + str: object(subclass_of='&PyBytes_Type') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_escape_encode__doc__, +"escape_encode(str, [errors])"); + +#define _CODECS_CODECS_ESCAPE_ENCODE_METHODDEF \ + {"escape_encode", (PyCFunction)_codecs_Codecs_escape_encode, METH_VARARGS, _codecs_Codecs_escape_encode__doc__}, + +static PyObject * +_codecs_Codecs_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_escape_encode(PyObject *self, PyObject *args) +{ + PyObject *return_value = NULL; PyObject *str; + int group_right_1 = 0; + const char *errors = NULL; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O!:escape_encode", &PyBytes_Type, &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "O!z:escape_encode", &PyBytes_Type, &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.escape_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_escape_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=1825e81def2fe1c52abb6db205208cef0013cfc8]*/ +{ 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 +448,58 @@ } /* --- Decoder ------------------------------------------------------------ */ +/*[clinic input] +_codecs.Codecs.unicode_internal_decode + obj: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_unicode_internal_decode__doc__, +"unicode_internal_decode(obj, [errors])"); + +#define _CODECS_CODECS_UNICODE_INTERNAL_DECODE_METHODDEF \ + {"unicode_internal_decode", (PyCFunction)_codecs_Codecs_unicode_internal_decode, METH_VARARGS, _codecs_Codecs_unicode_internal_decode__doc__}, static PyObject * -unicode_internal_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_unicode_internal_decode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_unicode_internal_decode(PyObject *self, PyObject *args) { + PyObject *return_value = NULL; PyObject *obj; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_internal_decode", &obj)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_internal_decode", &obj, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.unicode_internal_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_unicode_internal_decode_impl(self, obj, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_unicode_internal_decode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=71ea63c2d7d1b64a688913e0305dc98487e01956]*/ +{ 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 +515,382 @@ } } +/*[clinic input] +_codecs.Codecs.utf_7_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_7_decode__doc__, +"utf_7_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_7_DECODE_METHODDEF \ + {"utf_7_decode", (PyCFunction)_codecs_Codecs_utf_7_decode, METH_VARARGS, _codecs_Codecs_utf_7_decode__doc__}, + static PyObject * -utf_7_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_7_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_7_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_7_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_7_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_7_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_7_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_7_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_7_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=55ae215e968f480805f4c949963e23817a34605f]*/ +{ + 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_8_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_8_decode__doc__, +"utf_8_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_8_DECODE_METHODDEF \ + {"utf_8_decode", (PyCFunction)_codecs_Codecs_utf_8_decode, METH_VARARGS, _codecs_Codecs_utf_8_decode__doc__}, + static PyObject * -utf_8_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_8_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_8_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_8_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_8_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_8_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_8_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_8_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_8_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=9e9ac13c3aa2323e0038e64e161ebfbac2b7223b]*/ +{ + 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_16_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_decode__doc__, +"utf_16_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_16_DECODE_METHODDEF \ + {"utf_16_decode", (PyCFunction)_codecs_Codecs_utf_16_decode, METH_VARARGS, _codecs_Codecs_utf_16_decode__doc__}, + static PyObject * -utf_16_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_16_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=59e4ef2baf52a76cd8628624df8523da2f6adbff]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_16_le_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_le_decode__doc__, +"utf_16_le_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_16_LE_DECODE_METHODDEF \ + {"utf_16_le_decode", (PyCFunction)_codecs_Codecs_utf_16_le_decode, METH_VARARGS, _codecs_Codecs_utf_16_le_decode__doc__}, + static PyObject * -utf_16_le_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_le_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_16_le_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_le_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_le_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_le_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_le_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_le_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_le_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=47b76a3cd19f37458b16f07e087b0d6790f20104]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_16_be_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_be_decode__doc__, +"utf_16_be_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_16_BE_DECODE_METHODDEF \ + {"utf_16_be_decode", (PyCFunction)_codecs_Codecs_utf_16_be_decode, METH_VARARGS, _codecs_Codecs_utf_16_be_decode__doc__}, + static PyObject * -utf_16_be_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_be_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_16_be_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_be_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_be_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_be_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_be_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_be_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_be_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=90df345e0bc071a26d94e1b79ba51c90efa7e3e8]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -377,25 +903,89 @@ being the value in effect at the end of data. */ +/*[clinic input] +_codecs.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_Codecs_utf_16_ex_decode__doc__, +"utf_16_ex_decode(pbuf, [errors, [byteorder=0, [final=0]]])"); + +#define _CODECS_CODECS_UTF_16_EX_DECODE_METHODDEF \ + {"utf_16_ex_decode", (PyCFunction)_codecs_Codecs_utf_16_ex_decode, METH_VARARGS, _codecs_Codecs_utf_16_ex_decode__doc__}, static PyObject * -utf_16_ex_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_ex_decode_impl(PyObject *self, 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_Codecs_utf_16_ex_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_16_ex_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_16_ex_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_16_ex_decode", &pbuf, &errors, &byteorder)) + return NULL; + 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)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + group_right_3 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_ex_decode requires 1 to 4 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_ex_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, byteorder, group_right_3, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_ex_decode_impl(PyObject *self, 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=64c552405bb54fce83b025875ea578a24efc1d74]*/ +{ 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); + PyBuffer_Release(pbuf); if (unicode == NULL) return NULL; tuple = Py_BuildValue("Oni", unicode, consumed, byteorder); @@ -403,70 +993,232 @@ return tuple; } +/*[clinic input] +_codecs.Codecs.utf_32_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_decode__doc__, +"utf_32_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_32_DECODE_METHODDEF \ + {"utf_32_decode", (PyCFunction)_codecs_Codecs_utf_32_decode, METH_VARARGS, _codecs_Codecs_utf_32_decode__doc__}, + static PyObject * -utf_32_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_32_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=bc5da0d82ec133876b0218ba496cfb1b583fdf11]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_32_le_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_le_decode__doc__, +"utf_32_le_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_32_LE_DECODE_METHODDEF \ + {"utf_32_le_decode", (PyCFunction)_codecs_Codecs_utf_32_le_decode, METH_VARARGS, _codecs_Codecs_utf_32_le_decode__doc__}, + static PyObject * -utf_32_le_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_le_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_32_le_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_le_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_le_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_le_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_le_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_le_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_le_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=70ef9bfe9a4ddd0f05176c390e5cf73bf0c5ce50]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.utf_32_be_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_be_decode__doc__, +"utf_32_be_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_UTF_32_BE_DECODE_METHODDEF \ + {"utf_32_be_decode", (PyCFunction)_codecs_Codecs_utf_32_be_decode, METH_VARARGS, _codecs_Codecs_utf_32_be_decode__doc__}, + static PyObject * -utf_32_be_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_be_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_utf_32_be_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_be_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_be_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_be_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_be_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_be_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_be_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=82192b2f2263cdc196ed6be884fc3148d811a9c6]*/ +{ 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); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -479,25 +1231,88 @@ being the value in effect at the end of data. */ +/*[clinic input] +_codecs.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_Codecs_utf_32_ex_decode__doc__, +"utf_32_ex_decode(pbuf, [errors, [byteorder=0, [final=0]]])"); + +#define _CODECS_CODECS_UTF_32_EX_DECODE_METHODDEF \ + {"utf_32_ex_decode", (PyCFunction)_codecs_Codecs_utf_32_ex_decode, METH_VARARGS, _codecs_Codecs_utf_32_ex_decode__doc__}, static PyObject * -utf_32_ex_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_ex_decode_impl(PyObject *self, 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_Codecs_utf_32_ex_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:utf_32_ex_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:utf_32_ex_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:utf_32_ex_decode", &pbuf, &errors, &byteorder)) + return NULL; + 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)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + group_right_3 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_ex_decode requires 1 to 4 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_ex_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, byteorder, group_right_3, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_ex_decode_impl(PyObject *self, 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=693fca9c1b64c1cf6111feb86c0c0eb31b934857]*/ +{ 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); + PyBuffer_Release(pbuf); if (unicode == NULL) return NULL; tuple = Py_BuildValue("Oni", unicode, consumed, byteorder); @@ -505,139 +1320,472 @@ return tuple; } +/*[clinic input] +_codecs.Codecs.unicode_escape_decode + pbuf: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_unicode_escape_decode__doc__, +"unicode_escape_decode(pbuf, [errors])"); + +#define _CODECS_CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \ + {"unicode_escape_decode", (PyCFunction)_codecs_Codecs_unicode_escape_decode, METH_VARARGS, _codecs_Codecs_unicode_escape_decode__doc__}, + static PyObject * -unicode_escape_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_unicode_escape_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_unicode_escape_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:unicode_escape_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:unicode_escape_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.unicode_escape_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_unicode_escape_decode_impl(self, &pbuf, group_right_1, errors); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -raw_unicode_escape_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_unicode_escape_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=b77ca0eed0c140f6e422c8b10f1a8ecf20cd9746]*/ { - Py_buffer pbuf; + PyObject *unicode; + + unicode = PyUnicode_DecodeUnicodeEscape(pbuf->buf, pbuf->len, errors); + PyBuffer_Release(pbuf); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.Codecs.raw_unicode_escape_decode + pbuf: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_raw_unicode_escape_decode__doc__, +"raw_unicode_escape_decode(pbuf, [errors])"); + +#define _CODECS_CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \ + {"raw_unicode_escape_decode", (PyCFunction)_codecs_Codecs_raw_unicode_escape_decode, METH_VARARGS, _codecs_Codecs_raw_unicode_escape_decode__doc__}, + +static PyObject * +_codecs_Codecs_raw_unicode_escape_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_raw_unicode_escape_decode(PyObject *self, PyObject *args) +{ + PyObject *return_value = NULL; + Py_buffer pbuf = {NULL, NULL}; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:raw_unicode_escape_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:raw_unicode_escape_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.raw_unicode_escape_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_raw_unicode_escape_decode_impl(self, &pbuf, group_right_1, errors); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_raw_unicode_escape_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=4d9f594d2a64f0f5a90d5fb6dd4837f07d1e4060]*/ +{ 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); + PyBuffer_Release(pbuf); + return codec_tuple(unicode, pbuf->len); } +/*[clinic input] +_codecs.Codecs.latin_1_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_latin_1_decode__doc__, +"latin_1_decode(pbuf, [errors])"); + +#define _CODECS_CODECS_LATIN_1_DECODE_METHODDEF \ + {"latin_1_decode", (PyCFunction)_codecs_Codecs_latin_1_decode, METH_VARARGS, _codecs_Codecs_latin_1_decode__doc__}, + static PyObject * -latin_1_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_latin_1_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_latin_1_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:latin_1_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:latin_1_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.latin_1_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_latin_1_decode_impl(self, &pbuf, group_right_1, errors); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_latin_1_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=468bf8d720098557e9e04922296809a672f3c21c]*/ +{ PyObject *unicode; + + unicode = PyUnicode_DecodeLatin1(pbuf->buf, pbuf->len, errors); + PyBuffer_Release(pbuf); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.Codecs.ascii_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_ascii_decode__doc__, +"ascii_decode(pbuf, [errors])"); + +#define _CODECS_CODECS_ASCII_DECODE_METHODDEF \ + {"ascii_decode", (PyCFunction)_codecs_Codecs_ascii_decode, METH_VARARGS, _codecs_Codecs_ascii_decode__doc__}, + +static PyObject * +_codecs_Codecs_ascii_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_ascii_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:ascii_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:ascii_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.ascii_decode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_ascii_decode_impl(self, &pbuf, group_right_1, errors); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -ascii_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_ascii_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=71aea27a479823c89b959bd37c6f68e624baf4eb]*/ { - Py_buffer pbuf; PyObject *unicode; + + unicode = PyUnicode_DecodeASCII(pbuf->buf, pbuf->len, errors); + PyBuffer_Release(pbuf); + return codec_tuple(unicode, pbuf->len); +} + +/*[clinic input] +_codecs.Codecs.charmap_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + mapping: object = None + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_charmap_decode__doc__, +"charmap_decode(pbuf, [errors, [mapping=None]])"); + +#define _CODECS_CODECS_CHARMAP_DECODE_METHODDEF \ + {"charmap_decode", (PyCFunction)_codecs_Codecs_charmap_decode, METH_VARARGS, _codecs_Codecs_charmap_decode__doc__}, + +static PyObject * +_codecs_Codecs_charmap_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, PyObject *mapping); + +static PyObject * +_codecs_Codecs_charmap_decode(PyObject *self, 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 = Py_None; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:charmap_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:charmap_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zO:charmap_decode", &pbuf, &errors, &mapping)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.charmap_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_charmap_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, mapping); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; } static PyObject * -charmap_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_charmap_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, PyObject *mapping) +/*[clinic end generated code: checksum=34aa3f6eaa0943384294a8c1948c9a7bba26663c]*/ { - 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); + PyBuffer_Release(pbuf); + return codec_tuple(unicode, pbuf->len); } #ifdef HAVE_MBCS +/*[clinic input] +_codecs.Codecs.mbcs_decode + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_mbcs_decode__doc__, +"mbcs_decode(pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_MBCS_DECODE_METHODDEF \ + {"mbcs_decode", (PyCFunction)_codecs_Codecs_mbcs_decode, METH_VARARGS, _codecs_Codecs_mbcs_decode__doc__}, + static PyObject * -mbcs_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_mbcs_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_mbcs_decode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "y*:mbcs_decode", &pbuf)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "y*z:mbcs_decode", &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "y*zi:mbcs_decode", &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.mbcs_decode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_mbcs_decode_impl(self, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_mbcs_decode_impl(PyObject *self, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=dc2f5295b119004d628f5ebc50dd6241096b0624]*/ +{ + Py_ssize_t consumed = pbuf->len; 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, + decoded = PyUnicode_DecodeMBCSStateful(pbuf->buf, pbuf->len, errors, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); } +/*[clinic input] +_codecs.Codecs.code_page_decode + codepage: int + pbuf: Py_buffer + [ + errors: str(nullable=True) + [ + final: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_code_page_decode__doc__, +"code_page_decode(codepage, pbuf, [errors, [final=0]])"); + +#define _CODECS_CODECS_CODE_PAGE_DECODE_METHODDEF \ + {"code_page_decode", (PyCFunction)_codecs_Codecs_code_page_decode, METH_VARARGS, _codecs_Codecs_code_page_decode__doc__}, + static PyObject * -code_page_decode(PyObject *self, - PyObject *args) +_codecs_Codecs_code_page_decode_impl(PyObject *self, int codepage, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final); + +static PyObject * +_codecs_Codecs_code_page_decode(PyObject *self, 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; + + switch (PyTuple_Size(args)) { + case 2: + if (!PyArg_ParseTuple(args, "iy*:code_page_decode", &codepage, &pbuf)) + return NULL; + break; + case 3: + if (!PyArg_ParseTuple(args, "iy*z:code_page_decode", &codepage, &pbuf, &errors)) + return NULL; + group_right_1 = 1; + break; + case 4: + if (!PyArg_ParseTuple(args, "iy*zi:code_page_decode", &codepage, &pbuf, &errors, &final)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.code_page_decode requires 2 to 4 arguments"); + return NULL; + } + return_value = _codecs_Codecs_code_page_decode_impl(self, codepage, &pbuf, group_right_1, errors, group_right_2, final); + + /* Cleanup for pbuf */ + if (pbuf.obj) + PyBuffer_Release(&pbuf); + + return return_value; +} + +static PyObject * +_codecs_Codecs_code_page_decode_impl(PyObject *self, int codepage, Py_buffer *pbuf, int group_right_1, const char *errors, int group_right_2, int final) +/*[clinic end generated code: checksum=3ffd032d9d767326789b7e35ac4dfa96585f9b37]*/ +{ + Py_ssize_t consumed = pbuf->len; 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, + pbuf->buf, pbuf->len, errors, final ? NULL : &consumed); - PyBuffer_Release(&pbuf); + PyBuffer_Release(pbuf); if (decoded == NULL) return NULL; return codec_tuple(decoded, consumed); @@ -647,33 +1795,116 @@ /* --- Encoder ------------------------------------------------------------ */ +/*[clinic input] +_codecs.Codecs.readbuffer_encode + pdata: Py_buffer(types='str bytes bytearray buffer') + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_readbuffer_encode__doc__, +"readbuffer_encode(pdata, [errors])"); + +#define _CODECS_CODECS_READBUFFER_ENCODE_METHODDEF \ + {"readbuffer_encode", (PyCFunction)_codecs_Codecs_readbuffer_encode, METH_VARARGS, _codecs_Codecs_readbuffer_encode__doc__}, + static PyObject * -readbuffer_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_readbuffer_encode_impl(PyObject *self, Py_buffer *pdata, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_readbuffer_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "s*:readbuffer_encode", &pdata)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "s*z:readbuffer_encode", &pdata, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.readbuffer_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_readbuffer_encode_impl(self, &pdata, group_right_1, errors); + + /* Cleanup for pdata */ + if (pdata.obj) + PyBuffer_Release(&pdata); + + return return_value; +} + +static PyObject * +_codecs_Codecs_readbuffer_encode_impl(PyObject *self, Py_buffer *pdata, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=7b0e61e4071750fd661cdb8de8f4d57ebc2c0dee]*/ +{ + const char *data = pdata->buf; + Py_ssize_t size = pdata->len; + PyObject *result = PyBytes_FromStringAndSize(data, size); + + PyBuffer_Release(pdata); return codec_tuple(result, size); } +/*[clinic input] +_codecs.Codecs.unicode_internal_encode + obj: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_unicode_internal_encode__doc__, +"unicode_internal_encode(obj, [errors])"); + +#define _CODECS_CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF \ + {"unicode_internal_encode", (PyCFunction)_codecs_Codecs_unicode_internal_encode, METH_VARARGS, _codecs_Codecs_unicode_internal_encode__doc__}, + static PyObject * -unicode_internal_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_unicode_internal_encode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_unicode_internal_encode(PyObject *self, PyObject *args) { + PyObject *return_value = NULL; PyObject *obj; + int group_right_1 = 0; const char *errors = NULL; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_internal_encode", &obj)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_internal_encode", &obj, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.unicode_internal_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_unicode_internal_encode_impl(self, obj, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_unicode_internal_encode_impl(PyObject *self, PyObject *obj, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=19efdb7139fcc2ed2cc2e57d914cac27aeab43e0]*/ +{ const char *data; Py_ssize_t len, size; @@ -682,10 +1913,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 +1935,56 @@ } } +/*[clinic input] +_codecs.Codecs.utf_7_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_7_encode__doc__, +"utf_7_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_7_ENCODE_METHODDEF \ + {"utf_7_encode", (PyCFunction)_codecs_Codecs_utf_7_encode, METH_VARARGS, _codecs_Codecs_utf_7_encode__doc__}, + static PyObject * -utf_7_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_7_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_7_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_7_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_7_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_7_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_7_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_7_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=e8806f9456a8449b514fbd097067cff45008d28a]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -730,16 +1997,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.utf_8_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_8_encode__doc__, +"utf_8_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_8_ENCODE_METHODDEF \ + {"utf_8_encode", (PyCFunction)_codecs_Codecs_utf_8_encode, METH_VARARGS, _codecs_Codecs_utf_8_encode__doc__}, + static PyObject * -utf_8_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_8_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_8_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_8_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_8_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_8_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_8_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_8_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=0166a55bda0daf434ec7c29afcf8057820e3e930]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -759,17 +2066,67 @@ */ +/*[clinic input] +_codecs.Codecs.utf_16_encode + str: object + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_encode__doc__, +"utf_16_encode(str, [errors, [byteorder=0]])"); + +#define _CODECS_CODECS_UTF_16_ENCODE_METHODDEF \ + {"utf_16_encode", (PyCFunction)_codecs_Codecs_utf_16_encode, METH_VARARGS, _codecs_Codecs_utf_16_encode__doc__}, + static PyObject * -utf_16_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder); + +static PyObject * +_codecs_Codecs_utf_16_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Ozi:utf_16_encode", &str, &errors, &byteorder)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_encode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_encode_impl(self, str, group_right_1, errors, group_right_2, byteorder); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder) +/*[clinic end generated code: checksum=6dfd84bbe81e21021754ec75a9e45eaf1fcf54bf]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -782,16 +2139,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.utf_16_le_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_le_encode__doc__, +"utf_16_le_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_16_LE_ENCODE_METHODDEF \ + {"utf_16_le_encode", (PyCFunction)_codecs_Codecs_utf_16_le_encode, METH_VARARGS, _codecs_Codecs_utf_16_le_encode__doc__}, + static PyObject * -utf_16_le_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_le_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_16_le_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_le_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_le_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_le_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_le_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_le_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=d1df6209b7e67b93eb87076368ace9155a58c28e]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -804,16 +2201,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.utf_16_be_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_16_be_encode__doc__, +"utf_16_be_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_16_BE_ENCODE_METHODDEF \ + {"utf_16_be_encode", (PyCFunction)_codecs_Codecs_utf_16_be_encode, METH_VARARGS, _codecs_Codecs_utf_16_be_encode__doc__}, + static PyObject * -utf_16_be_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_16_be_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_16_be_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_16_be_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_16_be_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_16_be_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_16_be_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_16_be_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=b999bb3a4967df4509ba0b1b0685d3b4fabeb26d]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -833,17 +2270,67 @@ */ +/*[clinic input] +_codecs.Codecs.utf_32_encode + str: object + [ + errors: str(nullable=True) + [ + byteorder: int = 0 + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_encode__doc__, +"utf_32_encode(str, [errors, [byteorder=0]])"); + +#define _CODECS_CODECS_UTF_32_ENCODE_METHODDEF \ + {"utf_32_encode", (PyCFunction)_codecs_Codecs_utf_32_encode, METH_VARARGS, _codecs_Codecs_utf_32_encode__doc__}, + static PyObject * -utf_32_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder); + +static PyObject * +_codecs_Codecs_utf_32_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "Ozi:utf_32_encode", &str, &errors, &byteorder)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_encode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_encode_impl(self, str, group_right_1, errors, group_right_2, byteorder); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, int byteorder) +/*[clinic end generated code: checksum=95bce5eae0e1726ea41a3b0037c8c9d3f67aa098]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -856,16 +2343,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.utf_32_le_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_le_encode__doc__, +"utf_32_le_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_32_LE_ENCODE_METHODDEF \ + {"utf_32_le_encode", (PyCFunction)_codecs_Codecs_utf_32_le_encode, METH_VARARGS, _codecs_Codecs_utf_32_le_encode__doc__}, + static PyObject * -utf_32_le_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_le_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_32_le_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_le_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_le_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_le_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_le_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_le_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=211158cd66e13ddb41cf41c21232712b24a6d2c0]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -878,16 +2405,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.utf_32_be_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_utf_32_be_encode__doc__, +"utf_32_be_encode(str, [errors])"); + +#define _CODECS_CODECS_UTF_32_BE_ENCODE_METHODDEF \ + {"utf_32_be_encode", (PyCFunction)_codecs_Codecs_utf_32_be_encode, METH_VARARGS, _codecs_Codecs_utf_32_be_encode__doc__}, + static PyObject * -utf_32_be_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_utf_32_be_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_utf_32_be_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:utf_32_be_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:utf_32_be_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.utf_32_be_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_utf_32_be_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_utf_32_be_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=f4f360e27584752de8f391612c0d3856ac5f631d]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -900,16 +2467,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.unicode_escape_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_unicode_escape_encode__doc__, +"unicode_escape_encode(str, [errors])"); + +#define _CODECS_CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \ + {"unicode_escape_encode", (PyCFunction)_codecs_Codecs_unicode_escape_encode, METH_VARARGS, _codecs_Codecs_unicode_escape_encode__doc__}, + static PyObject * -unicode_escape_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_unicode_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_unicode_escape_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:unicode_escape_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:unicode_escape_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.unicode_escape_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_unicode_escape_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_unicode_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=606f44f27f41c96420c5918de31951c425308c39]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -922,16 +2529,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.raw_unicode_escape_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_raw_unicode_escape_encode__doc__, +"raw_unicode_escape_encode(str, [errors])"); + +#define _CODECS_CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \ + {"raw_unicode_escape_encode", (PyCFunction)_codecs_Codecs_raw_unicode_escape_encode, METH_VARARGS, _codecs_Codecs_raw_unicode_escape_encode__doc__}, + static PyObject * -raw_unicode_escape_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_raw_unicode_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_raw_unicode_escape_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:raw_unicode_escape_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:raw_unicode_escape_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.raw_unicode_escape_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_raw_unicode_escape_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_raw_unicode_escape_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=71322526bde049be177d1cb0c224af1d542cea22]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -944,16 +2591,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.latin_1_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_latin_1_encode__doc__, +"latin_1_encode(str, [errors])"); + +#define _CODECS_CODECS_LATIN_1_ENCODE_METHODDEF \ + {"latin_1_encode", (PyCFunction)_codecs_Codecs_latin_1_encode, METH_VARARGS, _codecs_Codecs_latin_1_encode__doc__}, + static PyObject * -latin_1_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_latin_1_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_latin_1_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:latin_1_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:latin_1_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.latin_1_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_latin_1_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_latin_1_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=7b73f06986d320799647494fb73c9f606f95ff53]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -966,16 +2653,56 @@ return v; } +/*[clinic input] +_codecs.Codecs.ascii_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_ascii_encode__doc__, +"ascii_encode(str, [errors])"); + +#define _CODECS_CODECS_ASCII_ENCODE_METHODDEF \ + {"ascii_encode", (PyCFunction)_codecs_Codecs_ascii_encode, METH_VARARGS, _codecs_Codecs_ascii_encode__doc__}, + static PyObject * -ascii_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_ascii_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_ascii_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:ascii_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:ascii_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.ascii_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_ascii_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_ascii_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=7dce795060ed9de4a012740ff404d23ad3417cbf]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -988,17 +2715,68 @@ return v; } +/*[clinic input] +_codecs.Codecs.charmap_encode + str: object + [ + errors: str(nullable=True) + [ + mapping: object = None + ] + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_charmap_encode__doc__, +"charmap_encode(str, [errors, [mapping=None]])"); + +#define _CODECS_CODECS_CHARMAP_ENCODE_METHODDEF \ + {"charmap_encode", (PyCFunction)_codecs_Codecs_charmap_encode, METH_VARARGS, _codecs_Codecs_charmap_encode__doc__}, + static PyObject * -charmap_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_charmap_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, PyObject *mapping); + +static PyObject * +_codecs_Codecs_charmap_encode(PyObject *self, PyObject *args) { - PyObject *str, *v; + PyObject *return_value = NULL; + PyObject *str; + int group_right_1 = 0; const char *errors = NULL; - PyObject *mapping = NULL; - - if (!PyArg_ParseTuple(args, "O|zO:charmap_encode", - &str, &errors, &mapping)) - return NULL; + int group_right_2 = 0; + PyObject *mapping = Py_None; + + switch (PyTuple_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:charmap_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:charmap_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + case 3: + if (!PyArg_ParseTuple(args, "OzO:charmap_encode", &str, &errors, &mapping)) + return NULL; + group_right_1 = 1; + group_right_2 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.charmap_encode requires 1 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_charmap_encode_impl(self, str, group_right_1, errors, group_right_2, mapping); + + return return_value; +} + +static PyObject * +_codecs_Codecs_charmap_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors, int group_right_2, PyObject *mapping) +/*[clinic end generated code: checksum=cb386acf850159e17e2b30528fa0a4d2e6d1c809]*/ +{ + PyObject *v; + if (mapping == Py_None) mapping = NULL; @@ -1013,27 +2791,96 @@ return v; } -static PyObject* -charmap_build(PyObject *self, PyObject *args) +/*[clinic input] +_codecs.Codecs.charmap_build + map: unicode + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_charmap_build__doc__, +"charmap_build(map)"); + +#define _CODECS_CODECS_CHARMAP_BUILD_METHODDEF \ + {"charmap_build", (PyCFunction)_codecs_Codecs_charmap_build, METH_VARARGS, _codecs_Codecs_charmap_build__doc__}, + +static PyObject * +_codecs_Codecs_charmap_build_impl(PyObject *self, PyObject *map); + +static PyObject * +_codecs_Codecs_charmap_build(PyObject *self, 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_Codecs_charmap_build_impl(self, map); + +exit: + return return_value; +} + +static PyObject * +_codecs_Codecs_charmap_build_impl(PyObject *self, PyObject *map) +/*[clinic end generated code: checksum=a80038590a254024bf45acd290b3b5ea4695c8f7]*/ +{ return PyUnicode_BuildEncodingMap(map); } #ifdef HAVE_MBCS +/*[clinic input] +_codecs.Codecs.mbcs_encode + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_mbcs_encode__doc__, +"mbcs_encode(str, [errors])"); + +#define _CODECS_CODECS_MBCS_ENCODE_METHODDEF \ + {"mbcs_encode", (PyCFunction)_codecs_Codecs_mbcs_encode, METH_VARARGS, _codecs_Codecs_mbcs_encode__doc__}, + static PyObject * -mbcs_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_mbcs_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_mbcs_encode(PyObject *self, 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_Size(args)) { + case 1: + if (!PyArg_ParseTuple(args, "O:mbcs_encode", &str)) + return NULL; + break; + case 2: + if (!PyArg_ParseTuple(args, "Oz:mbcs_encode", &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.mbcs_encode requires 1 to 2 arguments"); + return NULL; + } + return_value = _codecs_Codecs_mbcs_encode_impl(self, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_mbcs_encode_impl(PyObject *self, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=1c89fd3be1247aaecc1d17bd0fd3c4132f8fa45e]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -1046,17 +2893,58 @@ return v; } +/*[clinic input] +_codecs.Codecs.code_page_encode + code_page: int + str: object + [ + errors: str(nullable=True) + ] + / +[clinic start generated code]*/ + +PyDoc_STRVAR(_codecs_Codecs_code_page_encode__doc__, +"code_page_encode(code_page, str, [errors])"); + +#define _CODECS_CODECS_CODE_PAGE_ENCODE_METHODDEF \ + {"code_page_encode", (PyCFunction)_codecs_Codecs_code_page_encode, METH_VARARGS, _codecs_Codecs_code_page_encode__doc__}, + static PyObject * -code_page_encode(PyObject *self, - PyObject *args) +_codecs_Codecs_code_page_encode_impl(PyObject *self, int code_page, PyObject *str, int group_right_1, const char *errors); + +static PyObject * +_codecs_Codecs_code_page_encode(PyObject *self, 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_Size(args)) { + case 2: + if (!PyArg_ParseTuple(args, "iO:code_page_encode", &code_page, &str)) + return NULL; + break; + case 3: + if (!PyArg_ParseTuple(args, "iOz:code_page_encode", &code_page, &str, &errors)) + return NULL; + group_right_1 = 1; + break; + default: + PyErr_SetString(PyExc_TypeError, "_codecs.Codecs.code_page_encode requires 2 to 3 arguments"); + return NULL; + } + return_value = _codecs_Codecs_code_page_encode_impl(self, code_page, str, group_right_1, errors); + + return return_value; +} + +static PyObject * +_codecs_Codecs_code_page_encode_impl(PyObject *self, int code_page, PyObject *str, int group_right_1, const char *errors) +/*[clinic end generated code: checksum=dd0a2b0c37f9740a3aae914b8bf089d7af12f8da]*/ +{ + PyObject *v; str = PyUnicode_FromObject(str); if (str == NULL || PyUnicode_READY(str) < 0) { @@ -1075,41 +2963,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.Codecs.register_error + name: str + handler: object + / + +Register the specified error 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_Codecs_register_error__doc__, +"register_error(name, handler)\n" +"Register the specified error 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_CODECS_REGISTER_ERROR_METHODDEF \ + {"register_error", (PyCFunction)_codecs_Codecs_register_error, METH_VARARGS, _codecs_Codecs_register_error__doc__}, + +static PyObject * +_codecs_Codecs_register_error_impl(PyObject *self, const char *name, PyObject *handler); + +static PyObject * +_codecs_Codecs_register_error(PyObject *self, 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_Codecs_register_error_impl(self, name, handler); + +exit: + return return_value; +} + +static PyObject * +_codecs_Codecs_register_error_impl(PyObject *self, const char *name, PyObject *handler) +/*[clinic end generated code: checksum=2f69fc4cacfab945ede1263f21f3522bd6a6e776]*/ +{ 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.Codecs.lookup_error + name: str + / + +Return the error 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_Codecs_lookup_error__doc__, +"lookup_error(name)\n" +"Return the error 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_CODECS_LOOKUP_ERROR_METHODDEF \ + {"lookup_error", (PyCFunction)_codecs_Codecs_lookup_error, METH_VARARGS, _codecs_Codecs_lookup_error__doc__}, + +static PyObject * +_codecs_Codecs_lookup_error_impl(PyObject *self, const char *name); + +static PyObject * +_codecs_Codecs_lookup_error(PyObject *self, 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_Codecs_lookup_error_impl(self, name); + +exit: + return return_value; +} + +static PyObject * +_codecs_Codecs_lookup_error_impl(PyObject *self, const char *name) +/*[clinic end generated code: checksum=baf3de5707dfd143b51a672e6d6931d0850756a8]*/ +{ return PyCodec_LookupError(name); } @@ -1118,56 +3070,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_CODECS_LOOKUP_METHODDEF + _CODECS_CODECS_ENCODE_METHODDEF + _CODECS_CODECS_DECODE_METHODDEF + _CODECS_CODECS_ESCAPE_DECODE_METHODDEF + _CODECS_CODECS_ESCAPE_ENCODE_METHODDEF + _CODECS_CODECS_UTF_8_ENCODE_METHODDEF + _CODECS_CODECS_UTF_8_DECODE_METHODDEF + _CODECS_CODECS_UTF_7_ENCODE_METHODDEF + _CODECS_CODECS_UTF_7_DECODE_METHODDEF + _CODECS_CODECS_UTF_16_ENCODE_METHODDEF + _CODECS_CODECS_UTF_16_LE_ENCODE_METHODDEF + _CODECS_CODECS_UTF_16_BE_ENCODE_METHODDEF + _CODECS_CODECS_UTF_16_DECODE_METHODDEF + _CODECS_CODECS_UTF_16_LE_DECODE_METHODDEF + _CODECS_CODECS_UTF_16_BE_DECODE_METHODDEF + _CODECS_CODECS_UTF_16_EX_DECODE_METHODDEF + _CODECS_CODECS_UTF_32_ENCODE_METHODDEF + _CODECS_CODECS_UTF_32_LE_ENCODE_METHODDEF + _CODECS_CODECS_UTF_32_BE_ENCODE_METHODDEF + _CODECS_CODECS_UTF_32_DECODE_METHODDEF + _CODECS_CODECS_UTF_32_LE_DECODE_METHODDEF + _CODECS_CODECS_UTF_32_BE_DECODE_METHODDEF + _CODECS_CODECS_UTF_32_EX_DECODE_METHODDEF + _CODECS_CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF + _CODECS_CODECS_UNICODE_ESCAPE_DECODE_METHODDEF + _CODECS_CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF + _CODECS_CODECS_UNICODE_INTERNAL_DECODE_METHODDEF + _CODECS_CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF + _CODECS_CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF + _CODECS_CODECS_LATIN_1_ENCODE_METHODDEF + _CODECS_CODECS_LATIN_1_DECODE_METHODDEF + _CODECS_CODECS_ASCII_ENCODE_METHODDEF + _CODECS_CODECS_ASCII_DECODE_METHODDEF + _CODECS_CODECS_CHARMAP_ENCODE_METHODDEF + _CODECS_CODECS_CHARMAP_DECODE_METHODDEF + _CODECS_CODECS_CHARMAP_BUILD_METHODDEF + _CODECS_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_CODECS_MBCS_ENCODE_METHODDEF + _CODECS_CODECS_MBCS_DECODE_METHODDEF + _CODECS_CODECS_CODE_PAGE_ENCODE_METHODDEF + _CODECS_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_CODECS_REGISTER_ERROR_METHODDEF + _CODECS_CODECS_LOOKUP_ERROR_METHODDEF {NULL, NULL} /* sentinel */ };