let ctx = &vm.ctx;

let module = _io::make_module(vm);

#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]

fileio::extend_module(vm, &module);

let unsupported_operation = _io::UNSUPPORTED_OPERATION

.get_or_init(|| _io::make_unsupportedop(ctx))

.clone();

extend_module!(vm, module, {

"UnsupportedOperation" => unsupported_operation,

"BlockingIOError" => ctx.exceptions.blocking_io_error.clone(),

});

module

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

use crate::builtins::int;

let int = match obj.downcast::<int::PyInt>() {

Ok(i) => i,

Err(obj) => {

let fileno_meth = vm.get_attribute_opt(obj, "fileno")?.ok_or_else(|| {

vm.new_type_error(

"argument must be an int, or have a fileno() method.".to_owned(),

)

})?;

vm.invoke(&fileno_meth, ())?

.downcast()

.map_err(|_| vm.new_type_error("fileno() returned a non-integer".to_owned()))?

}

};

let fd = int::try_to_primitive(int.as_bigint(), vm)?;

if fd < 0 {

return Err(vm.new_value_error(format!(

"file descriptor cannot be a negative integer ({})",

fd

)));

}

Ok(Fildes(fd))

}

use super::*;

use bstr::ByteSlice;

use crossbeam_utils::atomic::AtomicCell;

use num_traits::ToPrimitive;

use std::io::{self, prelude::*, Cursor, SeekFrom};

use std::ops::Range;

use crate::buffer::{BufferOptions, PyBuffer, PyBufferInternal, ResizeGuard};

use crate::builtins::memory::PyMemoryView;

use crate::builtins::{

bytes::{PyBytes, PyBytesRef},

pybool, pytype, PyByteArray, PyStr, PyStrRef, PyTypeRef,

};

use crate::byteslike::{ArgBytesLike, ArgMemoryBuffer};

use crate::common::borrow::{BorrowedValue, BorrowedValueMut};

use crate::common::lock::{

PyMappedThreadMutexGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,

PyThreadMutex, PyThreadMutexGuard,

};

use crate::common::rc::PyRc;

use crate::exceptions::{self, IntoPyException, PyBaseExceptionRef};

use crate::function::{FuncArgs, OptionalArg, OptionalOption};

use crate::slots::SlotConstructor;

use crate::utils::Either;

use crate::vm::{ReprGuard, VirtualMachine};

use crate::{

IdProtocol, IntoPyObject, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue,

StaticType, TryFromObject, TypeProtocol,

};

#[allow(clippy::let_and_return)]

fn validate_whence(whence: i32) -> bool {

let x = (0..=2).contains(&whence);

cfg_if::cfg_if! {

if #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "linux"))] {

x || matches!(whence, libc::SEEK_DATA | libc::SEEK_HOLE)

} else {

x

}

}

}

fn ensure_unclosed(file: &PyObjectRef, msg: &str, vm: &VirtualMachine) -> PyResult<()> {

if pybool::boolval(vm, vm.get_attribute(file.clone(), "closed")?)? {

Err(vm.new_value_error(msg.to_owned()))

} else {

Ok(())

}

}

