#include <stddef.h> // ptrdiff_t

#include "parts.h"

#include "util.h"

static struct PyModuleDef *_testcapimodule = NULL; // set at initialization

static PyObject *

codec_incrementalencoder(PyObject *self, PyObject *args)

{

const char *encoding, *errors = NULL;

if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",

&encoding, &errors))

return NULL;

return PyCodec_IncrementalEncoder(encoding, errors);

}

static PyObject *

codec_incrementaldecoder(PyObject *self, PyObject *args)

{

const char *encoding, *errors = NULL;

if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",

&encoding, &errors))

return NULL;

return PyCodec_IncrementalDecoder(encoding, errors);

}

static PyObject *

test_unicode_compare_with_ascii(PyObject *self, PyObject *Py_UNUSED(ignored)) {

PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);

int result;

if (py_s == NULL)

return NULL;

result = PyUnicode_CompareWithASCIIString(py_s, "str");

Py_DECREF(py_s);

if (!result) {

PyErr_SetString(PyExc_AssertionError, "Python string ending in NULL "

"should not compare equal to c string.");

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

test_widechar(PyObject *self, PyObject *Py_UNUSED(ignored))

{

#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)

const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};

size_t wtextlen = 1;

const wchar_t invalid[1] = {(wchar_t)0x110000u};

const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};

size_t wtextlen = 2;

PyObject *wide, *utf8;

wide = PyUnicode_FromWideChar(wtext, wtextlen);

if (wide == NULL)

return NULL;

utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");

if (utf8 == NULL) {

Py_DECREF(wide);

return NULL;

}

if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {

Py_DECREF(wide);

Py_DECREF(utf8);

PyErr_SetString(PyExc_AssertionError,

"test_widechar: "

"wide string and utf8 string "

"have different length");

return NULL;

}

if (PyUnicode_Compare(wide, utf8)) {

Py_DECREF(wide);

Py_DECREF(utf8);

if (PyErr_Occurred())

return NULL;

PyErr_SetString(PyExc_AssertionError,

"test_widechar: "

"wide string and utf8 string "

"are different");

return NULL;

}

Py_DECREF(wide);

Py_DECREF(utf8);

#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)

wide = PyUnicode_FromWideChar(invalid, 1);

if (wide == NULL)

PyErr_Clear();

