#define PY_SSIZE_T_CLEAN

#include "Python.h"

#ifdef MS_WINDOWS

#include <windows.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_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);

}

static PyObject *

_codecs__forget_codec_impl(PyObject *module, const char *encoding)

{

if (_PyCodec_Forget(encoding) < 0) {

return NULL;

};

Py_RETURN_NONE;

}

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_unicode_internal_decode_impl(PyObject *module, PyObject *obj,

const char *errors)

{

if (PyUnicode_Check(obj)) {

if (PyUnicode_READY(obj) < 0)

return NULL;

Py_INCREF(obj);

return codec_tuple(obj, PyUnicode_GET_LENGTH(obj));

}

else {

Py_buffer view;

PyObject *result;

if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)

return NULL;

result = codec_tuple(

_PyUnicode_DecodeUnicodeInternal(view.buf, view.len, errors),

view.len);

PyBuffer_Release(&view);

return result;

}

}

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)

{

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

errors);

return codec_tuple(decoded, data->len);

}

static PyObject *

_codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,

const char *errors)

{

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

errors);

return codec_tuple(decoded, data->len);

}

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 HAVE_MBCS

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_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 /* HAVE_MBCS */

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_unicode_internal_encode_impl(PyObject *module, PyObject *obj,

const char *errors)

{

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"unicode_internal codec has been deprecated",

1))

return NULL;

if (PyUnicode_Check(obj)) {

Py_UNICODE *u;

Py_ssize_t len, size;

if (PyUnicode_READY(obj) < 0)

return NULL;

u = PyUnicode_AsUnicodeAndSize(obj, &len);

if (u == NULL)

return NULL;

if ((size_t)len > (size_t)PY_SSIZE_T_MAX / sizeof(Py_UNICODE))

return PyErr_NoMemory();

size = len * sizeof(Py_UNICODE);

return codec_tuple(PyBytes_FromStringAndSize((const char*)u, size),

PyUnicode_GET_LENGTH(obj));

}

else {

Py_buffer view;

PyObject *result;

if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)

return NULL;

result = codec_tuple(PyBytes_FromStringAndSize(view.buf, view.len),

view.len);

PyBuffer_Release(&view);

return result;

}

}

static PyObject *

_codecs_utf_7_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF7(str, 0, 0, errors),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_8_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(PyUnicode_AsEncodedString(str, "utf-8", errors),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_16_encode_impl(PyObject *module, PyObject *str,

const char *errors, int byteorder)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF16(str, errors, byteorder),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF16(str, errors, -1),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF16(str, errors, +1),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_32_encode_impl(PyObject *module, PyObject *str,

const char *errors, int byteorder)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF32(str, errors, byteorder),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF32(str, errors, -1),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_EncodeUTF32(str, errors, +1),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(PyUnicode_AsUnicodeEscapeString(str),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(PyUnicode_AsRawUnicodeEscapeString(str),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

_codecs_latin_1_encode_impl(PyObject *module, PyObject *str,

const char *errors)

{

PyObject *v;

str = PyUnicode_FromObject(str);

if (str == NULL || PyUnicode_READY(str) < 0) {