#define PY_SSIZE_T_CLEAN

#include "Python.h"

#ifdef MS_WINDOWS

#include <windows.h>

PyDoc_STRVAR(register__doc__,

(or a CodecInfo object).");

PyObject *codec_register(PyObject *self, PyObject *search_function)

{

if (PyCodec_Register(search_function))

return NULL;

Py_RETURN_NONE;

}

PyDoc_STRVAR(lookup__doc__,

a CodecInfo object.");

PyObject *codec_lookup(PyObject *self, PyObject *args)

{

char *encoding;

if (!PyArg_ParseTuple(args, "s:lookup", &encoding))

return NULL;

return _PyCodec_Lookup(encoding);

}

PyDoc_STRVAR(encode__doc__,

codecs.register_error that can handle ValueErrors.");

static PyObject *

codec_encode(PyObject *self, PyObject *args)

{

const char *encoding = NULL;

const char *errors = NULL;

PyObject *v;

if (!PyArg_ParseTuple(args, "O|ss:encode", &v, &encoding, &errors))

return NULL;

if (encoding == NULL)

encoding = PyUnicode_GetDefaultEncoding();

/* Encode via the codec registry */

return PyCodec_Encode(v, encoding, errors);

}

PyDoc_STRVAR(decode__doc__,

able to handle ValueErrors.");

static PyObject *

codec_decode(PyObject *self, PyObject *args)

{

const char *encoding = NULL;

const char *errors = NULL;

PyObject *v;

if (!PyArg_ParseTuple(args, "O|ss:decode", &v, &encoding, &errors))

return NULL;

if (encoding == NULL)

encoding = PyUnicode_GetDefaultEncoding();

/* Decode via the codec registry */

return PyCodec_Decode(v, encoding, errors);

}

PyObject *codec_tuple(PyObject *unicode,

Py_ssize_t len)

{

PyObject *v;

if (unicode == NULL)

return NULL;

v = Py_BuildValue("On", unicode, len);

Py_DECREF(unicode);

return v;

}

static PyObject *

escape_decode(PyObject *self,

PyObject *args)

{

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);

}

static PyObject *

escape_encode(PyObject *self,

PyObject *args)

{

PyObject *str;

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,

"string is too large to encode");

return NULL;

}

newsize = 4*size;

v = PyBytes_FromStringAndSize(NULL, newsize);

if (v == NULL) {

return NULL;

}

else {

register Py_ssize_t i;

register char c;

register 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(str)[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 *

unicode_internal_decode(PyObject *self,

PyObject *args)

{

PyObject *obj;

const char *errors = NULL;

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;

Py_INCREF(obj);

return codec_tuple(obj, PyUnicode_GET_LENGTH(obj));

}

else {

if (PyObject_AsReadBuffer(obj, (const void **)&data, &size))

return NULL;

return codec_tuple(_PyUnicode_DecodeUnicodeInternal(data, size, errors),

size);

}

}

static PyObject *

utf_7_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int final = 0;

Py_ssize_t consumed;

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,

final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_8_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int final = 0;

Py_ssize_t consumed;

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,

final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_16_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_16_le_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = -1;

int final = 0;

Py_ssize_t consumed;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_16_be_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = 1;

int final = 0;

Py_ssize_t consumed;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_16_ex_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = 0;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (unicode == NULL)

return NULL;

tuple = Py_BuildValue("Oni", unicode, consumed, byteorder);

Py_DECREF(unicode);

return tuple;

}

static PyObject *

utf_32_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = 0;

int final = 0;

Py_ssize_t consumed;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_32_le_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = -1;

int final = 0;

Py_ssize_t consumed;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_32_be_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = 1;

int final = 0;

Py_ssize_t consumed;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

utf_32_ex_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int byteorder = 0;

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,

&byteorder, final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (unicode == NULL)

return NULL;

tuple = Py_BuildValue("Oni", unicode, consumed, byteorder);

Py_DECREF(unicode);

return tuple;

}

static PyObject *

unicode_escape_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

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);

}

static PyObject *

raw_unicode_escape_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

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);

}

static PyObject *

latin_1_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

