/* File object implementation (what's left of it -- see io.py) */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#include "pycore_pystate.h"

#if defined(HAVE_GETC_UNLOCKED) && !defined(_Py_MEMORY_SANITIZER)
/* clang MemorySanitizer doesn't yet understand getc_unlocked. */
#define GETC(f) getc_unlocked(f)
#define FLOCKFILE(f) flockfile(f)
#define FUNLOCKFILE(f) funlockfile(f)
#else
#define GETC(f) getc(f)
#define FLOCKFILE(f)
#define FUNLOCKFILE(f)
#endif

/* Newline flags */
#define NEWLINE_UNKNOWN 0 /* No newline seen, yet */
#define NEWLINE_CR 1 /* \r newline seen */
#define NEWLINE_LF 2 /* \n newline seen */
#define NEWLINE_CRLF 4 /* \r\n newline seen */

#ifdef __cplusplus
extern "C" {
#endif

/* External C interface */

PyObject *
PyFile_FromFd(int fd, const char *name, const char *mode, int buffering, const char *encoding,
 const char *errors, const char *newline, int closefd)
{
 PyObject *io, *stream;
 _Py_IDENTIFIER(open);

 /* import _io in case we are being used to open io.py */
 io = PyImport_ImportModule("_io");
 if (io == NULL)
 return NULL;
 stream = _PyObject_CallMethodId(io, &PyId_open, "isisssi", fd, mode,
 buffering, encoding, errors,
 newline, closefd);
 Py_DECREF(io);
 if (stream == NULL)
 return NULL;
 /* ignore name attribute because the name attribute of _BufferedIOMixin
 and TextIOWrapper is read only */
 return stream;
}

PyObject *
PyFile_GetLine(PyObject *f, int n)
{
 _Py_IDENTIFIER(readline);
 PyObject *result;

 if (f == NULL) {
 PyErr_BadInternalCall();
 return NULL;
 }

 if (n <= 0) {
 result = _PyObject_CallMethodIdObjArgs(f, &PyId_readline, NULL);
 }
 else {
 result = _PyObject_CallMethodId(f, &PyId_readline, "i", n);
 }
 if (result != NULL && !PyBytes_Check(result) &&
 !PyUnicode_Check(result)) {
 Py_DECREF(result);
 result = NULL;
 PyErr_SetString(PyExc_TypeError,
 "object.readline() returned non-string");
 }

 if (n < 0 && result != NULL && PyBytes_Check(result)) {
 char *s = PyBytes_AS_STRING(result);
 Py_ssize_t len = PyBytes_GET_SIZE(result);
 if (len == 0) {
 Py_DECREF(result);
 result = NULL;
 PyErr_SetString(PyExc_EOFError,
 "EOF when reading a line");
 }
 else if (s[len-1] == '\n') {
 if (result->ob_refcnt == 1)
 _PyBytes_Resize(&result, len-1);
 else {
 PyObject *v;
 v = PyBytes_FromStringAndSize(s, len-1);
 Py_DECREF(result);
 result = v;
 }
 }
 }
 if (n < 0 && result != NULL && PyUnicode_Check(result)) {
 Py_ssize_t len = PyUnicode_GET_LENGTH(result);
 if (len == 0) {
 Py_DECREF(result);
 result = NULL;
 PyErr_SetString(PyExc_EOFError,
 "EOF when reading a line");
 }
 else if (PyUnicode_READ_CHAR(result, len-1) == '\n') {
 PyObject *v;
 v = PyUnicode_Substring(result, 0, len-1);
 Py_DECREF(result);
 result = v;
 }
 }
 return result;
}

/* Interfaces to write objects/strings to file-like objects */

int
PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
{
 PyObject *writer, *value, *result;
 _Py_IDENTIFIER(write);

 if (f == NULL) {
 PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
 return -1;
 }
 writer = _PyObject_GetAttrId(f, &PyId_write);
 if (writer == NULL)
 return -1;
 if (flags & Py_PRINT_RAW) {
 value = PyObject_Str(v);
 }
 else
 value = PyObject_Repr(v);
 if (value == NULL) {
 Py_DECREF(writer);
 return -1;
 }
 result = PyObject_CallFunctionObjArgs(writer, value, NULL);
 Py_DECREF(value);
 Py_DECREF(writer);
 if (result == NULL)
 return -1;
 Py_DECREF(result);
 return 0;
}

int
PyFile_WriteString(const char *s, PyObject *f)
{
 if (f == NULL) {
 /* Should be caused by a pre-existing error */
 if (!PyErr_Occurred())
 PyErr_SetString(PyExc_SystemError,
 "null file for PyFile_WriteString");
 return -1;
 }
 else if (!PyErr_Occurred()) {
 PyObject *v = PyUnicode_FromString(s);
 int err;
 if (v == NULL)
 return -1;
 err = PyFile_WriteObject(v, f, Py_PRINT_RAW);
 Py_DECREF(v);
 return err;
 }
 else
 return -1;
}

/* Try to get a file-descriptor from a Python object. If the object
 is an integer, its value is returned. If not, the
 object's fileno() method is called if it exists; the method must return
 an integer, which is returned as the file descriptor value.
 -1 is returned on failure.
*/

int
PyObject_AsFileDescriptor(PyObject *o)
{
 int fd;
 PyObject *meth;
 _Py_IDENTIFIER(fileno);

 if (PyLong_Check(o)) {
 fd = _PyLong_AsInt(o);
 }
 else if (_PyObject_LookupAttrId(o, &PyId_fileno, &meth) < 0) {
 return -1;
 }
 else if (meth != NULL) {
 PyObject *fno = _PyObject_CallNoArg(meth);
 Py_DECREF(meth);
 if (fno == NULL)
 return -1;

 if (PyLong_Check(fno)) {
 fd = _PyLong_AsInt(fno);
 Py_DECREF(fno);
 }
 else {
 PyErr_SetString(PyExc_TypeError,
 "fileno() returned a non-integer");
 Py_DECREF(fno);
 return -1;
 }
 }
 else {
 PyErr_SetString(PyExc_TypeError,
 "argument must be an int, or have a fileno() method.");
 return -1;
 }

 if (fd == -1 && PyErr_Occurred())
 return -1;
 if (fd < 0) {
 PyErr_Format(PyExc_ValueError,
 "file descriptor cannot be a negative integer (%i)",
 fd);
 return -1;
 }
 return fd;
}

/*
** Py_UniversalNewlineFgets is an fgets variation that understands
** all of \r, \n and \r\n conventions.
** The stream should be opened in binary mode.
** If fobj is NULL the routine always does newline conversion, and
** it may peek one char ahead to gobble the second char in \r\n.
** If fobj is non-NULL it must be a PyFileObject. In this case there
** is no readahead but in stead a flag is used to skip a following
** \n on the next read. Also, if the file is open in binary mode
** the whole conversion is skipped. Finally, the routine keeps track of
** the different types of newlines seen.
** Note that we need no error handling: fgets() treats error and eof
** identically.
*/
char *
Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
{
 char *p = buf;
 int c;
 int newlinetypes = 0;
 int skipnextlf = 0;

 if (fobj) {
 errno = ENXIO; /* What can you do... */
 return NULL;
 }
 FLOCKFILE(stream);
 c = 'x'; /* Shut up gcc warning */
 while (--n > 0 && (c = GETC(stream)) != EOF ) {
 if (skipnextlf ) {
 skipnextlf = 0;
 if (c == '\n') {
 /* Seeing a \n here with skipnextlf true
 ** means we saw a \r before.
 */
 newlinetypes |= NEWLINE_CRLF;
 c = GETC(stream);
 if (c == EOF) break;
 } else {
 /*
 ** Note that c == EOF also brings us here,
 ** so we're okay if the last char in the file
 ** is a CR.
 */
 newlinetypes |= NEWLINE_CR;
 }
 }
 if (c == '\r') {
 /* A \r is translated into a \n, and we skip
 ** an adjacent \n, if any. We don't set the
 ** newlinetypes flag until we've seen the next char.
 */
 skipnextlf = 1;
 c = '\n';
 } else if ( c == '\n') {
 newlinetypes |= NEWLINE_LF;
 }
 *p++ = c;
 if (c == '\n') break;
 }
 /* if ( c == EOF && skipnextlf )
 newlinetypes |= NEWLINE_CR; */
 FUNLOCKFILE(stream);
 *p = '0円';
 if ( skipnextlf ) {
 /* If we have no file object we cannot save the
 ** skipnextlf flag. We have to readahead, which
 ** will cause a pause if we're reading from an
 ** interactive stream, but that is very unlikely
 ** unless we're doing something silly like
 ** exec(open("/dev/tty").read()).
 */
 c = GETC(stream);
 if ( c != '\n' )
 ungetc(c, stream);
 }
 if (p == buf)
 return NULL;
 return buf;
}

/* **************************** std printer ****************************
 * The stdprinter is used during the boot strapping phase as a preliminary
 * file like object for sys.stderr.
 */

typedef struct {
 PyObject_HEAD
 int fd;
} PyStdPrinter_Object;

static PyObject *
stdprinter_new(PyTypeObject *type, PyObject *args, PyObject *kews)
{
 PyStdPrinter_Object *self;

 assert(type != NULL && type->tp_alloc != NULL);

 self = (PyStdPrinter_Object *) type->tp_alloc(type, 0);
 if (self != NULL) {
 self->fd = -1;
 }

 return (PyObject *) self;
}

static int
stdprinter_init(PyObject *self, PyObject *args, PyObject *kwds)
{
 PyErr_SetString(PyExc_TypeError,
 "cannot create 'stderrprinter' instances");
 return -1;
}

PyObject *
PyFile_NewStdPrinter(int fd)
{
 PyStdPrinter_Object *self;

 if (fd != fileno(stdout) && fd != fileno(stderr)) {
 /* not enough infrastructure for PyErr_BadInternalCall() */
 return NULL;
 }

 self = PyObject_New(PyStdPrinter_Object,
 &PyStdPrinter_Type);
 if (self != NULL) {
 self->fd = fd;
 }
 return (PyObject*)self;
}

static PyObject *
stdprinter_write(PyStdPrinter_Object *self, PyObject *args)
{
 PyObject *unicode;
 PyObject *bytes = NULL;
 const char *str;
 Py_ssize_t n;
 int err;

 /* The function can clear the current exception */
 assert(!PyErr_Occurred());

 if (self->fd < 0) {
 /* fd might be invalid on Windows
 * I can't raise an exception here. It may lead to an
 * unlimited recursion in the case stderr is invalid.
 */
 Py_RETURN_NONE;
 }

 if (!PyArg_ParseTuple(args, "U", &unicode)) {
 return NULL;
 }

 /* Encode Unicode to UTF-8/surrogateescape */
 str = PyUnicode_AsUTF8AndSize(unicode, &n);
 if (str == NULL) {
 PyErr_Clear();
 bytes = _PyUnicode_AsUTF8String(unicode, "backslashreplace");
 if (bytes == NULL)
 return NULL;
 str = PyBytes_AS_STRING(bytes);
 n = PyBytes_GET_SIZE(bytes);
 }

 n = _Py_write(self->fd, str, n);
 /* save errno, it can be modified indirectly by Py_XDECREF() */
 err = errno;

 Py_XDECREF(bytes);

 if (n == -1) {
 if (err == EAGAIN) {
 PyErr_Clear();
 Py_RETURN_NONE;
 }
 return NULL;
 }

 return PyLong_FromSsize_t(n);
}

static PyObject *
stdprinter_fileno(PyStdPrinter_Object *self, PyObject *Py_UNUSED(ignored))
{
 return PyLong_FromLong((long) self->fd);
}

static PyObject *
stdprinter_repr(PyStdPrinter_Object *self)
{
 return PyUnicode_FromFormat("<stdprinter(fd=%d) object at %p>",
 self->fd, self);
}

static PyObject *
stdprinter_noop(PyStdPrinter_Object *self, PyObject *Py_UNUSED(ignored))
{
 Py_RETURN_NONE;
}

static PyObject *
stdprinter_isatty(PyStdPrinter_Object *self, PyObject *Py_UNUSED(ignored))
{
 long res;
 if (self->fd < 0) {
 Py_RETURN_FALSE;
 }

 Py_BEGIN_ALLOW_THREADS
 res = isatty(self->fd);
 Py_END_ALLOW_THREADS

 return PyBool_FromLong(res);
}

static PyMethodDef stdprinter_methods[] = {
 {"close", (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
 {"flush", (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
 {"fileno", (PyCFunction)stdprinter_fileno, METH_NOARGS, ""},
 {"isatty", (PyCFunction)stdprinter_isatty, METH_NOARGS, ""},
 {"write", (PyCFunction)stdprinter_write, METH_VARARGS, ""},
 {NULL, NULL} /*sentinel */
};

static PyObject *
get_closed(PyStdPrinter_Object *self, void *closure)
{
 Py_RETURN_FALSE;
}

static PyObject *
get_mode(PyStdPrinter_Object *self, void *closure)
{
 return PyUnicode_FromString("w");
}

static PyObject *
get_encoding(PyStdPrinter_Object *self, void *closure)
{
 Py_RETURN_NONE;
}

static PyGetSetDef stdprinter_getsetlist[] = {
 {"closed", (getter)get_closed, NULL, "True if the file is closed"},
 {"encoding", (getter)get_encoding, NULL, "Encoding of the file"},
 {"mode", (getter)get_mode, NULL, "String giving the file mode"},
 {0},
};

PyTypeObject PyStdPrinter_Type = {
 PyVarObject_HEAD_INIT(&PyType_Type, 0)
 "stderrprinter", /* tp_name */
 sizeof(PyStdPrinter_Object), /* tp_basicsize */
 0, /* tp_itemsize */
 /* methods */
 0, /* tp_dealloc */
 0, /* tp_vectorcall_offset */
 0, /* tp_getattr */
 0, /* tp_setattr */
 0, /* tp_as_async */
 (reprfunc)stdprinter_repr, /* 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_iternext */
 stdprinter_methods, /* tp_methods */
 0, /* tp_members */
 stdprinter_getsetlist, /* tp_getset */
 0, /* tp_base */
 0, /* tp_dict */
 0, /* tp_descr_get */
 0, /* tp_descr_set */
 0, /* tp_dictoffset */
 stdprinter_init, /* tp_init */
 PyType_GenericAlloc, /* tp_alloc */
 stdprinter_new, /* tp_new */
 PyObject_Del, /* tp_free */
};


/* ************************** open_code hook ***************************
 * The open_code hook allows embedders to override the method used to
 * open files that are going to be used by the runtime to execute code
 */

int
PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData) {
 if (Py_IsInitialized() &&
 PySys_Audit("setopencodehook", NULL) < 0) {
 return -1;
 }

 if (_PyRuntime.open_code_hook) {
 if (Py_IsInitialized()) {
 PyErr_SetString(PyExc_SystemError,
 "failed to change existing open_code hook");
 }
 return -1;
 }

 _PyRuntime.open_code_hook = hook;
 _PyRuntime.open_code_userdata = userData;
 return 0;
}

PyObject *
PyFile_OpenCodeObject(PyObject *path)
{
 PyObject *iomod, *f = NULL;
 _Py_IDENTIFIER(open);

 if (!PyUnicode_Check(path)) {
 PyErr_Format(PyExc_TypeError, "'path' must be 'str', not '%.200s'",
 Py_TYPE(path)->tp_name);
 return NULL;
 }

 Py_OpenCodeHookFunction hook = _PyRuntime.open_code_hook;
 if (hook) {
 f = hook(path, _PyRuntime.open_code_userdata);
 } else {
 iomod = PyImport_ImportModule("_io");
 if (iomod) {
 f = _PyObject_CallMethodId(iomod, &PyId_open, "Os",
 path, "rb");
 Py_DECREF(iomod);
 }
 }

 return f;
}

PyObject *
PyFile_OpenCode(const char *utf8path)
{
 PyObject *pathobj = PyUnicode_FromString(utf8path);
 PyObject *f;
 if (!pathobj) {
 return NULL;
 }
 f = PyFile_OpenCodeObject(pathobj);
 Py_DECREF(pathobj);
 return f;
}


#ifdef __cplusplus
}
#endif