#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "multibytecodec.h"

#include "clinic/multibytecodec.c.h"

typedef struct {

PyObject *inobj;

Py_ssize_t inpos, inlen;

unsigned char *outbuf, *outbuf_end;

PyObject *excobj, *outobj;

} MultibyteEncodeBuffer;

typedef struct {

const unsigned char *inbuf, *inbuf_top, *inbuf_end;

PyObject *excobj;

_PyUnicodeWriter writer;

} MultibyteDecodeBuffer;

static char *incnewkwarglist[] = {"errors", NULL};

static char *streamkwarglist[] = {"stream", "errors", NULL};

static PyObject *multibytecodec_encode(MultibyteCodec *,

MultibyteCodec_State *, PyObject *, Py_ssize_t *,

PyObject *, int);

#define MBENC_RESET MBENC_MAX<<1 /* reset after an encoding session */

_Py_IDENTIFIER(write);

static PyObject *

make_tuple(PyObject *object, Py_ssize_t len)

{

PyObject *v, *w;

if (object == NULL)

return NULL;

v = PyTuple_New(2);

if (v == NULL) {

Py_DECREF(object);

return NULL;

}

PyTuple_SetItemRef(v, 0, object);

Py_DECREF(object);

w = PyLong_FromSsize_t(len);

if (w == NULL) {

Py_DECREF(v);

return NULL;

}

PyTuple_SetItemRef(v, 1, w);

Py_DECREF(w);

return v;

}

static PyObject *

internal_error_callback(const char *errors)

{

if (errors == NULL || strcmp(errors, "strict") == 0)

return ERROR_STRICT;

else if (strcmp(errors, "ignore") == 0)

return ERROR_IGNORE;

else if (strcmp(errors, "replace") == 0)

return ERROR_REPLACE;

else

return PyUnicode_FromString(errors);

}

static PyObject *

call_error_callback(PyObject *errors, PyObject *exc)

{

PyObject *args, *cb, *r;

const char *str;

assert(PyUnicode_Check(errors));

str = PyUnicode_AsUTF8(errors);

if (str == NULL)

return NULL;

cb = PyCodec_LookupError(str);

if (cb == NULL)

return NULL;

args = PyTuple_New(1);

if (args == NULL) {

Py_DECREF(cb);

return NULL;

}

PyTuple_SetItemRef(args, 0, exc);

Py_DECREF(exc);

Py_INCREF(exc);

r = PyObject_CallObject(cb, args);

Py_DECREF(args);

Py_DECREF(cb);

return r;

}

static PyObject *

codecctx_errors_get(MultibyteStatefulCodecContext *self)

{

const char *errors;

if (self->errors == ERROR_STRICT)

errors = "strict";

else if (self->errors == ERROR_IGNORE)

errors = "ignore";

else if (self->errors == ERROR_REPLACE)

errors = "replace";

else {

Py_INCREF(self->errors);

return self->errors;

}

return PyUnicode_FromString(errors);

}

static int

codecctx_errors_set(MultibyteStatefulCodecContext *self, PyObject *value,

void *closure)

{

PyObject *cb;

const char *str;

if (!PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError, "errors must be a string");

return -1;

}

str = PyUnicode_AsUTF8(value);

if (str == NULL)

return -1;

cb = internal_error_callback(str);

if (cb == NULL)

return -1;

ERROR_DECREF(self->errors);

self->errors = cb;

return 0;

}

static PyGetSetDef codecctx_getsets[] = {

{"errors", (getter)codecctx_errors_get,

(setter)codecctx_errors_set,

PyDoc_STR("how to treat errors")},

{NULL,}

};

static int

expand_encodebuffer(MultibyteEncodeBuffer *buf, Py_ssize_t esize)

{

Py_ssize_t orgpos, orgsize, incsize;

orgpos = (Py_ssize_t)((char *)buf->outbuf -

PyBytes_AS_STRING(buf->outobj));

orgsize = PyBytes_GET_SIZE(buf->outobj);

incsize = (esize < (orgsize >> 1) ? (orgsize >> 1) | 1 : esize);

if (orgsize > PY_SSIZE_T_MAX - incsize) {

PyErr_NoMemory();

return -1;

}

if (_PyBytes_Resize(&buf->outobj, orgsize + incsize) == -1)

return -1;

buf->outbuf = (unsigned char *)PyBytes_AS_STRING(buf->outobj) +orgpos;

buf->outbuf_end = (unsigned char *)PyBytes_AS_STRING(buf->outobj)

+ PyBytes_GET_SIZE(buf->outobj);

return 0;

}

