#include "Python.h"

#include "pycore_codecs.h" // _PyCodec_Lookup()

#include "pycore_unicodeobject.h" // _PyUnicode_EncodeCharmap

#ifdef MS_WINDOWS

#include <windows.h>

#include "pycore_runtime.h"

#include "clinic/_codecsmodule.c.h"

static PyObject *

_codecs_register(PyObject *module, PyObject *search_function)

{

if (PyCodec_Register(search_function))

return NULL;

Py_RETURN_NONE;

}

static PyObject *

_codecs_unregister(PyObject *module, PyObject *search_function)

{

if (PyCodec_Unregister(search_function) < 0) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

_codecs_lookup_impl(PyObject *module, const char *encoding)

{

return _PyCodec_Lookup(encoding);

}

static PyObject *

_codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,

const char *errors)

{

if (encoding == NULL)

encoding = PyUnicode_GetDefaultEncoding();

/* Encode via the codec registry */

return PyCodec_Encode(obj, encoding, errors);

}

static PyObject *

_codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,

const char *errors)

{

if (encoding == NULL)

encoding = PyUnicode_GetDefaultEncoding();

/* Decode via the codec registry */

return PyCodec_Decode(obj, encoding, errors);

}

PyObject *codec_tuple(PyObject *decoded,

Py_ssize_t len)

{

if (decoded == NULL)

return NULL;

return Py_BuildValue("Nn", decoded, len);

}

static PyObject *

_codecs_escape_decode_impl(PyObject *module, Py_buffer *data,

const char *errors)

{

PyObject *decoded = PyBytes_DecodeEscape(data->buf, data->len,

errors, 0, NULL);

return codec_tuple(decoded, data->len);

}

static PyObject *

_codecs_escape_encode_impl(PyObject *module, PyObject *data,

const char *errors)

{

Py_ssize_t size;

Py_ssize_t newsize;

PyObject *v;

size = PyBytes_GET_SIZE(data);

if (size > PY_SSIZE_T_MAX / 4) {

PyErr_SetString(PyExc_OverflowError,

"string is too large to encode");

return NULL;

}

newsize = 4*size;

v = PyBytes_FromStringAndSize(NULL, newsize);

if (v == NULL) {

return NULL;

}

else {

Py_ssize_t i;

char c;

char *p = PyBytes_AS_STRING(v);

for (i = 0; i < size; i++) {

/* There's at least enough room for a hex escape */

assert(newsize - (p - PyBytes_AS_STRING(v)) >= 4);

c = PyBytes_AS_STRING(data)[i];

if (c == '\'' || c == '\\')

*p++ = '\\', *p++ = c;

else if (c == '\t')

*p++ = '\\', *p++ = 't';

else if (c == '\n')

*p++ = '\\', *p++ = 'n';

else if (c == '\r')

*p++ = '\\', *p++ = 'r';

else if (c < ' ' || c >= 0x7f) {

*p++ = '\\';

*p++ = 'x';

*p++ = Py_hexdigits[(c & 0xf0) >> 4];

*p++ = Py_hexdigits[c & 0xf];

}

else

*p++ = c;

}

*p = '\0';

if (_PyBytes_Resize(&v, (p - PyBytes_AS_STRING(v)))) {

return NULL;

}

}

return codec_tuple(v, size);

}

static PyObject *

_codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF7Stateful(data->buf, data->len,

errors,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF8Stateful(data->buf, data->len,

errors,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = 0;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = -1;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = 1;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int byteorder, int final)

{

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

if (decoded == NULL)

return NULL;

return Py_BuildValue("Nni", decoded, consumed, byteorder);

}

static PyObject *

_codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = 0;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = -1;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

int byteorder = 1;

/* This is overwritten unless final is true. */

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int byteorder, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,

errors, &byteorder,

final ? NULL : &consumed);

if (decoded == NULL)

return NULL;

return Py_BuildValue("Nni", decoded, consumed, byteorder);

}

static PyObject *

_codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = _PyUnicode_DecodeUnicodeEscapeStateful(data->buf, data->len,

errors,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = _PyUnicode_DecodeRawUnicodeEscapeStateful(data->buf, data->len,

errors,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,

const char *errors)

{

PyObject *decoded = PyUnicode_DecodeLatin1(data->buf, data->len, errors);

return codec_tuple(decoded, data->len);

}

static PyObject *

_codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,

const char *errors)

{

PyObject *decoded = PyUnicode_DecodeASCII(data->buf, data->len, errors);

return codec_tuple(decoded, data->len);

}

static PyObject *

_codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, PyObject *mapping)

{

PyObject *decoded;

if (mapping == Py_None)

mapping = NULL;

decoded = PyUnicode_DecodeCharmap(data->buf, data->len, mapping, errors);

return codec_tuple(decoded, data->len);

}

#ifdef MS_WINDOWS

static PyObject *

_codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeMBCSStateful(data->buf, data->len,

errors, final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_oem_decode_impl(PyObject *module, Py_buffer *data,

const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeCodePageStateful(CP_OEMCP,

data->buf, data->len, errors, final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

static PyObject *

_codecs_code_page_decode_impl(PyObject *module, int codepage,

Py_buffer *data, const char *errors, int final)

{

Py_ssize_t consumed = data->len;

PyObject *decoded = PyUnicode_DecodeCodePageStateful(codepage,

data->buf, data->len,

errors,

final ? NULL : &consumed);

return codec_tuple(decoded, consumed);

}

#endif /* MS_WINDOWS */

static PyObject *

_codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,

const char *errors)

{

PyObject *result = PyBytes_FromStringAndSize(data->buf, data->len);

return codec_tuple(result, data->len);

}

static PyObject *

_codecs_utf_7_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_EncodeUTF7(str, 0, 0, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_8_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_AsUTF8String(str, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_16_encode_impl(PyObject *module, PyObject *str,

const char *errors, int byteorder)

{

return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, byteorder),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, -1),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, +1),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_32_encode_impl(PyObject *module, PyObject *str,

const char *errors, int byteorder)

{

return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, byteorder),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, -1),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, +1),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(PyUnicode_AsUnicodeEscapeString(str),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(PyUnicode_AsRawUnicodeEscapeString(str),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_latin_1_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_AsLatin1String(str, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_ascii_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

return codec_tuple(_PyUnicode_AsASCIIString(str, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_charmap_encode_impl(PyObject *module, PyObject *str,

const char *errors, PyObject *mapping)

{

if (mapping == Py_None)

mapping = NULL;

return codec_tuple(_PyUnicode_EncodeCharmap(str, mapping, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_charmap_build_impl(PyObject *module, PyObject *map)

{

return PyUnicode_BuildEncodingMap(map);

}

#ifdef MS_WINDOWS

static PyObject *

_codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors)

{

return codec_tuple(PyUnicode_EncodeCodePage(CP_ACP, str, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors)

{

return codec_tuple(PyUnicode_EncodeCodePage(CP_OEMCP, str, errors),

PyUnicode_GET_LENGTH(str));

}

static PyObject *

_codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,

const char *errors)

{

return codec_tuple(PyUnicode_EncodeCodePage(code_page, str, errors),

PyUnicode_GET_LENGTH(str));

}

#endif /* MS_WINDOWS */

static PyObject *

_codecs_register_error_impl(PyObject *module, const char *errors,

PyObject *handler)

{

if (PyCodec_RegisterError(errors, handler))

return NULL;

Py_RETURN_NONE;

}