else {

PyErr_SetString(PyExc_AssertionError,

"test_widechar: "

"PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

unicode_copy(PyObject *unicode)

{

PyObject *copy;

if (!unicode) {

return NULL;

}

if (!PyUnicode_Check(unicode)) {

Py_INCREF(unicode);

return unicode;

}

copy = PyUnicode_New(PyUnicode_GET_LENGTH(unicode),

PyUnicode_MAX_CHAR_VALUE(unicode));

if (!copy) {

return NULL;

}

if (PyUnicode_CopyCharacters(copy, 0, unicode,

0, PyUnicode_GET_LENGTH(unicode)) < 0)

{

Py_DECREF(copy);

return NULL;

}

return copy;

}

static PyObject *

unicode_new(PyObject *self, PyObject *args)

{

Py_ssize_t size;

unsigned int maxchar;

PyObject *result;

if (!PyArg_ParseTuple(args, "nI", &size, &maxchar)) {

return NULL;

}

result = PyUnicode_New(size, (Py_UCS4)maxchar);

if (!result) {

return NULL;

}

if (size > 0 && maxchar <= 0x10ffff &&

PyUnicode_Fill(result, 0, size, (Py_UCS4)maxchar) < 0)

{

Py_DECREF(result);

return NULL;

}

return result;

}

static PyObject *

unicode_fill(PyObject *self, PyObject *args)

{

PyObject *to, *to_copy;

Py_ssize_t start, length, filled;

unsigned int fill_char;

if (!PyArg_ParseTuple(args, "OnnI", &to, &start, &length, &fill_char)) {

return NULL;

}

NULLABLE(to);

if (!(to_copy = unicode_copy(to)) && to) {

return NULL;

}

filled = PyUnicode_Fill(to_copy, start, length, (Py_UCS4)fill_char);

if (filled == -1 && PyErr_Occurred()) {

Py_DECREF(to_copy);

return NULL;

}

return Py_BuildValue("(Nn)", to_copy, filled);

}

static PyObject *

unicode_writechar(PyObject *self, PyObject *args)

{

PyObject *to, *to_copy;

Py_ssize_t index;

unsigned int character;

int result;

if (!PyArg_ParseTuple(args, "OnI", &to, &index, &character)) {

return NULL;

}

NULLABLE(to);

if (!(to_copy = unicode_copy(to)) && to) {

return NULL;

}

result = PyUnicode_WriteChar(to_copy, index, (Py_UCS4)character);

if (result == -1 && PyErr_Occurred()) {

Py_DECREF(to_copy);

return NULL;

}

return Py_BuildValue("(Ni)", to_copy, result);

}

static PyObject *

unicode_resize(PyObject *self, PyObject *args)

{

PyObject *obj, *copy;

Py_ssize_t length;

int result;

if (!PyArg_ParseTuple(args, "On", &obj, &length)) {

return NULL;

}

NULLABLE(obj);

if (!(copy = unicode_copy(obj)) && obj) {

return NULL;

}

result = PyUnicode_Resize(&copy, length);

if (result == -1 && PyErr_Occurred()) {

Py_XDECREF(copy);

return NULL;

}

if (obj && PyUnicode_Check(obj) && length > PyUnicode_GET_LENGTH(obj)) {

if (PyUnicode_Fill(copy, PyUnicode_GET_LENGTH(obj), length, 0U) < 0) {

Py_DECREF(copy);

return NULL;

}

}

return Py_BuildValue("(Ni)", copy, result);

}

static PyObject *

unicode_append(PyObject *self, PyObject *args)

{

PyObject *left, *right, *left_copy;

if (!PyArg_ParseTuple(args, "OO", &left, &right))

return NULL;

NULLABLE(left);

NULLABLE(right);

if (!(left_copy = unicode_copy(left)) && left) {

return NULL;

}

PyUnicode_Append(&left_copy, right);

return left_copy;

}

static PyObject *

unicode_appendanddel(PyObject *self, PyObject *args)

{

PyObject *left, *right, *left_copy;

if (!PyArg_ParseTuple(args, "OO", &left, &right))

return NULL;

NULLABLE(left);

NULLABLE(right);

if (!(left_copy = unicode_copy(left)) && left) {

return NULL;

}

Py_XINCREF(right);

PyUnicode_AppendAndDel(&left_copy, right);

return left_copy;

}

static PyObject *

unicode_fromstringandsize(PyObject *self, PyObject *args)

{

const char *s;

Py_ssize_t bsize;

Py_ssize_t size = -100;

if (!PyArg_ParseTuple(args, "z#|n", &s, &bsize, &size)) {

return NULL;

}

if (size == -100) {

size = bsize;

}

return PyUnicode_FromStringAndSize(s, size);

}

static PyObject *

unicode_fromstring(PyObject *self, PyObject *arg)

{

const char *s;

Py_ssize_t size;

if (!PyArg_Parse(arg, "z#", &s, &size)) {

return NULL;

}

return PyUnicode_FromString(s);

}

static PyObject *

unicode_fromkindanddata(PyObject *self, PyObject *args)

{

int kind;

void *buffer;

Py_ssize_t bsize;

Py_ssize_t size = -100;

if (!PyArg_ParseTuple(args, "iz#|n", &kind, &buffer, &bsize, &size)) {

return NULL;

}

if (size == -100) {

size = bsize;

}

if (kind && size % kind) {

PyErr_SetString(PyExc_AssertionError,

"invalid size in unicode_fromkindanddata()");

return NULL;

}

return PyUnicode_FromKindAndData(kind, buffer, kind ? size / kind : 0);

}

static PyObject *

unicode_substring(PyObject *self, PyObject *args)

{

PyObject *str;

Py_ssize_t start, end;

if (!PyArg_ParseTuple(args, "Onn", &str, &start, &end)) {

return NULL;

}

NULLABLE(str);

return PyUnicode_Substring(str, start, end);

}

static PyObject *

unicode_getlength(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

RETURN_SIZE(PyUnicode_GetLength(arg));

}

static PyObject *

unicode_readchar(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_ssize_t index;

Py_UCS4 result;

if (!PyArg_ParseTuple(args, "On", &unicode, &index)) {

return NULL;

}

NULLABLE(unicode);

result = PyUnicode_ReadChar(unicode, index);

if (result == (Py_UCS4)-1)

return NULL;

return PyLong_FromUnsignedLong(result);

}

static PyObject *

unicode_fromencodedobject(PyObject *self, PyObject *args)

{

PyObject *obj;

const char *encoding;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "Oz|z", &obj, &encoding, &errors)) {

return NULL;

}

NULLABLE(obj);

return PyUnicode_FromEncodedObject(obj, encoding, errors);

}