#define REQUIRE_ENCODEBUFFER(buf, s) do { \

if ((s) < 0 || (s) > (buf)->outbuf_end - (buf)->outbuf) \

if (expand_encodebuffer(buf, s) == -1) \

goto errorexit; \

} while(0)

static int

multibytecodec_encerror(MultibyteCodec *codec,

MultibyteCodec_State *state,

MultibyteEncodeBuffer *buf,

PyObject *errors, Py_ssize_t e)

{

PyObject *retobj = NULL, *retstr = NULL, *tobj, *arg;

Py_ssize_t retstrsize, newpos;

Py_ssize_t esize, start, end;

const char *reason;

if (e > 0) {

reason = "illegal multibyte sequence";

esize = e;

}

else {

switch (e) {

case MBERR_TOOSMALL:

REQUIRE_ENCODEBUFFER(buf, -1);

return 0; /* retry it */

case MBERR_TOOFEW:

reason = "incomplete multibyte sequence";

esize = (Py_ssize_t)buf->inpos;

break;

case MBERR_INTERNAL:

PyErr_SetString(PyExc_RuntimeError,

"internal codec error");

return -1;

default:

PyErr_SetString(PyExc_RuntimeError,

"unknown runtime error");

return -1;

}

}

if (errors == ERROR_REPLACE) {

PyObject *replchar;

Py_ssize_t r;

Py_ssize_t inpos;

int kind;

void *data;

replchar = PyUnicode_FromOrdinal('?');

if (replchar == NULL)

goto errorexit;

kind = PyUnicode_KIND(replchar);

data = PyUnicode_DATA(replchar);

inpos = 0;

for (;;) {

Py_ssize_t outleft = (Py_ssize_t)(buf->outbuf_end - buf->outbuf);

r = codec->encode(state, codec->config,

kind, data, &inpos, 1,

&buf->outbuf, outleft, 0);

if (r == MBERR_TOOSMALL) {

REQUIRE_ENCODEBUFFER(buf, -1);

continue;

}

else

break;

}

Py_DECREF(replchar);

if (r != 0) {

REQUIRE_ENCODEBUFFER(buf, 1);

*buf->outbuf++ = '?';

}

}

if (errors == ERROR_IGNORE || errors == ERROR_REPLACE) {

buf->inpos += esize;

return 0;

}

start = (Py_ssize_t)buf->inpos;

end = start + esize;

/* use cached exception object if available */

if (buf->excobj == NULL) {

buf->excobj = PyObject_CallFunction(PyExc_UnicodeEncodeError,

"sOnns",

codec->encoding, buf->inobj,

start, end, reason);

if (buf->excobj == NULL)

goto errorexit;

}

else

if (PyUnicodeEncodeError_SetStart(buf->excobj, start) != 0 ||

PyUnicodeEncodeError_SetEnd(buf->excobj, end) != 0 ||

PyUnicodeEncodeError_SetReason(buf->excobj, reason) != 0)

goto errorexit;

if (errors == ERROR_STRICT) {

PyCodec_StrictErrors(buf->excobj);

goto errorexit;

}

retobj = call_error_callback(errors, buf->excobj);

if (retobj == NULL)

goto errorexit;

int invalid = (!PyTuple_Check(retobj) || PyTuple_GET_SIZE(retobj) != 2);

if (!invalid) {

tobj = PyTuple_GetItemRef(retobj, 0);

arg = PyTuple_GetItemRef(retobj, 1);

invalid = ((!PyUnicode_Check(tobj) && !PyBytes_Check(tobj)) ||

!PyLong_Check(arg));

if (invalid) {

Py_DECREF(tobj);

Py_DECREF(arg);

}

}

if (invalid) {

PyErr_SetString(PyExc_TypeError,

"encoding error handler must return "

"(str, int) tuple");

goto errorexit;

}

Py_DECREF(tobj);

Py_DECREF(arg);

if (PyUnicode_Check(tobj)) {

Py_ssize_t inpos;

retstr = multibytecodec_encode(codec, state, tobj,

&inpos, ERROR_STRICT,

MBENC_FLUSH);

if (retstr == NULL)

goto errorexit;

}

else {

Py_INCREF(tobj);

retstr = tobj;

}

assert(PyBytes_Check(retstr));

retstrsize = PyBytes_GET_SIZE(retstr);

if (retstrsize > 0) {

REQUIRE_ENCODEBUFFER(buf, retstrsize);

memcpy(buf->outbuf, PyBytes_AS_STRING(retstr), retstrsize);

buf->outbuf += retstrsize;

}

arg = PyTuple_GetItemRef(retobj, 1);

newpos = PyLong_AsSsize_t(arg);

Py_DECREF(arg);

if (newpos < 0 && !PyErr_Occurred())

newpos += (Py_ssize_t)buf->inlen;

if (newpos < 0 || newpos > buf->inlen) {

PyErr_Clear();

PyErr_Format(PyExc_IndexError,

"position %zd from error handler out of bounds",

newpos);

goto errorexit;

}

buf->inpos = newpos;

Py_DECREF(retobj);

Py_DECREF(retstr);

return 0;

errorexit:

Py_XDECREF(retobj);

Py_XDECREF(retstr);

return -1;

}

