Initialize _io.py in the vm

coolreader18 · coolreader18 · commit bc2e6816a011 · 2020-04-11T16:40:05.000-05:00
diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs
@@ -78,7 +78,7 @@ pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
         "errno".to_owned() => Box::new(errno::make_module),
         "hashlib".to_owned() => Box::new(hashlib::make_module),
         "itertools".to_owned() => Box::new(itertools::make_module),
-        "_io".to_owned() => Box::new(io::make_module),
+        "_rust_io".to_owned() => Box::new(io::make_module),
         "marshal".to_owned() => Box::new(marshal::make_module),
         "math".to_owned() => Box::new(math::make_module),
         "_operator".to_owned() => Box::new(operator::make_module),
diff --git a/vm/src/stdlib/subprocess.rs b/vm/src/stdlib/subprocess.rs
@@ -12,7 +12,6 @@ use crate::obj::objlist::PyListRef;
 use crate::obj::objstr::{self, PyStringRef};
 use crate::obj::objtype::PyClassRef;
 use crate::pyobject::{Either, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue};
-use crate::stdlib::io::io_open;
 use crate::stdlib::os::{convert_io_error, raw_file_number, rust_file};
 use crate::vm::VirtualMachine;
 
@@ -94,8 +93,7 @@ fn convert_redirection(arg: Option<i64>, vm: &VirtualMachine) -> PyResult<subpro
 
 fn convert_to_file_io(file: &Option<File>, mode: String, vm: &VirtualMachine) -> PyResult {
     match file {
-        Some(ref stdin) => io_open(
-            vm,
+        Some(ref stdin) => vm.io_open(
             vec![
                 vm.new_int(raw_file_number(stdin.try_clone().unwrap())),
                 vm.new_str(mode),
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -237,11 +237,32 @@ impl VirtualMachine {
                     #[cfg(not(target_arch = "wasm32"))]
                     import::import_builtin(self, "signal")?;
 
-                    import::init_importlib(self, initialize_parameter)?;
+                    let io = {
+                        let module_name = "_io";
+                        let attrs = self.ctx.new_dict();
+                        let io_code = self.frozen.borrow().get(module_name).unwrap().code.clone();
+
+                        attrs.set_item("__name__", self.new_str(module_name.to_owned()), self)?;
+
+                        let module = self.new_module(module_name, attrs.clone());
+
+                        // Store module in cache to prevent infinite loop with mutual importing libs:
+                        let sys_modules = self.get_attribute(self.sys_module.clone(), "modules")?;
+                        sys_modules.set_item(module_name, module.clone(), self)?;
+
+                        import::init_importlib(self, initialize_parameter)?;
+
+                        // Execute main code in module:
+                        self.run_code_obj(
+                            PyCode::new(io_code).into_ref(self),
+                            Scope::with_builtins(None, attrs, self),
+                        )?;
+
+                        module
+                    };
 
                     #[cfg(not(target_arch = "wasm32"))]
                     {
-                        let io = self.import("io", &[], 0)?;
                         let io_open = self.get_attribute(io.clone(), "open")?;
                         let set_stdio = |name, fd, mode: &str| {
                             let stdio = self.invoke(
@@ -1082,6 +1103,12 @@ impl VirtualMachine {
         self.call_codec_func("encode", obj, encoding, errors)
     }
 
+    pub fn io_open(&self, args: PyFuncArgs) -> PyResult {
+        let io = self.import("io", &[], 0)?;
+        let io_open = self.get_attribute(io, "open")?;
+        self.invoke(&io_open, args)
+    }
+
     pub fn _sub(&self, a: PyObjectRef, b: PyObjectRef) -> PyResult {
         self.call_or_reflection(a, b, "__sub__", "__rsub__", |vm, a, b| {
             Err(vm.new_unsupported_operand_error(a, b, "-"))