static PyObject *

unicode_fromobject(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_FromObject(arg);

}

static PyObject *

unicode_interninplace(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

Py_XINCREF(arg);

PyUnicode_InternInPlace(&arg);

return arg;

}

static PyObject *

unicode_internfromstring(PyObject *self, PyObject *arg)

{

const char *s;

Py_ssize_t size;

if (!PyArg_Parse(arg, "z#", &s, &size)) {

return NULL;

}

return PyUnicode_InternFromString(s);

}

static PyObject *

unicode_fromwidechar(PyObject *self, PyObject *args)

{

const char *s;

Py_ssize_t bsize;

Py_ssize_t size = -100;

if (!PyArg_ParseTuple(args, "z#|n", &s, &bsize, &size)) {

return NULL;

}

if (size == -100) {

if (bsize % SIZEOF_WCHAR_T) {

PyErr_SetString(PyExc_AssertionError,

"invalid size in unicode_fromwidechar()");

return NULL;

}

size = bsize / SIZEOF_WCHAR_T;

}

return PyUnicode_FromWideChar((const wchar_t *)s, size);

}

static PyObject *

unicode_aswidechar(PyObject *self, PyObject *args)

{

PyObject *unicode, *result;

Py_ssize_t buflen, size;

wchar_t *buffer;

if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))

return NULL;

NULLABLE(unicode);

buffer = PyMem_New(wchar_t, buflen);

if (buffer == NULL)

return PyErr_NoMemory();

size = PyUnicode_AsWideChar(unicode, buffer, buflen);

if (size == -1) {

PyMem_Free(buffer);

return NULL;

}

if (size < buflen)

buflen = size + 1;

else

buflen = size;

result = PyUnicode_FromWideChar(buffer, buflen);

PyMem_Free(buffer);

if (result == NULL)

return NULL;

return Py_BuildValue("(Nn)", result, size);

}

static PyObject *

unicode_aswidechar_null(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_ssize_t buflen;

if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))

return NULL;

NULLABLE(unicode);

RETURN_SIZE(PyUnicode_AsWideChar(unicode, NULL, buflen));

}

static PyObject *

unicode_aswidecharstring(PyObject *self, PyObject *args)

{

PyObject *unicode, *result;

Py_ssize_t size = UNINITIALIZED_SIZE;

wchar_t *buffer;

if (!PyArg_ParseTuple(args, "O", &unicode))

return NULL;

NULLABLE(unicode);

buffer = PyUnicode_AsWideCharString(unicode, &size);

if (buffer == NULL) {

assert(size == UNINITIALIZED_SIZE);

return NULL;

}

result = PyUnicode_FromWideChar(buffer, size + 1);

PyMem_Free(buffer);

if (result == NULL)

return NULL;

return Py_BuildValue("(Nn)", result, size);

}

static PyObject *

unicode_aswidecharstring_null(PyObject *self, PyObject *args)