static int

multibytecodec_decerror(MultibyteCodec *codec,

MultibyteCodec_State *state,

MultibyteDecodeBuffer *buf,

PyObject *errors, Py_ssize_t e)

{

PyObject *retobj = NULL, *retuni = NULL, *arg;

Py_ssize_t newpos;

const char *reason;

Py_ssize_t esize, start, end;

if (e > 0) {

reason = "illegal multibyte sequence";

esize = e;

}

else {

switch (e) {

case MBERR_TOOSMALL:

return 0; /* retry it */

case MBERR_TOOFEW:

reason = "incomplete multibyte sequence";

esize = (Py_ssize_t)(buf->inbuf_end - buf->inbuf);

break;

case MBERR_INTERNAL:

PyErr_SetString(PyExc_RuntimeError,

"internal codec error");

return -1;

case MBERR_EXCEPTION:

return -1;

default:

PyErr_SetString(PyExc_RuntimeError,

"unknown runtime error");

return -1;

}

}

if (errors == ERROR_REPLACE) {

if (_PyUnicodeWriter_WriteChar(&buf->writer,

Py_UNICODE_REPLACEMENT_CHARACTER) < 0)

goto errorexit;

}

if (errors == ERROR_IGNORE || errors == ERROR_REPLACE) {

buf->inbuf += esize;

return 0;

}

start = (Py_ssize_t)(buf->inbuf - buf->inbuf_top);

end = start + esize;

/* use cached exception object if available */

if (buf->excobj == NULL) {

buf->excobj = PyUnicodeDecodeError_Create(codec->encoding,

(const char *)buf->inbuf_top,

(Py_ssize_t)(buf->inbuf_end - buf->inbuf_top),

start, end, reason);

if (buf->excobj == NULL)

goto errorexit;

}

else

if (PyUnicodeDecodeError_SetStart(buf->excobj, start) ||

PyUnicodeDecodeError_SetEnd(buf->excobj, end) ||

PyUnicodeDecodeError_SetReason(buf->excobj, reason))

goto errorexit;

if (errors == ERROR_STRICT) {

PyCodec_StrictErrors(buf->excobj);

goto errorexit;

}

retobj = call_error_callback(errors, buf->excobj);

if (retobj == NULL)

goto errorexit;

int invalid = (!PyTuple_Check(retobj) || PyTuple_GET_SIZE(retobj) != 2);

if (!invalid) {

retuni = PyTuple_GetItemRef(retobj, 0);

arg = PyTuple_GetItemRef(retobj, 1);

invalid = (!PyUnicode_Check(retuni) || !PyLong_Check(arg));

if (invalid) {

Py_DECREF(retuni);

Py_DECREF(arg);

}

}

if (invalid) {

PyErr_SetString(PyExc_TypeError,

"decoding error handler must return "

"(str, int) tuple");

goto errorexit;

}

Py_DECREF(retuni);

Py_DECREF(arg);

if (_PyUnicodeWriter_WriteStr(&buf->writer, retuni) < 0)

goto errorexit;

arg = PyTuple_GetItemRef(retobj, 1);

newpos = PyLong_AsSsize_t(arg);

Py_DECREF(arg);

if (newpos < 0 && !PyErr_Occurred())

newpos += (Py_ssize_t)(buf->inbuf_end - buf->inbuf_top);

if (newpos < 0 || buf->inbuf_top + newpos > buf->inbuf_end) {

PyErr_Clear();

PyErr_Format(PyExc_IndexError,

"position %zd from error handler out of bounds",

newpos);

goto errorexit;

}

buf->inbuf = buf->inbuf_top + newpos;

Py_DECREF(retobj);

return 0;

errorexit:

Py_XDECREF(retobj);

return -1;

}

