/*

An implementation of Text I/O as defined by PEP 3116 - "New I/O"

Classes defined here: TextIOBase, IncrementalNewlineDecoder, TextIOWrapper.

Written by Amaury Forgeot d'Arc and Antoine Pitrou

*/

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "_iomodule.h"

/*[clinic input]

module _io

class _io.IncrementalNewlineDecoder "nldecoder_object *" "&PyIncrementalNewlineDecoder_Type"

class _io.TextIOWrapper "textio *" "&TextIOWrapper_TYpe"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=2097a4fc85670c26]*/

/*[python input]

class io_ssize_t_converter(CConverter):

type = 'Py_ssize_t'

converter = '_PyIO_ConvertSsize_t'

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=d0a811d3cbfd1b33]*/

_Py_IDENTIFIER(close);

_Py_IDENTIFIER(_dealloc_warn);

_Py_IDENTIFIER(decode);

_Py_IDENTIFIER(fileno);

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(getpreferredencoding);

_Py_IDENTIFIER(isatty);

_Py_IDENTIFIER(mode);

_Py_IDENTIFIER(name);

_Py_IDENTIFIER(raw);

_Py_IDENTIFIER(read);

_Py_IDENTIFIER(read1);

_Py_IDENTIFIER(readable);

_Py_IDENTIFIER(replace);

_Py_IDENTIFIER(reset);

_Py_IDENTIFIER(seek);

_Py_IDENTIFIER(seekable);

_Py_IDENTIFIER(setstate);

_Py_IDENTIFIER(tell);

_Py_IDENTIFIER(writable);

/* TextIOBase */

PyDoc_STRVAR(textiobase_doc,

"Base class for text I/O.\n"

"\n"

"This class provides a character and line based interface to stream\n"

"I/O. There is no readinto method because Python's character strings\n"

"are immutable. There is no public constructor.\n"

);

static PyObject *

_unsupported(const char *message)

{

_PyIO_State *state = IO_STATE();

if (state != NULL)

PyErr_SetString(state->unsupported_operation, message);

return NULL;

}

PyDoc_STRVAR(textiobase_detach_doc,

"Separate the underlying buffer from the TextIOBase and return it.\n"

"\n"

"After the underlying buffer has been detached, the TextIO is in an\n"

"unusable state.\n"

);

static PyObject *

textiobase_detach(PyObject *self)

{

return _unsupported("detach");

}

PyDoc_STRVAR(textiobase_read_doc,

"Read at most n characters from stream.\n"

"\n"

"Read from underlying buffer until we have n characters or we hit EOF.\n"

"If n is negative or omitted, read until EOF.\n"

);

static PyObject *

textiobase_read(PyObject *self, PyObject *args)

{

return _unsupported("read");

}

PyDoc_STRVAR(textiobase_readline_doc,

"Read until newline or EOF.\n"

"\n"

"Returns an empty string if EOF is hit immediately.\n"

);

static PyObject *

textiobase_readline(PyObject *self, PyObject *args)

{

return _unsupported("readline");

}

PyDoc_STRVAR(textiobase_write_doc,

"Write string to stream.\n"

"Returns the number of characters written (which is always equal to\n"

"the length of the string).\n"

);

static PyObject *

textiobase_write(PyObject *self, PyObject *args)

{

return _unsupported("write");

}

PyDoc_STRVAR(textiobase_encoding_doc,

"Encoding of the text stream.\n"

"\n"

"Subclasses should override.\n"

);

static PyObject *

textiobase_encoding_get(PyObject *self, void *context)

{

Py_RETURN_NONE;

}

PyDoc_STRVAR(textiobase_newlines_doc,

"Line endings translated so far.\n"

"\n"

"Only line endings translated during reading are considered.\n"

"\n"

"Subclasses should override.\n"

);

static PyObject *

textiobase_newlines_get(PyObject *self, void *context)

{

Py_RETURN_NONE;

}

PyDoc_STRVAR(textiobase_errors_doc,

"The error setting of the decoder or encoder.\n"

"\n"

"Subclasses should override.\n"

);

static PyObject *