PyObject *unicode;

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);

}

static PyObject *

ascii_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

PyObject *unicode;

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);

}

static PyObject *

charmap_decode(PyObject *self,

PyObject *args)

{

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);

}

#ifdef HAVE_MBCS

static PyObject *

mbcs_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int final = 0;

Py_ssize_t consumed;

PyObject *decoded = NULL;

if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode",

&pbuf, &errors, &final))

return NULL;

consumed = pbuf.len;

decoded = PyUnicode_DecodeMBCSStateful(pbuf.buf, pbuf.len, errors,

final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

static PyObject *

code_page_decode(PyObject *self,

PyObject *args)

{

Py_buffer pbuf;

const char *errors = NULL;

int final = 0;

Py_ssize_t consumed;

PyObject *decoded = NULL;

int code_page;

if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode",

&code_page, &pbuf, &errors, &final))

return NULL;

consumed = pbuf.len;

decoded = PyUnicode_DecodeCodePageStateful(code_page,

pbuf.buf, pbuf.len, errors,

final ? NULL : &consumed);

PyBuffer_Release(&pbuf);

if (decoded == NULL)

return NULL;

return codec_tuple(decoded, consumed);

}

#endif /* HAVE_MBCS */

static PyObject *

readbuffer_encode(PyObject *self,

PyObject *args)

{

Py_buffer pdata;

const char *data;

Py_ssize_t size;

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);

return codec_tuple(result, size);

}

static PyObject *

unicode_internal_encode(PyObject *self,

PyObject *args)

{

PyObject *obj;

const char *errors = NULL;

const char *data;

Py_ssize_t len, size;

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"unicode_internal codec has been deprecated",

1))

return NULL;

if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode",

&obj, &errors))

return NULL;

if (PyUnicode_Check(obj)) {

Py_UNICODE *u;

if (PyUnicode_READY(obj) < 0)

return NULL;

u = PyUnicode_AsUnicodeAndSize(obj, &len);

if (u == NULL)

return NULL;

if (len > 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 {

if (PyObject_AsReadBuffer(obj, (const void **)&data, &size))

return NULL;

return codec_tuple(PyBytes_FromStringAndSize(data, size), size);

}

}

static PyObject *

utf_7_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_7_encode",

&str, &errors))

return NULL;

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 *

utf_8_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_8_encode",

&str, &errors))

return NULL;

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 *

utf_16_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

int byteorder = 0;

if (!PyArg_ParseTuple(args, "O|zi:utf_16_encode",

&str, &errors, &byteorder))

return NULL;

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 *

utf_16_le_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_16_le_encode",

&str, &errors))

return NULL;

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 *

utf_16_be_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_16_be_encode",

&str, &errors))

return NULL;

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 *

utf_32_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

int byteorder = 0;

if (!PyArg_ParseTuple(args, "O|zi:utf_32_encode",

&str, &errors, &byteorder))

return NULL;

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 *

utf_32_le_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_32_le_encode",

&str, &errors))

return NULL;

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 *

utf_32_be_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:utf_32_be_encode",

&str, &errors))

return NULL;

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 *

unicode_escape_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:unicode_escape_encode",

&str, &errors))

return NULL;

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 *

raw_unicode_escape_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:raw_unicode_escape_encode",

&str, &errors))

return NULL;

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 *

latin_1_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:latin_1_encode",

&str, &errors))

return NULL;

str = PyUnicode_FromObject(str);

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

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_AsLatin1String(str, errors),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

ascii_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "O|z:ascii_encode",

&str, &errors))

return NULL;

str = PyUnicode_FromObject(str);

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

Py_XDECREF(str);

return NULL;

}

v = codec_tuple(_PyUnicode_AsASCIIString(str, errors),

PyUnicode_GET_LENGTH(str));

Py_DECREF(str);

return v;

}

static PyObject *

charmap_encode(PyObject *self,

PyObject *args)

{

PyObject *str, *v;

const char *errors = NULL;

PyObject *mapping = NULL;

if (!PyArg_ParseTuple(args, "O|zO:charmap_encode",

&str, &errors, &mapping))