pub fn new_unsupported_operation(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {

vm.new_exception_msg(UNSUPPORTED_OPERATION.get().unwrap().clone(), msg)

}

fn _unsupported<T>(vm: &VirtualMachine, zelf: &PyObjectRef, operation: &str) -> PyResult<T> {

Err(new_unsupported_operation(

vm,

format!("{}.{}() not supported", zelf.class().name(), operation),

))

}

#[derive(FromArgs)]

pub(super) struct OptionalSize {

// In a few functions, the default value is -1 rather than None.

// Make sure the default value doesn't affect compatibility.

#[pyarg(positional, default)]

size: Option<isize>,

}

impl OptionalSize {

pub fn to_usize(self) -> Option<usize> {

self.size.and_then(|v| v.to_usize())

}

pub fn try_usize(self, vm: &VirtualMachine) -> PyResult<Option<usize>> {

self.size

.map(|v| {

if v >= 0 {

Ok(v as usize)

} else {

Err(vm.new_value_error(format!("Negative size value {}", v)))

}

})

.transpose()

}

}

fn os_err(vm: &VirtualMachine, err: io::Error) -> PyBaseExceptionRef {

#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]

{

err.into_pyexception(vm)

}

#[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]

{

vm.new_os_error(err.to_string())

}

}

pub(super) fn io_closed_error(vm: &VirtualMachine) -> PyBaseExceptionRef {

vm.new_value_error("I/O operation on closed file".to_owned())

}

#[pyattr]

const DEFAULT_BUFFER_SIZE: usize = 8 * 1024;

pub(super) fn seekfrom(

vm: &VirtualMachine,

offset: PyObjectRef,

how: OptionalArg<i32>,

) -> PyResult<SeekFrom> {

let seek = match how {

OptionalArg::Present(0) | OptionalArg::Missing => {

SeekFrom::Start(u64::try_from_object(vm, offset)?)

}

OptionalArg::Present(1) => SeekFrom::Current(i64::try_from_object(vm, offset)?),

OptionalArg::Present(2) => SeekFrom::End(i64::try_from_object(vm, offset)?),

_ => return Err(vm.new_value_error("invalid value for how".to_owned())),

};

Ok(seek)

}

#[derive(Debug)]

struct BufferedIO {

cursor: Cursor<Vec<u8>>,

}

impl BufferedIO {

fn new(cursor: Cursor<Vec<u8>>) -> BufferedIO {

BufferedIO { cursor }

}

fn write(&mut self, data: &[u8]) -> Option<u64> {

let length = data.len();

match self.cursor.write_all(data) {

Ok(_) => Some(length as u64),

Err(_) => None,

}

}

//return the entire contents of the underlying

fn getvalue(&self) -> Vec<u8> {

self.cursor.clone().into_inner()

}

//skip to the jth position

fn seek(&mut self, seek: SeekFrom) -> io::Result<u64> {

self.cursor.seek(seek)

}

//Read k bytes from the object and return.

fn read(&mut self, bytes: Option<usize>) -> Option<Vec<u8>> {

let pos = self.cursor.position().to_usize()?;

let avail_slice = self.cursor.get_ref().get(pos..)?;

// if we don't specify the number of bytes, or it's too big, give the whole rest of the slice

let n = bytes.map_or_else(

|| avail_slice.len(),

|n| std::cmp::min(n, avail_slice.len()),

);

let b = avail_slice[..n].to_vec();

self.cursor.set_position((pos + n) as u64);

Some(b)

}

fn tell(&self) -> u64 {

self.cursor.position()

}

fn readline(&mut self, size: Option<usize>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {

self.read_until(size, b'\n', vm)

}

fn read_until(

&mut self,

size: Option<usize>,

byte: u8,

vm: &VirtualMachine,

) -> PyResult<Vec<u8>> {

let size = match size {

None => {

let mut buf: Vec<u8> = Vec::new();

self.cursor

.read_until(byte, &mut buf)

.map_err(|err| os_err(vm, err))?;

return Ok(buf);

}

Some(0) => {

return Ok(Vec::new());

}

Some(size) => size,

};

let available = {

// For Cursor, fill_buf returns all of the remaining data unlike other BufReads which have outer reading source.

// Unless we add other data by write, there will be no more data.

let buf = self.cursor.fill_buf().map_err(|err| os_err(vm, err))?;

if size < buf.len() {

&buf[..size]

} else {

buf

}

};

let buf = match available.find_byte(byte) {

Some(i) => (available[..=i].to_vec()),

_ => (available.to_vec()),

};

self.cursor.consume(buf.len());

Ok(buf)

}

fn truncate(&mut self, pos: Option<usize>) -> usize {

let pos = pos.unwrap_or_else(|| self.tell() as usize);

self.cursor.get_mut().truncate(pos);

pos

}

}

fn file_closed(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {

pybool::boolval(vm, vm.get_attribute(file.clone(), "closed")?)

}

fn check_closed(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

if file_closed(file, vm)? {

Err(io_closed_error(vm))

} else {

Ok(())

}

}

fn check_readable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

if pybool::boolval(vm, vm.call_method(file, "readable", ())?)? {

Ok(())

} else {

Err(new_unsupported_operation(

vm,

"File or stream is not readable".to_owned(),

))

}

}

fn check_writable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

if pybool::boolval(vm, vm.call_method(file, "writable", ())?)? {

Ok(())

} else {

Err(new_unsupported_operation(

vm,

"File or stream is not writable.".to_owned(),

))

}

}

fn check_seekable(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

if pybool::boolval(vm, vm.call_method(file, "seekable", ())?)? {

Ok(())

} else {

Err(new_unsupported_operation(

vm,

"File or stream is not seekable".to_owned(),

))

}

}

fn check_decoded(decoded: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {

decoded.downcast().map_err(|obj| {

vm.new_type_error(format!(

"decoder should return a string result, not '{}'",

obj.class().name()

))

})

}

#[pyattr]

#[pyclass(name = "_IOBase")]

struct _IOBase;

#[pyimpl(flags(BASETYPE, HAS_DICT))]

impl _IOBase {

#[pymethod]

fn seek(

zelf: PyObjectRef,

_pos: PyObjectRef,

_whence: OptionalArg,

vm: &VirtualMachine,

) -> PyResult {

_unsupported(vm, &zelf, "seek")

}

#[pymethod]

fn tell(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {

vm.call_method(&zelf, "seek", (0, 1))

}

#[pymethod]

fn truncate(zelf: PyObjectRef, _pos: OptionalArg, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "truncate")

}

#[pymethod]

fn fileno(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "truncate")

}

#[pyattr]

fn __closed(ctx: &PyContext) -> PyObjectRef {

ctx.new_bool(false)

}

#[pymethod(magic)]

fn enter(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult {

check_closed(&instance, vm)?;

Ok(instance)

}

#[pyslot]

fn tp_del(instance: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

let _ = vm.call_method(instance, "close", ());

Ok(())

}

#[pymethod(magic)]

fn del(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

Self::tp_del(&instance, vm)

}

#[pymethod(magic)]

fn exit(instance: PyObjectRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {

vm.call_method(&instance, "close", ())?;

Ok(())

}

#[pymethod]

fn flush(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

// just check if this is closed; if it isn't, do nothing

check_closed(&instance, vm)

}

#[pymethod]

fn seekable(_self: PyObjectRef) -> bool {

false

}

#[pymethod]

fn readable(_self: PyObjectRef) -> bool {

false

}

#[pymethod]

fn writable(_self: PyObjectRef) -> bool {

false

}

#[pymethod]

fn isatty(_self: PyObjectRef) -> bool {

false

}

#[pyproperty]

fn closed(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult {

vm.get_attribute(instance, "__closed")

}

#[pymethod]

fn close(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

iobase_close(&instance, vm)

}

#[pymethod]

fn readline(

instance: PyObjectRef,

size: OptionalSize,

vm: &VirtualMachine,

) -> PyResult<Vec<u8>> {

let size = size.to_usize();

let read = vm.get_attribute(instance, "read")?;

let mut res = Vec::new();

while size.map_or(true, |s| res.len() < s) {

let read_res = ArgBytesLike::try_from_object(vm, vm.invoke(&read, (1,))?)?;

if read_res.with_ref(|b| b.is_empty()) {

break;

}

read_res.with_ref(|b| res.extend_from_slice(b));

if res.ends_with(b"\n") {

break;

}

}

Ok(res)

}

#[pymethod]

fn readlines(

instance: PyObjectRef,

hint: OptionalOption<isize>,

vm: &VirtualMachine,

) -> PyResult {

let hint = hint.flatten().unwrap_or(-1);

if hint <= 0 {

return Ok(vm.ctx.new_list(vm.extract_elements(&instance)?));

}

let hint = hint as usize;

let mut ret = Vec::new();

let it = PyIterable::try_from_object(vm, instance)?;

let mut full_len = 0;

for line in it.iter(vm)? {

let line = line?;

let line_len = vm.obj_len(&line)?;

ret.push(line.clone());

full_len += line_len;

if full_len > hint {

break;

}

}

Ok(vm.ctx.new_list(ret))

}

#[pymethod]

fn writelines(

instance: PyObjectRef,

lines: PyIterable,

vm: &VirtualMachine,

) -> PyResult<()> {

check_closed(&instance, vm)?;

for line in lines.iter(vm)? {

vm.call_method(&instance, "write", (line?,))?;

}

Ok(())

}

#[pymethod(name = "_checkClosed")]

fn check_closed(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

check_closed(&instance, vm)

}

#[pymethod(name = "_checkReadable")]

fn check_readable(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

check_readable(&instance, vm)

}

#[pymethod(name = "_checkWritable")]

fn check_writable(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

check_writable(&instance, vm)

}

#[pymethod(name = "_checkSeekable")]

fn check_seekable(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

check_seekable(&instance, vm)

}

#[pyslot]

#[pymethod(name = "__iter__")]

fn tp_iter(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult {

check_closed(&instance, vm)?;

Ok(instance)

}

#[pyslot]

fn tp_iternext(instance: &PyObjectRef, vm: &VirtualMachine) -> PyResult {

let line = vm.call_method(instance, "readline", ())?;

if !pybool::boolval(vm, line.clone())? {

Err(vm.new_stop_iteration())

} else {

Ok(line)

}

}

#[pymethod(magic)]

fn next(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult {

Self::tp_iternext(&instance, vm)

}

}

pub(super) fn iobase_close(file: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {

if !file_closed(file, vm)? {

let res = vm.call_method(file, "flush", ());

vm.set_attr(file, "__closed", vm.ctx.new_bool(true))?;

res?;

}

Ok(())

}

#[pyattr]

#[pyclass(name = "_RawIOBase", base = "_IOBase")]

pub(super) struct _RawIOBase;

#[pyimpl(flags(BASETYPE, HAS_DICT))]

impl _RawIOBase {

#[pymethod]

fn read(instance: PyObjectRef, size: OptionalSize, vm: &VirtualMachine) -> PyResult {

if let Some(size) = size.to_usize() {

// FIXME: unnecessary zero-init

let b = PyByteArray::from(vec![0; size]).into_ref(vm);

let n = <Option<usize>>::try_from_object(

vm,

vm.call_method(&instance, "readinto", (b.clone(),))?,

)?;

Ok(n.map(|n| {

let mut bytes = b.borrow_buf_mut();

bytes.truncate(n);

// FIXME: try to use Arc::unwrap on the bytearray to get at the inner buffer

bytes.clone()

})

.into_pyobject(vm))

} else {

vm.call_method(&instance, "readall", ())

}

}

#[pymethod]

fn readall(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<Option<Vec<u8>>> {

let mut chunks = Vec::new();

let mut total_len = 0;

loop {

let data = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,))?;

let data = <Option<PyBytesRef>>::try_from_object(vm, data)?;

match data {

None => {

if chunks.is_empty() {

return Ok(None);

}

break;

}

Some(b) => {

if b.as_bytes().is_empty() {

break;

}

total_len += b.as_bytes().len();

chunks.push(b)

}

}

}

let mut ret = Vec::with_capacity(total_len);

for b in chunks {

ret.extend_from_slice(b.as_bytes())

}

Ok(Some(ret))

}

}

#[pyattr]

#[pyclass(name = "_BufferedIOBase", base = "_IOBase")]

struct _BufferedIOBase;

#[pyimpl(flags(BASETYPE))]

impl _BufferedIOBase {

#[pymethod]

fn read(zelf: PyObjectRef, _size: OptionalArg, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "read")

}

#[pymethod]

fn read1(zelf: PyObjectRef, _size: OptionalArg, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "read1")

}

fn _readinto(

zelf: PyObjectRef,

bufobj: PyObjectRef,

method: &str,

vm: &VirtualMachine,

) -> PyResult<usize> {

let b = ArgMemoryBuffer::new(vm, &bufobj)?;

let l = b.len();

let data = vm.call_method(&zelf, method, (l,))?;

if data.is(&bufobj) {

return Ok(l);

}

let mut buf = b.borrow_buf_mut();

let data = ArgBytesLike::try_from_object(vm, data)?;

let data = data.borrow_buf();

match buf.get_mut(..data.len()) {

Some(slice) => {

slice.copy_from_slice(&data);

Ok(data.len())

}

None => Err(vm.new_value_error(

"readinto: buffer and read data have different lengths".to_owned(),

)),

}

}

#[pymethod]

fn readinto(zelf: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {

Self::_readinto(zelf, b, "read", vm)

}

#[pymethod]

fn readinto1(zelf: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {

Self::_readinto(zelf, b, "read1", vm)

}

#[pymethod]

fn write(zelf: PyObjectRef, _b: PyObjectRef, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "write")

}

#[pymethod]

fn detach(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {

_unsupported(vm, &zelf, "detach")

}

}

// TextIO Base has no public constructor

#[pyattr]

#[pyclass(name = "_TextIOBase", base = "_IOBase")]

struct _TextIOBase;

#[pyimpl(flags(BASETYPE))]

impl _TextIOBase {}

#[derive(FromArgs, Clone)]

struct BufferSize {

#[pyarg(any, optional)]

buffer_size: OptionalArg<isize>,

}

bitflags::bitflags! {

#[derive(Default)]

struct BufferedFlags: u8 {

const DETACHED = 1 << 0;

const WRITABLE = 1 << 1;

const READABLE = 1 << 2;

}

}

#[derive(Debug, Default)]

struct BufferedData {

raw: Option<PyObjectRef>,

flags: BufferedFlags,

abs_pos: Offset,

buffer: Vec<u8>,

pos: Offset,

raw_pos: Offset,

read_end: Offset,

write_pos: Offset,

write_end: Offset,

}

impl BufferedData {

fn check_init(&self, vm: &VirtualMachine) -> PyResult<&PyObjectRef> {

if let Some(raw) = &self.raw {

Ok(raw)

} else {

let msg = if self.flags.contains(BufferedFlags::DETACHED) {

"raw stream has been detached"

} else {

"I/O operation on uninitialized object"

};

Err(vm.new_value_error(msg.to_owned()))

}

}

#[inline]

fn writable(&self) -> bool {

self.flags.contains(BufferedFlags::WRITABLE)

}

#[inline]

fn readable(&self) -> bool {

self.flags.contains(BufferedFlags::READABLE)

}

#[inline]

fn valid_read(&self) -> bool {

self.readable() && self.read_end != -1

}

#[inline]

fn valid_write(&self) -> bool {

self.writable() && self.write_end != -1

}

#[inline]

fn raw_offset(&self) -> Offset {

if (self.valid_read() || self.valid_write()) && self.raw_pos >= 0 {

self.raw_pos - self.pos

} else {

0

}

}

#[inline]

fn readahead(&self) -> Offset {

if self.valid_read() {

self.read_end - self.pos

} else {

0

}

}

fn reset_read(&mut self) {

self.read_end = -1;

}

fn reset_write(&mut self) {

self.write_pos = 0;

self.write_end = -1;

}

fn flush(&mut self, vm: &VirtualMachine) -> PyResult<()> {

if !self.valid_write() || self.write_pos == self.write_end {

self.reset_write();

return Ok(());

}

let rewind = self.raw_offset() + (self.pos - self.write_pos);

if rewind != 0 {

self.raw_seek(-rewind, 1, vm)?;

self.raw_pos = -rewind;

}

while self.write_pos < self.write_end {

let n =

self.raw_write(None, self.write_pos as usize..self.write_end as usize, vm)?;

let n = n.ok_or_else(|| {

vm.new_exception_msg(

vm.ctx.exceptions.blocking_io_error.clone(),

"write could not complete without blocking".to_owned(),

)

})?;

self.write_pos += n as Offset;

self.raw_pos = self.write_pos;

vm.check_signals()?;

}

self.reset_write();

Ok(())

}

fn flush_rewind(&mut self, vm: &VirtualMachine) -> PyResult<()> {

self.flush(vm)?;

if self.readable() {

let res = self.raw_seek(-self.raw_offset(), 1, vm);

self.reset_read();

res?;

}

Ok(())

}

fn raw_seek(&mut self, pos: Offset, whence: i32, vm: &VirtualMachine) -> PyResult<Offset> {

let ret = vm.call_method(self.check_init(vm)?, "seek", (pos, whence))?;