runtime: support sys.stdout and sys.stderr and implement proper print

integration/tests/file_io.py

@@ -0,0 +1,20 @@
+# Regression test: closing a path-opened FileIO after reading must not crash.
+# Previously FileIO.close() called ferror() on the underlying FILE* *after*
+# closing it (which resets the pointer to NULL), segfaulting on ferror(NULL).
+# This is the same path the import machinery uses to read a module's source.
+
+# Run with cwd == integration/ (as the integration runner does).
+DATA = "tests/file_io_data.txt"
+
+# 1. read inside a `with` block -> __exit__ closes the file (the crashing path).
+with open(DATA, "rb") as f:
+    data = f.read()
+assert data == b"line1\nline2\n", data
+
+# 2. explicit close, and close() must be idempotent (callable more than once).
+g = open(DATA, "rb")
+assert g.read() == b"line1\nline2\n"
+g.close()
+g.close()
+
+print("file_io: ok")

integration/tests/file_io_data.txt

@@ -0,0 +1,2 @@
+line1
+line2

src/interpreter/Interpreter.cpp

@@ -22,6 +22,7 @@
 #include "executable/Program.hpp"
 #include "executable/bytecode/Bytecode.hpp"
 #include "executable/bytecode/BytecodeProgram.hpp"
+#include "utilities.hpp"
 
 #include <filesystem>
 