static PyObject *

multibytecodec_encode(MultibyteCodec *codec,

MultibyteCodec_State *state,

PyObject *text, Py_ssize_t *inpos_t,

PyObject *errors, int flags)

{

MultibyteEncodeBuffer buf;

Py_ssize_t finalsize, r = 0;

Py_ssize_t datalen;

int kind;

void *data;

if (PyUnicode_READY(text) < 0)

return NULL;

datalen = PyUnicode_GET_LENGTH(text);

if (datalen == 0 && !(flags & MBENC_RESET))

return PyBytes_FromStringAndSize(NULL, 0);

buf.excobj = NULL;

buf.outobj = NULL;

buf.inobj = text; /* borrowed reference */

buf.inpos = 0;

buf.inlen = datalen;

kind = PyUnicode_KIND(buf.inobj);

data = PyUnicode_DATA(buf.inobj);

if (datalen > (PY_SSIZE_T_MAX - 16) / 2) {

PyErr_NoMemory();

goto errorexit;

}

buf.outobj = PyBytes_FromStringAndSize(NULL, datalen * 2 + 16);

if (buf.outobj == NULL)

goto errorexit;

buf.outbuf = (unsigned char *)PyBytes_AS_STRING(buf.outobj);

buf.outbuf_end = buf.outbuf + PyBytes_GET_SIZE(buf.outobj);

while (buf.inpos < buf.inlen) {

/* we don't reuse inleft and outleft here.

Py_ssize_t outleft = (Py_ssize_t)(buf.outbuf_end - buf.outbuf);

r = codec->encode(state, codec->config,

kind, data,

&buf.inpos, buf.inlen,

&buf.outbuf, outleft, flags);

if ((r == 0) || (r == MBERR_TOOFEW && !(flags & MBENC_FLUSH)))

break;

else if (multibytecodec_encerror(codec, state, &buf, errors,r))

goto errorexit;

else if (r == MBERR_TOOFEW)

break;

}

if (codec->encreset != NULL && (flags & MBENC_RESET))

for (;;) {

Py_ssize_t outleft;

outleft = (Py_ssize_t)(buf.outbuf_end - buf.outbuf);

r = codec->encreset(state, codec->config, &buf.outbuf,

outleft);

if (r == 0)

break;

else if (multibytecodec_encerror(codec, state,

&buf, errors, r))

goto errorexit;

}

finalsize = (Py_ssize_t)((char *)buf.outbuf -

PyBytes_AS_STRING(buf.outobj));

if (finalsize != PyBytes_GET_SIZE(buf.outobj))

if (_PyBytes_Resize(&buf.outobj, finalsize) == -1)

goto errorexit;

if (inpos_t)

*inpos_t = buf.inpos;

Py_XDECREF(buf.excobj);

return buf.outobj;

errorexit:

Py_XDECREF(buf.excobj);

Py_XDECREF(buf.outobj);

return NULL;

}

static PyObject *

_multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,

PyObject *input,

const char *errors)

{

MultibyteCodec_State state;

PyObject *errorcb, *r, *ucvt;

Py_ssize_t datalen;

if (PyUnicode_Check(input))

ucvt = NULL;

else {

input = ucvt = PyObject_Str(input);

if (input == NULL)

return NULL;

else if (!PyUnicode_Check(input)) {

PyErr_SetString(PyExc_TypeError,

"couldn't convert the object to unicode.");

Py_DECREF(ucvt);

return NULL;

}

}

if (PyUnicode_READY(input) < 0) {

Py_XDECREF(ucvt);

return NULL;

}

datalen = PyUnicode_GET_LENGTH(input);

errorcb = internal_error_callback(errors);

if (errorcb == NULL) {

Py_XDECREF(ucvt);

return NULL;

}

if (self->codec->encinit != NULL &&

self->codec->encinit(&state, self->codec->config) != 0)

goto errorexit;

r = multibytecodec_encode(self->codec, &state,

input, NULL, errorcb,

MBENC_FLUSH | MBENC_RESET);

if (r == NULL)

goto errorexit;

ERROR_DECREF(errorcb);

Py_XDECREF(ucvt);

return make_tuple(r, datalen);

errorexit:

ERROR_DECREF(errorcb);

Py_XDECREF(ucvt);

return NULL;

}

static PyObject *

_multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,

Py_buffer *input,

const char *errors)

{

MultibyteCodec_State state;

MultibyteDecodeBuffer buf;

PyObject *errorcb, *res;

const char *data;

Py_ssize_t datalen;

data = input->buf;

datalen = input->len;

errorcb = internal_error_callback(errors);

if (errorcb == NULL) {

return NULL;

}

if (datalen == 0) {

ERROR_DECREF(errorcb);

return make_tuple(PyUnicode_New(0, 0), 0);

}

_PyUnicodeWriter_Init(&buf.writer);

buf.writer.min_length = datalen;

buf.excobj = NULL;

buf.inbuf = buf.inbuf_top = (unsigned char *)data;

buf.inbuf_end = buf.inbuf_top + datalen;

if (self->codec->decinit != NULL &&

self->codec->decinit(&state, self->codec->config) != 0)

goto errorexit;

while (buf.inbuf < buf.inbuf_end) {

Py_ssize_t inleft, r;

inleft = (Py_ssize_t)(buf.inbuf_end - buf.inbuf);

r = self->codec->decode(&state, self->codec->config,

&buf.inbuf, inleft, &buf.writer);

if (r == 0)

break;

else if (multibytecodec_decerror(self->codec, &state,

&buf, errorcb, r))

goto errorexit;

}

res = _PyUnicodeWriter_Finish(&buf.writer);

if (res == NULL)

goto errorexit;

Py_XDECREF(buf.excobj);

ERROR_DECREF(errorcb);

return make_tuple(res, datalen);

errorexit:

ERROR_DECREF(errorcb);

Py_XDECREF(buf.excobj);

_PyUnicodeWriter_Dealloc(&buf.writer);

return NULL;

}

static struct PyMethodDef multibytecodec_methods[] = {

_MULTIBYTECODEC_MULTIBYTECODEC_ENCODE_METHODDEF

_MULTIBYTECODEC_MULTIBYTECODEC_DECODE_METHODDEF

{NULL, NULL},

};

static void

multibytecodec_dealloc(MultibyteCodecObject *self)

{

PyObject_Del(self);

}

static PyTypeObject MultibyteCodec_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"MultibyteCodec", /* tp_name */

sizeof(MultibyteCodecObject), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)multibytecodec_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_reserved */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iterext */

multibytecodec_methods, /* tp_methods */

};