textiobase_errors_get(PyObject *self, void *context)

{

Py_RETURN_NONE;

}

static PyMethodDef textiobase_methods[] = {

{"detach", (PyCFunction)textiobase_detach, METH_NOARGS, textiobase_detach_doc},

{"read", textiobase_read, METH_VARARGS, textiobase_read_doc},

{"readline", textiobase_readline, METH_VARARGS, textiobase_readline_doc},

{"write", textiobase_write, METH_VARARGS, textiobase_write_doc},

{NULL, NULL}

};

static PyGetSetDef textiobase_getset[] = {

{"encoding", (getter)textiobase_encoding_get, NULL, textiobase_encoding_doc},

{"newlines", (getter)textiobase_newlines_get, NULL, textiobase_newlines_doc},

{"errors", (getter)textiobase_errors_get, NULL, textiobase_errors_doc},

{NULL}

};

PyTypeObject PyTextIOBase_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_io._TextIOBase", /*tp_name*/

0, /*tp_basicsize*/

0, /*tp_itemsize*/

0, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_compare */

0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash */

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE

| Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/

textiobase_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

textiobase_methods, /* tp_methods */

0, /* tp_members */

textiobase_getset, /* tp_getset */

&PyIOBase_Type, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

0, /* tp_free */

0, /* tp_is_gc */

0, /* tp_bases */

0, /* tp_mro */

0, /* tp_cache */

0, /* tp_subclasses */

0, /* tp_weaklist */

0, /* tp_del */

0, /* tp_version_tag */

0, /* tp_finalize */

};

/* IncrementalNewlineDecoder */

typedef struct {

PyObject_HEAD

PyObject *decoder;

PyObject *errors;

unsigned int pendingcr: 1;

unsigned int translate: 1;

unsigned int seennl: 3;

} nldecoder_object;

/*[clinic input]

_io.IncrementalNewlineDecoder.__init__

decoder: object

translate: int

errors: object(c_default="NULL") = "strict"

Codec used when reading a file in universal newlines mode.

It wraps another incremental decoder, translating \r\n and \r into \n.

It also records the types of newlines encountered. When used with

translate=False, it ensures that the newline sequence is returned in

one piece. When used with decoder=None, it expects unicode strings as

decode input and translates newlines without first invoking an external

decoder.

[clinic start generated code]*/

static int

_io_IncrementalNewlineDecoder___init___impl(nldecoder_object *self,

PyObject *decoder, int translate,

PyObject *errors)

/*[clinic end generated code: output=fbd04d443e764ec2 input=89db6b19c6b126bf]*/

{

self->decoder = decoder;

Py_INCREF(decoder);

if (errors == NULL) {

self->errors = PyUnicode_FromString("strict");

if (self->errors == NULL)

return -1;

}

else {

Py_INCREF(errors);

self->errors = errors;

}

self->translate = translate;

self->seennl = 0;

self->pendingcr = 0;

return 0;

}

static void

incrementalnewlinedecoder_dealloc(nldecoder_object *self)