{

PyObject *unicode, *result;

wchar_t *buffer;

if (!PyArg_ParseTuple(args, "O", &unicode))

return NULL;

NULLABLE(unicode);

buffer = PyUnicode_AsWideCharString(unicode, NULL);

if (buffer == NULL)

return NULL;

result = PyUnicode_FromWideChar(buffer, -1);

PyMem_Free(buffer);

if (result == NULL)

return NULL;

return result;

}

static PyObject *

unicode_asucs4(PyObject *self, PyObject *args)

{

PyObject *unicode, *result;

Py_UCS4 *buffer;

int copy_null;

Py_ssize_t str_len, buf_len;

if (!PyArg_ParseTuple(args, "Onp:unicode_asucs4", &unicode, &str_len, &copy_null)) {

return NULL;

}

NULLABLE(unicode);

buf_len = str_len + 1;

buffer = PyMem_NEW(Py_UCS4, buf_len);

if (buffer == NULL) {

return PyErr_NoMemory();

}

memset(buffer, 0, sizeof(Py_UCS4)*buf_len);

buffer[str_len] = 0xffffU;

if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {

PyMem_Free(buffer);

return NULL;

}

result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);

PyMem_Free(buffer);

return result;

}

static PyObject *

unicode_asucs4copy(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_UCS4 *buffer;

PyObject *result;

if (!PyArg_ParseTuple(args, "O", &unicode)) {

return NULL;

}

NULLABLE(unicode);

buffer = PyUnicode_AsUCS4Copy(unicode);

if (buffer == NULL) {

return NULL;

}

result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND,

buffer,

PyUnicode_GET_LENGTH(unicode) + 1);

PyMem_FREE(buffer);

return result;

}

static PyObject *

unicode_fromordinal(PyObject *self, PyObject *args)

{

int ordinal;

if (!PyArg_ParseTuple(args, "i", &ordinal))

return NULL;

return PyUnicode_FromOrdinal(ordinal);

}

static PyObject *

unicode_asutf8(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_ssize_t buflen;

const char *s;

if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))

return NULL;

NULLABLE(unicode);

s = PyUnicode_AsUTF8(unicode);

if (s == NULL)

return NULL;

return PyBytes_FromStringAndSize(s, buflen);

}

static PyObject *

unicode_asutf8andsize(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_ssize_t buflen;

const char *s;

Py_ssize_t size = UNINITIALIZED_SIZE;

if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))

return NULL;

NULLABLE(unicode);

s = PyUnicode_AsUTF8AndSize(unicode, &size);

if (s == NULL) {

assert(size == -1);

return NULL;

}

return Py_BuildValue("(y#n)", s, buflen, size);

}

static PyObject *

unicode_asutf8andsize_null(PyObject *self, PyObject *args)

{

PyObject *unicode;

Py_ssize_t buflen;

const char *s;

if (!PyArg_ParseTuple(args, "On", &unicode, &buflen))

return NULL;

NULLABLE(unicode);

s = PyUnicode_AsUTF8AndSize(unicode, NULL);

if (s == NULL)

return NULL;

return PyBytes_FromStringAndSize(s, buflen);

}

static PyObject *

unicode_getdefaultencoding(PyObject *self, PyObject *Py_UNUSED(ignored))

{

const char *s = PyUnicode_GetDefaultEncoding();

if (s == NULL)

return NULL;

return PyBytes_FromString(s);

}

static PyObject *

unicode_decode(PyObject *self, PyObject *args)

{

const char *s;

Py_ssize_t size;

const char *encoding;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#z|z", &s, &size, &encoding, &errors))

return NULL;

return PyUnicode_Decode(s, size, encoding, errors);

}

static PyObject *

unicode_asencodedstring(PyObject *self, PyObject *args)

{

PyObject *unicode;

const char *encoding;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "Oz|z", &unicode, &encoding, &errors))

return NULL;

NULLABLE(unicode);

return PyUnicode_AsEncodedString(unicode, encoding, errors);

}

static PyObject *

unicode_buildencodingmap(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_BuildEncodingMap(arg);

}

static PyObject *

unicode_decodeutf7(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeUTF7(data, size, errors);

}

static PyObject *