#define STATEFUL_DCTX(o) ((MultibyteStatefulDecoderContext *)(o))

#define STATEFUL_ECTX(o) ((MultibyteStatefulEncoderContext *)(o))

static PyObject *

encoder_encode_stateful(MultibyteStatefulEncoderContext *ctx,

PyObject *unistr, int final)

{

PyObject *ucvt, *r = NULL;

PyObject *inbuf = NULL;

Py_ssize_t inpos, datalen;

PyObject *origpending = NULL;

if (PyUnicode_Check(unistr))

ucvt = NULL;

else {

unistr = ucvt = PyObject_Str(unistr);

if (unistr == NULL)

return NULL;

else if (!PyUnicode_Check(unistr)) {

PyErr_SetString(PyExc_TypeError,

"couldn't convert the object to str.");

Py_DECREF(ucvt);

return NULL;

}

}

if (ctx->pending) {

PyObject *inbuf_tmp;

Py_INCREF(ctx->pending);

origpending = ctx->pending;

Py_INCREF(ctx->pending);

inbuf_tmp = ctx->pending;

PyUnicode_Append(&inbuf_tmp, unistr);

if (inbuf_tmp == NULL)

goto errorexit;

Py_CLEAR(ctx->pending);

inbuf = inbuf_tmp;

}

else {

origpending = NULL;

Py_INCREF(unistr);

inbuf = unistr;

}

if (PyUnicode_READY(inbuf) < 0)

goto errorexit;

inpos = 0;

datalen = PyUnicode_GET_LENGTH(inbuf);

r = multibytecodec_encode(ctx->codec, &ctx->state,

inbuf, &inpos,

ctx->errors, final ? MBENC_FLUSH | MBENC_RESET : 0);

if (r == NULL) {

/* recover the original pending buffer */

Py_XSETREF(ctx->pending, origpending);

origpending = NULL;

goto errorexit;

}

Py_XDECREF(origpending);

if (inpos < datalen) {

if (datalen - inpos > MAXENCPENDING) {

/* normal codecs can't reach here */

PyErr_SetString(PyExc_UnicodeError,

"pending buffer overflow");

goto errorexit;

}

ctx->pending = PyUnicode_Substring(inbuf, inpos, datalen);

if (ctx->pending == NULL) {

/* normal codecs can't reach here */

goto errorexit;

}

}

Py_DECREF(inbuf);

Py_XDECREF(ucvt);

return r;

errorexit:

Py_XDECREF(r);

Py_XDECREF(ucvt);

Py_XDECREF(origpending);

Py_XDECREF(inbuf);

return NULL;

}