{

Py_CLEAR(self->decoder);

Py_CLEAR(self->errors);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static int

check_decoded(PyObject *decoded)

{

if (decoded == NULL)

return -1;

if (!PyUnicode_Check(decoded)) {

PyErr_Format(PyExc_TypeError,

"decoder should return a string result, not '%.200s'",

Py_TYPE(decoded)->tp_name);

Py_DECREF(decoded);

return -1;

}

if (PyUnicode_READY(decoded) < 0) {

Py_DECREF(decoded);

return -1;

}

return 0;

}

#define SEEN_CR 1

#define SEEN_LF 2

#define SEEN_CRLF 4

#define SEEN_ALL (SEEN_CR | SEEN_LF | SEEN_CRLF)

PyObject *

_PyIncrementalNewlineDecoder_decode(PyObject *myself,

PyObject *input, int final)

{

PyObject *output;

Py_ssize_t output_len;

nldecoder_object *self = (nldecoder_object *) myself;

if (self->decoder == NULL) {

PyErr_SetString(PyExc_ValueError,

"IncrementalNewlineDecoder.__init__ not called");

return NULL;

}

/* decode input (with the eventual \r from a previous pass) */

if (self->decoder != Py_None) {

output = PyObject_CallMethodObjArgs(self->decoder,

_PyIO_str_decode, input, final ? Py_True : Py_False, NULL);

}

else {

output = input;

Py_INCREF(output);

}

if (check_decoded(output) < 0)

return NULL;

output_len = PyUnicode_GET_LENGTH(output);

if (self->pendingcr && (final || output_len > 0)) {

/* Prefix output with CR */

int kind;

PyObject *modified;

char *out;

modified = PyUnicode_New(output_len + 1,

PyUnicode_MAX_CHAR_VALUE(output));

if (modified == NULL)

goto error;

kind = PyUnicode_KIND(modified);

out = PyUnicode_DATA(modified);

PyUnicode_WRITE(kind, PyUnicode_DATA(modified), 0, '\r');

memcpy(out + kind, PyUnicode_DATA(output), kind * output_len);

Py_DECREF(output);

output = modified; /* output remains ready */

self->pendingcr = 0;

output_len++;

}

/* retain last \r even when not translating data:

* then readline() is sure to get \r\n in one pass

*/

if (!final) {

if (output_len > 0

&& PyUnicode_READ_CHAR(output, output_len - 1) == '\r')

{

PyObject *modified = PyUnicode_Substring(output, 0, output_len -1);

if (modified == NULL)

goto error;

Py_DECREF(output);

output = modified;

self->pendingcr = 1;

}

}

/* Record which newlines are read and do newline translation if desired,

all in one pass. */

{

void *in_str;

Py_ssize_t len;

int seennl = self->seennl;

int only_lf = 0;

int kind;

in_str = PyUnicode_DATA(output);

len = PyUnicode_GET_LENGTH(output);

kind = PyUnicode_KIND(output);

if (len == 0)

return output;

/* If, up to now, newlines are consistently \n, do a quick check

for the \r *byte* with the libc's optimized memchr.

*/

if (seennl == SEEN_LF || seennl == 0) {

only_lf = (memchr(in_str, '\r', kind * len) == NULL);

}

if (only_lf) {

/* If not already seen, quick scan for a possible "\n" character.

(there's nothing else to be done, even when in translation mode)

*/

if (seennl == 0 &&

memchr(in_str, '\n', kind * len) != NULL) {

if (kind == PyUnicode_1BYTE_KIND)

seennl |= SEEN_LF;

else {

Py_ssize_t i = 0;

for (;;) {

Py_UCS4 c;

/* Fast loop for non-control characters */

while (PyUnicode_READ(kind, in_str, i) > '\n')

i++;

c = PyUnicode_READ(kind, in_str, i++);

if (c == '\n') {

seennl |= SEEN_LF;

break;

}

if (i >= len)

break;

}

}

}

/* Finished: we have scanned for newlines, and none of them

need translating */

}

else if (!self->translate) {

Py_ssize_t i = 0;

/* We have already seen all newline types, no need to scan again */

if (seennl == SEEN_ALL)

goto endscan;

for (;;) {

Py_UCS4 c;

/* Fast loop for non-control characters */

while (PyUnicode_READ(kind, in_str, i) > '\r')

i++;

c = PyUnicode_READ(kind, in_str, i++);

if (c == '\n')

seennl |= SEEN_LF;

else if (c == '\r') {

if (PyUnicode_READ(kind, in_str, i) == '\n') {

seennl |= SEEN_CRLF;

i++;

}

else

seennl |= SEEN_CR;

}

if (i >= len)

break;

if (seennl == SEEN_ALL)

break;

}

endscan:

;

}

else {

void *translated;

int kind = PyUnicode_KIND(output);

void *in_str = PyUnicode_DATA(output);

Py_ssize_t in, out;

/* XXX: Previous in-place translation here is disabled as

resizing is not possible anymore */

/* We could try to optimize this so that we only do a copy

when there is something to translate. On the other hand,

we already know there is a \r byte, so chances are high

that something needs to be done. */

translated = PyMem_Malloc(kind * len);

if (translated == NULL) {

PyErr_NoMemory();

goto error;

}

in = out = 0;

for (;;) {

Py_UCS4 c;

/* Fast loop for non-control characters */

while ((c = PyUnicode_READ(kind, in_str, in++)) > '\r')

PyUnicode_WRITE(kind, translated, out++, c);

if (c == '\n') {

PyUnicode_WRITE(kind, translated, out++, c);

seennl |= SEEN_LF;

continue;

}

if (c == '\r') {

if (PyUnicode_READ(kind, in_str, in) == '\n') {

in++;

seennl |= SEEN_CRLF;

}

else

seennl |= SEEN_CR;

PyUnicode_WRITE(kind, translated, out++, '\n');

continue;

}

if (in > len)

break;

PyUnicode_WRITE(kind, translated, out++, c);

}

Py_DECREF(output);

output = PyUnicode_FromKindAndData(kind, translated, out);

PyMem_Free(translated);

if (!output)

return NULL;

}

self->seennl |= seennl;

}

return output;

error:

Py_DECREF(output);

return NULL;

}

/*[clinic input]

_io.IncrementalNewlineDecoder.decode

input: object

final: int(c_default="0") = False

[clinic start generated code]*/

static PyObject *

_io_IncrementalNewlineDecoder_decode_impl(nldecoder_object *self,

PyObject *input, int final)

/*[clinic end generated code: output=0d486755bb37a66e input=d65677385bfd6827]*/

{

return _PyIncrementalNewlineDecoder_decode((PyObject *) self, input, final);

}

/*[clinic input]

_io.IncrementalNewlineDecoder.getstate

[clinic start generated code]*/

static PyObject *

_io_IncrementalNewlineDecoder_getstate_impl(nldecoder_object *self)

/*[clinic end generated code: output=f0d2c9c136f4e0d0 input=f8ff101825e32e7f]*/

{

PyObject *buffer;

unsigned long long flag;

if (self->decoder != Py_None) {

PyObject *state = PyObject_CallMethodObjArgs(self->decoder,

_PyIO_str_getstate, NULL);

if (state == NULL)

return NULL;

if (!PyArg_ParseTuple(state, "OK", &buffer, &flag)) {

Py_DECREF(state);

return NULL;

}

Py_INCREF(buffer);

Py_DECREF(state);

}

else {

buffer = PyBytes_FromString("");

flag = 0;

}

flag <<= 1;

if (self->pendingcr)

flag |= 1;

return Py_BuildValue("NK", buffer, flag);

}

/*[clinic input]

_io.IncrementalNewlineDecoder.setstate

state: object

/

[clinic start generated code]*/

static PyObject *

_io_IncrementalNewlineDecoder_setstate(nldecoder_object *self,

PyObject *state)

/*[clinic end generated code: output=c10c622508b576cb input=c53fb505a76dbbe2]*/

{

PyObject *buffer;

unsigned long long flag;

if (!PyArg_ParseTuple(state, "OK", &buffer, &flag))

return NULL;

self->pendingcr = (int) (flag & 1);

flag >>= 1;

if (self->decoder != Py_None)

return _PyObject_CallMethodId(self->decoder,

&PyId_setstate, "((OK))", buffer, flag);

else

Py_RETURN_NONE;

}

/*[clinic input]

_io.IncrementalNewlineDecoder.reset

[clinic start generated code]*/

static PyObject *

_io_IncrementalNewlineDecoder_reset_impl(nldecoder_object *self)

/*[clinic end generated code: output=32fa40c7462aa8ff input=728678ddaea776df]*/

{

self->seennl = 0;

self->pendingcr = 0;

if (self->decoder != Py_None)

return PyObject_CallMethodObjArgs(self->decoder, _PyIO_str_reset, NULL);

else

Py_RETURN_NONE;

}

static PyObject *

incrementalnewlinedecoder_newlines_get(nldecoder_object *self, void *context)

{

switch (self->seennl) {

case SEEN_CR:

return PyUnicode_FromString("\r");

case SEEN_LF:

return PyUnicode_FromString("\n");

case SEEN_CRLF:

return PyUnicode_FromString("\r\n");

case SEEN_CR | SEEN_LF:

return Py_BuildValue("ss", "\r", "\n");

case SEEN_CR | SEEN_CRLF:

return Py_BuildValue("ss", "\r", "\r\n");

case SEEN_LF | SEEN_CRLF:

return Py_BuildValue("ss", "\n", "\r\n");

case SEEN_CR | SEEN_LF | SEEN_CRLF:

return Py_BuildValue("sss", "\r", "\n", "\r\n");

default:

Py_RETURN_NONE;

}

}

/* TextIOWrapper */

typedef PyObject *

(*encodefunc_t)(PyObject *, PyObject *);

typedef struct

{

PyObject_HEAD

int ok; /* initialized? */

int detached;

Py_ssize_t chunk_size;

PyObject *buffer;

PyObject *encoding;

PyObject *encoder;

PyObject *decoder;

PyObject *readnl;

PyObject *errors;

const char *writenl; /* utf-8 encoded, NULL stands for \n */

char line_buffering;

char write_through;

char readuniversal;

char readtranslate;

char writetranslate;

char seekable;

char has_read1;

char telling;

char finalizing;

/* Specialized encoding func (see below) */

encodefunc_t encodefunc;

/* Whether or not it's the start of the stream */

char encoding_start_of_stream;

/* Reads and writes are internally buffered in order to speed things up.

However, any read will first flush the write buffer if itsn't empty.

Please also note that text to be written is first encoded before being

buffered. This is necessary so that encoding errors are immediately

reported to the caller, but it unfortunately means that the

IncrementalEncoder (whose encode() method is always written in Python)

becomes a bottleneck for small writes.

*/

PyObject *decoded_chars; /* buffer for text returned from decoder */

Py_ssize_t decoded_chars_used; /* offset into _decoded_chars for read() */

PyObject *pending_bytes; /* list of bytes objects waiting to be

written, or NULL */

Py_ssize_t pending_bytes_count;

/* snapshot is either None, or a tuple (dec_flags, next_input) where

* dec_flags is the second (integer) item of the decoder state and

* next_input is the chunk of input bytes that comes next after the

* snapshot point. We use this to reconstruct decoder states in tell().

*/

PyObject *snapshot;

/* Bytes-to-characters ratio for the current chunk. Serves as input for

the heuristic in tell(). */

double b2cratio;

/* Cache raw object if it's a FileIO object */

PyObject *raw;

PyObject *weakreflist;

PyObject *dict;

} textio;

/* A couple of specialized cases in order to bypass the slow incremental

encoding methods for the most popular encodings. */

static PyObject *

ascii_encode(textio *self, PyObject *text)

{

return _PyUnicode_AsASCIIString(text, PyBytes_AS_STRING(self->errors));

}

static PyObject *

utf16be_encode(textio *self, PyObject *text)

{

return _PyUnicode_EncodeUTF16(text,

PyBytes_AS_STRING(self->errors), 1);

}

static PyObject *

utf16le_encode(textio *self, PyObject *text)

{

return _PyUnicode_EncodeUTF16(text,

PyBytes_AS_STRING(self->errors), -1);

}

static PyObject *

utf16_encode(textio *self, PyObject *text)

{

if (!self->encoding_start_of_stream) {

/* Skip the BOM and use native byte ordering */

#if PY_BIG_ENDIAN

return utf16be_encode(self, text);

#else

return utf16le_encode(self, text);

#endif

}

return _PyUnicode_EncodeUTF16(text,

PyBytes_AS_STRING(self->errors), 0);

}

static PyObject *

utf32be_encode(textio *self, PyObject *text)

{

return _PyUnicode_EncodeUTF32(text,

PyBytes_AS_STRING(self->errors), 1);

}

static PyObject *

utf32le_encode(textio *self, PyObject *text)

{

return _PyUnicode_EncodeUTF32(text,

PyBytes_AS_STRING(self->errors), -1);

}

static PyObject *

utf32_encode(textio *self, PyObject *text)

{

if (!self->encoding_start_of_stream) {

/* Skip the BOM and use native byte ordering */

#if PY_BIG_ENDIAN

return utf32be_encode(self, text);

#else

return utf32le_encode(self, text);

#endif

}

return _PyUnicode_EncodeUTF32(text,

PyBytes_AS_STRING(self->errors), 0);

}

static PyObject *

utf8_encode(textio *self, PyObject *text)

{

return _PyUnicode_AsUTF8String(text, PyBytes_AS_STRING(self->errors));

}

static PyObject *

latin1_encode(textio *self, PyObject *text)

{

return _PyUnicode_AsLatin1String(text, PyBytes_AS_STRING(self->errors));

}

/* Map normalized encoding names onto the specialized encoding funcs */

typedef struct {

const char *name;

encodefunc_t encodefunc;

} encodefuncentry;

static const encodefuncentry encodefuncs[] = {

{"ascii", (encodefunc_t) ascii_encode},

{"iso8859-1", (encodefunc_t) latin1_encode},

{"utf-8", (encodefunc_t) utf8_encode},

{"utf-16-be", (encodefunc_t) utf16be_encode},

{"utf-16-le", (encodefunc_t) utf16le_encode},

{"utf-16", (encodefunc_t) utf16_encode},

{"utf-32-be", (encodefunc_t) utf32be_encode},

{"utf-32-le", (encodefunc_t) utf32le_encode},

{"utf-32", (encodefunc_t) utf32_encode},

{NULL, NULL}

};

/*[clinic input]

_io.TextIOWrapper.__init__

buffer: object

encoding: str(accept={str, NoneType}) = NULL

errors: str(accept={str, NoneType}) = NULL

newline: str(accept={str, NoneType}) = NULL

line_buffering: int(c_default="0") = False

write_through: int(c_default="0") = False

Character and line based layer over a BufferedIOBase object, buffer.

encoding gives the name of the encoding that the stream will be

decoded or encoded with. It defaults to locale.getpreferredencoding(False).

errors determines the strictness of encoding and decoding (see

help(codecs.Codec) or the documentation for codecs.register) and

defaults to "strict".

newline controls how line endings are handled. It can be None, '',

'\n', '\r', and '\r\n'. It works as follows:

* On input, if newline is None, universal newlines mode is

enabled. Lines in the input can end in '\n', '\r', or '\r\n', and

these are translated into '\n' before being returned to the

caller. If it is '', universal newline mode is enabled, but line

endings are returned to the caller untranslated. If it has any of

the other legal values, input lines are only terminated by the given

string, and the line ending is returned to the caller untranslated.

* On output, if newline is None, any '\n' characters written are

translated to the system default line separator, os.linesep. If

newline is '' or '\n', no translation takes place. If newline is any

of the other legal values, any '\n' characters written are translated

to the given string.

If line_buffering is True, a call to flush is implied when a call to

write contains a newline character.

[clinic start generated code]*/

static int

_io_TextIOWrapper___init___impl(textio *self, PyObject *buffer,

const char *encoding, const char *errors,

const char *newline, int line_buffering,

int write_through)

/*[clinic end generated code: output=56a83402ce2a8381 input=3126cb3101a2c99b]*/

{

PyObject *raw, *codec_info = NULL;

_PyIO_State *state = NULL;

PyObject *res;

int r;

self->ok = 0;

self->detached = 0;

if (newline && newline[0] != '\0'

&& !(newline[0] == '\n' && newline[1] == '\0')

&& !(newline[0] == '\r' && newline[1] == '\0')

&& !(newline[0] == '\r' && newline[1] == '\n' && newline[2] == '\0')) {

PyErr_Format(PyExc_ValueError,

"illegal newline value: %s", newline);

return -1;

}

Py_CLEAR(self->buffer);

Py_CLEAR(self->encoding);

Py_CLEAR(self->encoder);

Py_CLEAR(self->decoder);

Py_CLEAR(self->readnl);

Py_CLEAR(self->decoded_chars);

Py_CLEAR(self->pending_bytes);

Py_CLEAR(self->snapshot);

Py_CLEAR(self->errors);

Py_CLEAR(self->raw);

self->decoded_chars_used = 0;

self->pending_bytes_count = 0;

self->encodefunc = NULL;

self->b2cratio = 0.0;

if (encoding == NULL) {

/* Try os.device_encoding(fileno) */

PyObject *fileno;

state = IO_STATE();

if (state == NULL)

goto error;

fileno = _PyObject_CallMethodId(buffer, &PyId_fileno, NULL);

/* Ignore only AttributeError and UnsupportedOperation */

if (fileno == NULL) {

if (PyErr_ExceptionMatches(PyExc_AttributeError) ||

PyErr_ExceptionMatches(state->unsupported_operation)) {

PyErr_Clear();

}

else {

goto error;

}

}

else {

int fd = _PyLong_AsInt(fileno);

Py_DECREF(fileno);

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

goto error;

}

self->encoding = _Py_device_encoding(fd);

if (self->encoding == NULL)

goto error;

else if (!PyUnicode_Check(self->encoding))

Py_CLEAR(self->encoding);

}

}

if (encoding == NULL && self->encoding == NULL) {

PyObject *locale_module = _PyIO_get_locale_module(state);

if (locale_module == NULL)

goto catch_ImportError;

self->encoding = _PyObject_CallMethodId(

locale_module, &PyId_getpreferredencoding, "O", Py_False);

Py_DECREF(locale_module);

if (self->encoding == NULL) {

catch_ImportError:

/*

Importing locale can raise an ImportError because of

_functools, and locale.getpreferredencoding can raise an

ImportError if _locale is not available. These will happen

during module building.

*/

if (PyErr_ExceptionMatches(PyExc_ImportError)) {

PyErr_Clear();

self->encoding = PyUnicode_FromString("ascii");

}

else

goto error;

}

else if (!PyUnicode_Check(self->encoding))

Py_CLEAR(self->encoding);

}

if (self->encoding != NULL) {

encoding = PyUnicode_AsUTF8(self->encoding);

if (encoding == NULL)

goto error;

}

else if (encoding != NULL) {

self->encoding = PyUnicode_FromString(encoding);

if (self->encoding == NULL)

goto error;

}

else {

PyErr_SetString(PyExc_IOError,

"could not determine default encoding");

}

/* Check we have been asked for a real text encoding */

codec_info = _PyCodec_LookupTextEncoding(encoding, "codecs.open()");

if (codec_info == NULL) {

Py_CLEAR(self->encoding);

goto error;

}

/* XXX: Failures beyond this point have the potential to leak elements

* of the partially constructed object (like self->encoding)

*/

if (errors == NULL)

errors = "strict";

self->errors = PyBytes_FromString(errors);

if (self->errors == NULL)

goto error;

self->chunk_size = 8192;

self->readuniversal = (newline == NULL || newline[0] == '\0');

self->line_buffering = line_buffering;

self->write_through = write_through;

self->readtranslate = (newline == NULL);

if (newline) {

self->readnl = PyUnicode_FromString(newline);

if (self->readnl == NULL)

goto error;

}

self->writetranslate = (newline == NULL || newline[0] != '\0');

if (!self->readuniversal && self->readnl) {

self->writenl = PyUnicode_AsUTF8(self->readnl);

if (self->writenl == NULL)

goto error;

if (!strcmp(self->writenl, "\n"))

self->writenl = NULL;

}

#ifdef MS_WINDOWS

else

self->writenl = "\r\n";

#endif

/* Build the decoder object */

res = _PyObject_CallMethodId(buffer, &PyId_readable, NULL);

if (res == NULL)

goto error;

r = PyObject_IsTrue(res);

Py_DECREF(res);

if (r == -1)

goto error;

if (r == 1) {

self->decoder = _PyCodecInfo_GetIncrementalDecoder(codec_info,

errors);

if (self->decoder == NULL)

goto error;

if (self->readuniversal) {

PyObject *incrementalDecoder = PyObject_CallFunction(

(PyObject *)&PyIncrementalNewlineDecoder_Type,

"Oi", self->decoder, (int)self->readtranslate);

if (incrementalDecoder == NULL)

goto error;

Py_XSETREF(self->decoder, incrementalDecoder);

}

}