@@ -168,20 +169,48 @@ void Interpreter::internal_setup(const std::string &name,
 	m_codec_search_path = PyList::create().unwrap();
 	m_codec_search_path_cache = PyDict::create().unwrap();
 
+	PyModule *io_module;
 	for (const auto &[name, module_factory] : builtin_modules) {
-		if (module_factory) { m_modules->insert(String{ std::string{ name } }, module_factory()); }
+		if (module_factory) {
+			auto mod = module_factory();
+			if (name == "_io") { io_module = mod; }
+			m_modules->insert(String{ std::string{ name } }, mod);
+		}
 	}
 
 	{
-		auto open = io_module()->symbol_table()->map().at(String{ "open" });
+		ASSERT(io_module);
+		auto open = io_module->symbol_table()->map().at(String{ "open" });
 		m_builtins->add_symbol(PyString::create("open").unwrap(), open);
+		auto *file_io =
+			std::get<PyObject *>(io_module->symbol_table()->map().at(String{ "FileIO" }));
+		auto *buffered_writer =
+			std::get<PyObject *>(io_module->symbol_table()->map().at(String{ "BufferedWriter" }));
+		auto *text_io_wrapper =
+			std::get<PyObject *>(io_module->symbol_table()->map().at(String{ "TextIOWrapper" }));
+		auto py_stdout =
+			file_io->call(PyTuple::create(Number{ 1 }, String{ "wb" }).unwrap(), nullptr)
+				.and_then([buffered_writer](PyObject *stdout) {
+					return buffered_writer->call(PyTuple::create(stdout).unwrap(), nullptr);
+				})
+				.and_then([text_io_wrapper](PyObject *stdout_buffer_writer) {
+					return text_io_wrapper->call(
+						PyTuple::create(stdout_buffer_writer).unwrap(), nullptr);
+				});
+		ASSERT(py_stdout.is_ok());
+		auto py_stderr =
+			file_io->call(PyTuple::create(Number{ 2 }, String{ "wb" }).unwrap(), nullptr)
+				.and_then([buffered_writer](PyObject *stderr) {
+					return buffered_writer->call(PyTuple::create(stderr).unwrap(), nullptr);
+				})
+				.and_then([text_io_wrapper](PyObject *stderr_buffer_writer) {
+					return text_io_wrapper->call(
+						PyTuple::create(stderr_buffer_writer).unwrap(), nullptr);
+				});
+		ASSERT(py_stderr.is_ok());
+		sys->add_symbol(PyString::create("stdout").unwrap(), py_stdout.unwrap());
+		sys->add_symbol(PyString::create("stderr").unwrap(), py_stderr.unwrap());
 	}
-	// {
-	// 	auto open = io_module()->symbol_table()->map().at(String{ "open" });
-	// 	m_builtins->add_symbol(PyString::create("open").unwrap(), open);
-	// 	sys->add_symbol(PyString::create("stderr").unwrap(),
-	// 		std::get<PyObject *>(open)->call(PyTuple::create().unwrap(), nullptr).unwrap());
-	// }
 
 	if (config.requires_importlib) {
 		auto *_imp = imp_module();

src/runtime/PyMemoryView.cpp

@@ -336,6 +336,25 @@ PyResult<PyObject *> PyMemoryView::tolist()
 
 PyResult<PyObject *> PyMemoryView::__repr__() const { return PyString::create(to_string()); }
 
+PyResult<std::monostate> PyMemoryView::__getbuffer__(PyBuffer &view, int /*flags*/)
+{
+	// TODO: validate flags
+	view = PyBuffer{
+		.buf = m_view.buf->view(),
+		.obj = this,
+		.len = m_view.len,
+		.itemsize = m_view.itemsize,
+		.readonly = m_view.readonly,
+		.ndim = m_view.ndim,
+		.format = m_view.format,
+		.shape = m_view.shape,
+		.strides = m_view.strides,
+		.suboffsets = m_view.suboffsets,
+		.internal = m_view.internal,
+	};
+	return Ok(std::monostate{});
+}
+
 namespace {
 	std::once_flag memoryview_flag;
 

src/runtime/PyMemoryView.hpp

@@ -41,6 +41,9 @@ class PyMemoryView : public PyBaseObject
 
 	size_t itemsize() const { return m_view.itemsize; }
 
+	PyResult<std::monostate> __getbuffer__(PyBuffer &view, int /*flags*/);
+
+
   private:
 	static PyResult<PyBuffer> create_view(PyBuffer &main_view);
 };

src/runtime/PyObject.cpp

@@ -468,12 +468,7 @@ PyResult<std::monostate> PyObject::get_buffer(PyBuffer &buffer, int flags)
 {
 	return as_buffer().and_then(
 		[&buffer, flags, this](const PyBufferProcs &bc) -> PyResult<std::monostate> {
-			(void)buffer;
-			(void)flags;
-			(void)this;
-			(void)bc;
-			return Err(not_implemented_error("get_buffer not implemented!"));
-			// return bc.getbuffer(this, buffer, flags);
+			return bc.getbuffer(this, buffer, flags);
 		});
 }
 

src/runtime/PyObject.hpp

@@ -433,6 +433,7 @@ class PyObject : public Cell
 	PyResult<PySequenceWrapper> as_sequence();
 	PyResult<PyBufferProcs> as_buffer();
 
+	// TODO: add strongly typed flags
 	PyResult<std::monostate> get_buffer(PyBuffer &, int flags);
 
 	PyResult<PyObject *> getattribute(PyObject *attribute) const;

src/runtime/modules/BuiltinsModule.cpp

@@ -67,10 +67,20 @@ static PyModule *s_builtin_module = nullptr;
 
 namespace {
 
-PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interpreter &)
+PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interpreter &interpreter)
 {
 	std::string separator = " ";
 	std::string end = "\n";
+	// TODO: handle error case?
+	PyObject *file =
+		PyObject::from(interpreter.get_imported_module(PyString::create("sys").unwrap())
+						   ->symbol_table()
+						   ->map()
+						   .at(String{ "stdout" }))
+			.unwrap();
+	// sys.stdout may be None when FILE* stdout isn't connected
+	if (!file || file == py_none()) { return Ok(py_none()); }
+	bool flush = true;
 	if (kwargs) {
 		static const Value separator_keyword = String{ "sep" };
 		static const Value end_keyword = String{ "end" };
@@ -98,6 +108,9 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 			end = std::get<String>(maybe_str).s;
 		}
 	}
+	auto file_write_ = file->get_method(PyString::create("write").unwrap());
+	if (file_write_.is_err()) { return file_write_; }
+	auto file_write = file_write_.unwrap();
 	auto strfunc = [](const PyResult<PyObject *> &arg) -> PyResult<PyString *> {
 		if (arg.is_err()) return Err(arg.unwrap_err());
 		return arg.unwrap()->str();
@@ -106,7 +119,11 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 	auto arg_it = args->begin();
 	auto arg_it_end = args->end();
 	if (arg_it == arg_it_end) {
-		std::cout << std::endl;
+		if (flush) {
+			auto file_flush_ = file->get_method(PyString::create("flush").unwrap());
+			if (file_flush_.is_err()) { return file_flush_; }
+			return file_flush_.unwrap()->call(nullptr, nullptr);
+		}
 		return Ok(py_none());
 	}
 	--arg_it_end;
@@ -117,7 +134,10 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 		if (reprobj_.is_err()) { return reprobj_; }
 		auto reprobj = reprobj_.unwrap();
 		spdlog::debug("repr result: {}", reprobj->value());
-		std::cout << reprobj->value() << separator;
+		if (auto result = file_write->call(PyTuple::create(reprobj).unwrap(), nullptr);
+			result.is_err()) {
+			return result;
+		}
 		std::advance(arg_it, 1);
 	}
 
@@ -126,8 +146,23 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
 	if (reprobj_.is_err()) { return reprobj_; }
 	auto reprobj = reprobj_.unwrap();
 	spdlog::debug("repr result: {}", reprobj->value());
-	std::cout << reprobj->value() << end;
+	if (auto result = file_write->call(PyTuple::create(reprobj).unwrap(), nullptr);
+		result.is_err()) {
+		return result;
+	}
 
+	if (!end.empty()) {
+		if (auto result =
+				file_write->call(PyTuple::create(PyString::create(end).unwrap()).unwrap(), nullptr);
+			result.is_err()) {
+			return result;
+		}
+	}
+	if (flush) {
+		auto file_flush_ = file->get_method(PyString::create("flush").unwrap());
+		if (file_flush_.is_err()) { return file_flush_; }
+		return file_flush_.unwrap()->call(nullptr, nullptr);
+	}
 	return Ok(py_none());
 }