Merge pull request RustPython#1767 from RustPython/coolreader18/windows-fd-from-handle

Fix writing to stdio streams on Windows

Author: coolreader18

Lib/_sitebuiltins.py

@@ -8,13 +8,8 @@
 # Note this means this module should also avoid keep things alive in its
 # globals.
 
-import os
 import sys
 
-sys.stdin = sys.__stdin__ = getattr(sys, '__stdin__', False) or os.fdopen(0, "r")
-sys.stdout = sys.__stdout__ = getattr(sys, '__stdout__', False) or os.fdopen(1, "w")
-sys.stderr = sys.__stderr__ = getattr(sys, '__stderr__', False) or os.fdopen(2, "w")
-
 
 class Quitter(object):
     def __init__(self, name, eof):

Lib/platform.py

@@ -281,9 +281,10 @@ def _syscmd_ver(system='', release='', version='',
     for cmd in ('ver', 'command /c ver', 'cmd /c ver'):
         try:
             info = subprocess.check_output(cmd,
-                                           stderr=subprocess.DEVNULL,
-                                           text=True,
-                                           shell=True)
+                                           stderr=subprocess.DEVNULL,)
+                                           # XXX RustPython TODO: more Popen args
+                                           # text=True,
+                                           # shell=True)
         except (OSError, subprocess.CalledProcessError) as why:
             #print('Command %s failed: %s' % (cmd, why))
             continue

Lib/test/list_tests.py

@@ -67,7 +67,7 @@ def test_repr(self):
         self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
 
     # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_repr_deep(self):
         a = self.type2test([])
         for i in range(sys.getrecursionlimit() + 100):

Lib/test/test_dict.py

@@ -558,7 +558,7 @@ def __repr__(self):
         self.assertRaises(Exc, repr, d)
 
     # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_repr_deep(self):
         d = {}
         for i in range(sys.getrecursionlimit() + 100):

vm/src/builtins.rs

@@ -32,8 +32,6 @@ use crate::pyobject::{
 };
 use crate::scope::Scope;
 use crate::stdlib::ast;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::stdlib::io::io_open;
 use crate::vm::VirtualMachine;
 
 fn builtin_abs(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -757,11 +755,6 @@ fn builtin_vars(obj: OptionalArg, vm: &VirtualMachine) -> PyResult {
 pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
     let ctx = &vm.ctx;
 
-    #[cfg(target_arch = "wasm32")]
-    let open = vm.ctx.none();
-    #[cfg(not(target_arch = "wasm32"))]
-    let open = vm.ctx.new_function(io_open);
-
     #[cfg(feature = "rustpython-compiler")]
     {
         extend_module!(vm, module, {
@@ -817,7 +810,6 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
         "min" => ctx.new_function(builtin_min),
         "object" => ctx.object(),
         "oct" => ctx.new_function(builtin_oct),
-        "open" => open,
         "ord" => ctx.new_function(builtin_ord),
         "next" => ctx.new_function(builtin_next),
         "pow" => ctx.new_function(builtin_pow),

vm/src/stdlib/os.rs

@@ -70,10 +70,17 @@ pub fn raw_file_number(handle: File) -> i64 {
 
 #[cfg(windows)]
 pub fn rust_file(raw_fileno: i64) -> File {
-    use std::os::windows::io::FromRawHandle;
+    use std::os::windows::io::{AsRawHandle, FromRawHandle, RawHandle};
+
+    let raw_fileno = match raw_fileno {
+        0 => io::stdin().as_raw_handle(),
+        1 => io::stdout().as_raw_handle(),
+        2 => io::stderr().as_raw_handle(),
+        fno => fno as RawHandle,
+    };
 
     //This seems to work as expected but further testing is required.
-    unsafe { File::from_raw_handle(raw_fileno as *mut ffi::c_void) }
+    unsafe { File::from_raw_handle(raw_fileno) }
 }
 
 #[cfg(all(not(unix), not(windows)))]

vm/src/stdlib/subprocess.rs

@@ -248,6 +248,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
 
     let subprocess_error = ctx.new_class("SubprocessError", ctx.exceptions.exception_type.clone());
     let timeout_expired = ctx.new_class("TimeoutExpired", subprocess_error.clone());
+    let called_process_error = ctx.new_class("CalledProcessError", subprocess_error.clone());
 
     let popen = py_class!(ctx, "Popen", ctx.object(), {
         (slot new) => PopenRef::new,
@@ -270,6 +271,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         "Popen" => popen,
         "SubprocessError" => subprocess_error,
         "TimeoutExpired" => timeout_expired,
+        "CalledProcessError" => called_process_error,
         "PIPE" => ctx.new_int(-1),
         "STDOUT" => ctx.new_int(-2),
         "DEVNULL" => ctx.new_int(-3),

vm/src/vm.rs

@@ -231,13 +231,41 @@ impl VirtualMachine {
                 builtins::make_module(self, self.builtins.clone());
                 sysmodule::make_module(self, self.sys_module.clone(), self.builtins.clone());
 
-                #[cfg(not(target_arch = "wasm32"))]
-                import::import_builtin(self, "signal").expect("Couldn't initialize signal module");
+                let inner_init = || -> PyResult<()> {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    import::import_builtin(self, "signal")?;
+
+                    import::init_importlib(self, initialize_parameter)?;
+
+                    #[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(
+                                &io_open,
+                                vec![self.new_int(fd), self.new_str(mode.to_owned())],
+                            )?;
+                            self.set_attr(
+                                &self.sys_module,
+                                format!("__{}__", name), // e.g. __stdin__
+                                stdio.clone(),
+                            )?;
+                            self.set_attr(&self.sys_module, name, stdio)?;
+                            Ok(())
+                        };
+                        set_stdio("stdin", 0, "r")?;
+                        set_stdio("stdout", 1, "w")?;
+                        set_stdio("stderr", 2, "w")?;
+
+                        let open_wrapper = self.get_attribute(io, "OpenWrapper")?;
+                        self.set_attr(&self.builtins, "open", open_wrapper)?;
+                    }
+
+                    Ok(())
+                };
 
-                self.expect_pyresult(
-                    import::init_importlib(self, initialize_parameter),
-                    "Initialize importlib fail",
-                );
+                self.expect_pyresult(inner_init(), "initializiation failed");
 
                 self.initialized = true;
             }