unicode_decodeutf7stateful(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

Py_ssize_t consumed = UNINITIALIZED_SIZE;

PyObject *result;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF7Stateful(data, size, errors, &consumed);

if (!result) {

assert(consumed == UNINITIALIZED_SIZE);

return NULL;

}

return Py_BuildValue("(Nn)", result, consumed);

}

static PyObject *

unicode_decodeutf8(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeUTF8(data, size, errors);

}

static PyObject *

unicode_decodeutf8stateful(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

Py_ssize_t consumed = UNINITIALIZED_SIZE;

PyObject *result;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF8Stateful(data, size, errors, &consumed);

if (!result) {

assert(consumed == UNINITIALIZED_SIZE);

return NULL;

}

return Py_BuildValue("(Nn)", result, consumed);

}

static PyObject *

unicode_asutf8string(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsUTF8String(arg);

}

static PyObject *

unicode_decodeutf32(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

int byteorder = UNINITIALIZED_INT;

PyObject *result;

if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF32(data, size, errors, &byteorder);

if (!result) {

return NULL;

}

return Py_BuildValue("(iN)", byteorder, result);

}

static PyObject *

unicode_decodeutf32stateful(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

int byteorder = UNINITIALIZED_INT;

Py_ssize_t consumed = UNINITIALIZED_SIZE;

PyObject *result;

if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF32Stateful(data, size, errors, &byteorder, &consumed);

if (!result) {

assert(consumed == UNINITIALIZED_SIZE);

return NULL;

}

return Py_BuildValue("(iNn)", byteorder, result, consumed);

}

static PyObject *

unicode_asutf32string(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsUTF32String(arg);

}

static PyObject *

unicode_decodeutf16(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

int byteorder = UNINITIALIZED_INT;

PyObject *result;

if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF16(data, size, errors, &byteorder);

if (!result) {

return NULL;

}

return Py_BuildValue("(iN)", byteorder, result);

}

static PyObject *

unicode_decodeutf16stateful(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

int byteorder = UNINITIALIZED_INT;

Py_ssize_t consumed = UNINITIALIZED_SIZE;

PyObject *result;

if (!PyArg_ParseTuple(args, "iy#|z", &byteorder, &data, &size, &errors))

return NULL;

result = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, &consumed);

if (!result) {

assert(consumed == UNINITIALIZED_SIZE);

return NULL;

}

return Py_BuildValue("(iNn)", byteorder, result, consumed);

}

static PyObject *

unicode_asutf16string(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsUTF16String(arg);

}

static PyObject *

unicode_decodeunicodeescape(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeUnicodeEscape(data, size, errors);

}

static PyObject *

unicode_asunicodeescapestring(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsUnicodeEscapeString(arg);

}

static PyObject *

unicode_decoderawunicodeescape(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeRawUnicodeEscape(data, size, errors);

}

static PyObject *

unicode_asrawunicodeescapestring(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsRawUnicodeEscapeString(arg);

}

static PyObject *

unicode_decodelatin1(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeLatin1(data, size, errors);

}

static PyObject *

unicode_aslatin1string(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsLatin1String(arg);

}

static PyObject *

unicode_decodeascii(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))

return NULL;

return PyUnicode_DecodeASCII(data, size, errors);

}

static PyObject *

unicode_asasciistring(PyObject *self, PyObject *arg)

{

NULLABLE(arg);

return PyUnicode_AsASCIIString(arg);

}

static PyObject *

unicode_decodecharmap(PyObject *self, PyObject *args)

{

const char *data;

Py_ssize_t size;

PyObject *mapping;

const char *errors = NULL;

if (!PyArg_ParseTuple(args, "y#O|z", &data, &size, &mapping, &errors))

return NULL;

NULLABLE(mapping);

return PyUnicode_DecodeCharmap(data, size, mapping, errors);

}

static PyObject *

unicode_ascharmapstring(PyObject *self, PyObject *args)

{

PyObject *unicode;

PyObject *mapping;

if (!PyArg_ParseTuple(args, "OO", &unicode, &mapping))

return NULL;