static int

decoder_append_pending(MultibyteStatefulDecoderContext *ctx,

MultibyteDecodeBuffer *buf)

{

Py_ssize_t npendings;

npendings = (Py_ssize_t)(buf->inbuf_end - buf->inbuf);

if (npendings + ctx->pendingsize > MAXDECPENDING ||

npendings > PY_SSIZE_T_MAX - ctx->pendingsize) {

PyErr_SetString(PyExc_UnicodeError, "pending buffer overflow");

return -1;

}

memcpy(ctx->pending + ctx->pendingsize, buf->inbuf, npendings);

ctx->pendingsize += npendings;

return 0;

}

static int

decoder_prepare_buffer(MultibyteDecodeBuffer *buf, const char *data,

Py_ssize_t size)

{

buf->inbuf = buf->inbuf_top = (const unsigned char *)data;

buf->inbuf_end = buf->inbuf_top + size;

buf->writer.min_length += size;

return 0;

}

static int

decoder_feed_buffer(MultibyteStatefulDecoderContext *ctx,

MultibyteDecodeBuffer *buf)

{

while (buf->inbuf < buf->inbuf_end) {

Py_ssize_t inleft;

Py_ssize_t r;

inleft = (Py_ssize_t)(buf->inbuf_end - buf->inbuf);

r = ctx->codec->decode(&ctx->state, ctx->codec->config,

&buf->inbuf, inleft, &buf->writer);

if (r == 0 || r == MBERR_TOOFEW)

break;

else if (multibytecodec_decerror(ctx->codec, &ctx->state,

buf, ctx->errors, r))

return -1;

}

return 0;

}

static PyObject *

_multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,

PyObject *input,

int final)

{

return encoder_encode_stateful(STATEFUL_ECTX(self), input, final);

}

static PyObject *

_multibytecodec_MultibyteIncrementalEncoder_reset_impl(MultibyteIncrementalEncoderObject *self)

{

/* Longest output: 4 bytes (b'\x0F\x1F(B') with ISO 2022 */

unsigned char buffer[4], *outbuf;

Py_ssize_t r;

if (self->codec->encreset != NULL) {

outbuf = buffer;

r = self->codec->encreset(&self->state, self->codec->config,

&outbuf, sizeof(buffer));

if (r != 0)

return NULL;

}

Py_CLEAR(self->pending);

Py_RETURN_NONE;

}

static struct PyMethodDef mbiencoder_methods[] = {

_MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_ENCODE_METHODDEF

_MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_RESET_METHODDEF

{NULL, NULL},

};

static PyObject *

mbiencoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

MultibyteIncrementalEncoderObject *self;

PyObject *codec = NULL;

char *errors = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s:IncrementalEncoder",

incnewkwarglist, &errors))

return NULL;

self = (MultibyteIncrementalEncoderObject *)type->tp_alloc(type, 0);

if (self == NULL)

return NULL;

codec = PyObject_GetAttrString((PyObject *)type, "codec");

if (codec == NULL)

goto errorexit;

if (!MultibyteCodec_Check(codec)) {

PyErr_SetString(PyExc_TypeError, "codec is unexpected type");

goto errorexit;

}

self->codec = ((MultibyteCodecObject *)codec)->codec;

self->pending = NULL;

self->errors = internal_error_callback(errors);

if (self->errors == NULL)

goto errorexit;

if (self->codec->encinit != NULL &&

self->codec->encinit(&self->state, self->codec->config) != 0)

goto errorexit;

Py_DECREF(codec);

return (PyObject *)self;

errorexit:

Py_XDECREF(self);

Py_XDECREF(codec);

return NULL;

}

static int

mbiencoder_init(PyObject *self, PyObject *args, PyObject *kwds)

{

return 0;

}