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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }
 

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";
+	auto *separator = PyString::create(" ").unwrap();
+	auto *end = PyString::create("\n").unwrap();
+	// 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" };
@@ -84,7 +94,7 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "sep must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- separator = std::get<String>(maybe_str).s;
+ separator = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
  if (auto it = kwargs->map().find(end_keyword); it != kwargs->map().end()) {
  auto maybe_str = it->second;
@@ -95,9 +105,12 @@ PyResult<PyObject *> print(const PyTuple *args, const PyDict *kwargs, Interprete
  return Err(type_error(
  "end must be None or a string, not {}", obj.unwrap()->type()->name()));
  }
- end = std::get<String>(maybe_str).s;
+ end = PyString::create(std::get<String>(maybe_str).s).unwrap();
  }
 	}
+	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,16 @@ 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 (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());
 	}
 	--arg_it_end;
@@ -117,7 +139,14 @@ 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;
+ }
+ if (auto result = file_write->call(PyTuple::create(separator).unwrap(), nullptr);
+ result.is_err()) {
+ return result;
+ }
  std::advance(arg_it, 1);
 	}
 
@@ -126,8 +155,21 @@ 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 (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());
 }