Lines Matching refs:self
133 codecctx_errors_get(MultibyteStatefulCodecContext *self, void *Py_UNUSED(ignored))
137 if (self->errors == ERROR_STRICT)
139 else if (self->errors == ERROR_IGNORE)
141 else if (self->errors == ERROR_REPLACE)
144 Py_INCREF(self->errors);
145 return self->errors;
152 codecctx_errors_set(MultibyteStatefulCodecContext *self, PyObject *value,
175 ERROR_DECREF(self->errors);
176 self->errors = cb;
584 _multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,
619 if (self->codec->encinit != NULL &&
620 self->codec->encinit(&state, self->codec->config) != 0)
622 r = multibytecodec_encode(self->codec, &state,
653 _multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,
683 if (self->codec->decinit != NULL &&
684 self->codec->decinit(&state, self->codec->config) != 0)
692 r = self->codec->decode(&state, self->codec->config,
696 else if (multibytecodec_decerror(self->codec, &state,
724 multibytecodec_traverse(PyObject *self, visitproc visit, void *arg)
726 Py_VISIT(Py_TYPE(self));
731 multibytecodec_dealloc(MultibyteCodecObject *self)
733 PyObject_GC_UnTrack(self);
734 PyTypeObject *tp = Py_TYPE(self);
735 tp->tp_free(self);
905 _multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,
910 return encoder_encode_stateful(STATEFUL_ECTX(self), input, final);
918 _multibytecodec_MultibyteIncrementalEncoder_getstate_impl(MultibyteIncrementalEncoderObject *self)
927 unsigned char statebytes[1 + MAXENCPENDING*4 + sizeof(self->state.c)];
932 if (self->pending != NULL) {
933 pendingbuffer = PyUnicode_AsUTF8AndSize(self->pending, &pendingsize);
948 memcpy(statebytes+statesize, self->state.c,
949 sizeof(self->state.c));
950 statesize += sizeof(self->state.c);
964 _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(MultibyteIncrementalEncoderObject *self,
969 unsigned char statebytes[1 + MAXENCPENDING*4 + sizeof(self->state.c)];
988 Py_CLEAR(self->pending);
989 self->pending = pending;
990 memcpy(self->state.c, statebytes+1+statebytes[0],
991 sizeof(self->state.c));
1005 _multibytecodec_MultibyteIncrementalEncoder_reset_impl(MultibyteIncrementalEncoderObject *self)
1011 if (self->codec->encreset != NULL) {
1013 r = self->codec->encreset(&self->state, self->codec->config,
1018 Py_CLEAR(self->pending);
1033 MultibyteIncrementalEncoderObject *self;
1041 self = (MultibyteIncrementalEncoderObject *)type->tp_alloc(type, 0);
1042 if (self == NULL)
1055 self->codec = ((MultibyteCodecObject *)codec)->codec;
1056 self->pending = NULL;
1057 self->errors = internal_error_callback(errors);
1058 if (self->errors == NULL)
1060 if (self->codec->encinit != NULL &&
1061 self->codec->encinit(&self->state, self->codec->config) != 0)
1065 return (PyObject *)self;
1068 Py_XDECREF(self);
1074 mbiencoder_init(PyObject *self, PyObject *args, PyObject *kwds)
1080 mbiencoder_traverse(MultibyteIncrementalEncoderObject *self,
1083 if (ERROR_ISCUSTOM(self->errors))
1084 Py_VISIT(self->errors);
1089 mbiencoder_dealloc(MultibyteIncrementalEncoderObject *self)
1091 PyTypeObject *tp = Py_TYPE(self);
1092 PyObject_GC_UnTrack(self);
1093 ERROR_DECREF(self->errors);
1094 Py_CLEAR(self->pending);
1095 tp->tp_free(self);
1127 _multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
1142 origpending = self->pendingsize;
1144 if (self->pendingsize == 0) {
1149 if (size > PY_SSIZE_T_MAX - self->pendingsize) {
1153 wsize = size + self->pendingsize;
1159 memcpy(wdata, self->pending, self->pendingsize);
1160 memcpy(wdata + self->pendingsize, data, size);
1161 self->pendingsize = 0;
1167 if (decoder_feed_buffer(STATEFUL_DCTX(self), &buf))
1171 if (multibytecodec_decerror(self->codec, &self->state,
1172 &buf, self->errors, MBERR_TOOFEW)) {
1174 memcpy(self->pending, wdata, origpending);
1175 self->pendingsize = origpending;
1181 if (decoder_append_pending(STATEFUL_DCTX(self), &buf) != 0)
1207 _multibytecodec_MultibyteIncrementalDecoder_getstate_impl(MultibyteIncrementalDecoderObject *self)
1213 buffer = PyBytes_FromStringAndSize((const char *)self->pending,
1214 self->pendingsize);
1219 statelong = (PyObject *)_PyLong_FromByteArray(self->state.c,
1220 sizeof(self->state.c),
1238 _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(MultibyteIncrementalDecoderObject *self,
1274 self->pendingsize = buffersize;
1275 memcpy(self->pending, bufferstr, self->pendingsize);
1276 memcpy(self->state.c, statebytes, sizeof(statebytes));
1286 _multibytecodec_MultibyteIncrementalDecoder_reset_impl(MultibyteIncrementalDecoderObject *self)
1289 if (self->codec->decreset != NULL &&
1290 self->codec->decreset(&self->state, self->codec->config) != 0)
1292 self->pendingsize = 0;
1308 MultibyteIncrementalDecoderObject *self;
1316 self = (MultibyteIncrementalDecoderObject *)type->tp_alloc(type, 0);
1317 if (self == NULL)
1330 self->codec = ((MultibyteCodecObject *)codec)->codec;
1331 self->pendingsize = 0;
1332 self->errors = internal_error_callback(errors);
1333 if (self->errors == NULL)
1335 if (self->codec->decinit != NULL &&
1336 self->codec->decinit(&self->state, self->codec->config) != 0)
1340 return (PyObject *)self;
1343 Py_XDECREF(self);
1349 mbidecoder_init(PyObject *self, PyObject *args, PyObject *kwds)
1355 mbidecoder_traverse(MultibyteIncrementalDecoderObject *self,
1358 if (ERROR_ISCUSTOM(self->errors))
1359 Py_VISIT(self->errors);
1364 mbidecoder_dealloc(MultibyteIncrementalDecoderObject *self)
1366 PyTypeObject *tp = Py_TYPE(self);
1367 PyObject_GC_UnTrack(self);
1368 ERROR_DECREF(self->errors);
1369 tp->tp_free(self);
1393 mbstreamreader_iread(MultibyteStreamReaderObject *self,
1411 cres = PyObject_CallMethod(self->stream,
1414 cres = PyObject_CallMethod(self->stream,
1429 if (self->pendingsize > 0) {
1433 if (PyBytes_GET_SIZE(cres) > PY_SSIZE_T_MAX - self->pendingsize) {
1437 rsize = PyBytes_GET_SIZE(cres) + self->pendingsize;
1442 memcpy(ctrdata, self->pending, self->pendingsize);
1443 memcpy(ctrdata + self->pendingsize,
1448 self->pendingsize = 0;
1457 (MultibyteStatefulDecoderContext *)self, &buf))
1462 multibytecodec_decerror(self->codec, &self->state,
1463 &buf, self->errors, MBERR_TOOFEW))
1468 if (decoder_append_pending(STATEFUL_DCTX(self),
1505 _multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
1523 return mbstreamreader_iread(self, "read", size);
1534 _multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
1552 return mbstreamreader_iread(self, "readline", size);
1563 _multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
1582 r = mbstreamreader_iread(self, "read", sizehint);
1596 _multibytecodec_MultibyteStreamReader_reset_impl(MultibyteStreamReaderObject *self)
1599 if (self->codec->decreset != NULL &&
1600 self->codec->decreset(&self->state, self->codec->config) != 0)
1602 self->pendingsize = 0;
1625 MultibyteStreamReaderObject *self;
1633 self = (MultibyteStreamReaderObject *)type->tp_alloc(type, 0);
1634 if (self == NULL)
1647 self->codec = ((MultibyteCodecObject *)codec)->codec;
1648 self->stream = stream;
1650 self->pendingsize = 0;
1651 self->errors = internal_error_callback(errors);
1652 if (self->errors == NULL)
1654 if (self->codec->decinit != NULL &&
1655 self->codec->decinit(&self->state, self->codec->config) != 0)
1659 return (PyObject *)self;
1662 Py_XDECREF(self);
1668 mbstreamreader_init(PyObject *self, PyObject *args, PyObject *kwds)
1674 mbstreamreader_traverse(MultibyteStreamReaderObject *self,
1677 if (ERROR_ISCUSTOM(self->errors))
1678 Py_VISIT(self->errors);
1679 Py_VISIT(self->stream);
1684 mbstreamreader_dealloc(MultibyteStreamReaderObject *self)
1686 PyTypeObject *tp = Py_TYPE(self);
1687 PyObject_GC_UnTrack(self);
1688 ERROR_DECREF(self->errors);
1689 Py_XDECREF(self->stream);
1690 tp->tp_free(self);
1715 mbstreamwriter_iwrite(MultibyteStreamWriterObject *self,
1720 str = encoder_encode_stateful(STATEFUL_ECTX(self), unistr, 0);
1724 wr = _PyObject_CallMethodOneArg(self->stream, str_write, str);
1742 _multibytecodec_MultibyteStreamWriter_write_impl(MultibyteStreamWriterObject *self,
1749 if (mbstreamwriter_iwrite(self, strobj, state->str_write)) {
1764 _multibytecodec_MultibyteStreamWriter_writelines_impl(MultibyteStreamWriterObject *self,
1786 r = mbstreamwriter_iwrite(self, strobj, state->str_write);
1807 _multibytecodec_MultibyteStreamWriter_reset_impl(MultibyteStreamWriterObject *self,
1813 if (!self->pending)
1816 pwrt = multibytecodec_encode(self->codec, &self->state,
1817 self->pending, NULL, self->errors,
1823 Py_CLEAR(self->pending);
1835 wr = _PyObject_CallMethodOneArg(self->stream, state->str_write, pwrt);
1849 MultibyteStreamWriterObject *self;
1857 self = (MultibyteStreamWriterObject *)type->tp_alloc(type, 0);
1858 if (self == NULL)
1871 self->codec = ((MultibyteCodecObject *)codec)->codec;
1872 self->stream = stream;
1874 self->pending = NULL;
1875 self->errors = internal_error_callback(errors);
1876 if (self->errors == NULL)
1878 if (self->codec->encinit != NULL &&
1879 self->codec->encinit(&self->state, self->codec->config) != 0)
1883 return (PyObject *)self;
1886 Py_XDECREF(self);
1892 mbstreamwriter_init(PyObject *self, PyObject *args, PyObject *kwds)
1898 mbstreamwriter_traverse(MultibyteStreamWriterObject *self,
1901 if (ERROR_ISCUSTOM(self->errors))
1902 Py_VISIT(self->errors);
1903 Py_VISIT(self->stream);
1908 mbstreamwriter_dealloc(MultibyteStreamWriterObject *self)
1910 PyTypeObject *tp = Py_TYPE(self);
1911 PyObject_GC_UnTrack(self);
1912 ERROR_DECREF(self->errors);
1913 Py_XDECREF(self->stream);
1914 tp->tp_free(self);
1964 MultibyteCodecObject *self;
1977 self = PyObject_GC_New(MultibyteCodecObject, state->multibytecodec_type);
1978 if (self == NULL)
1980 self->codec = codec;
1982 PyObject_GC_Track(self);
1983 return (PyObject *)self;