stdlib: win: stdio: Don't use console APIs on UWP

Author: chouquette

src/libstd/sys/windows/c.rs

@@ -42,6 +42,7 @@ pub type LPBOOL = *mut BOOL;
 pub type LPBYTE = *mut BYTE;
 pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 pub type LPCSTR = *const CHAR;
+#[cfg(not(target_os = "uwp"))]
 pub type LPCVOID = *const c_void;
 pub type LPCWSTR = *const WCHAR;
 pub type LPDWORD = *mut DWORD;
@@ -970,6 +971,7 @@ pub enum EXCEPTION_DISPOSITION {
     ExceptionCollidedUnwind
 }
 
+#[cfg(not(target_os = "uwp"))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CONSOLE_READCONSOLE_CONTROL {
@@ -978,6 +980,7 @@ pub struct CONSOLE_READCONSOLE_CONTROL {
     pub dwCtrlWakeupMask: ULONG,
     pub dwControlKeyState: ULONG,
 }
+#[cfg(not(target_os = "uwp"))]
 pub type PCONSOLE_READCONSOLE_CONTROL = *mut CONSOLE_READCONSOLE_CONTROL;
 
 #[repr(C)]
@@ -1039,18 +1042,21 @@ extern "system" {
     pub fn LeaveCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
     pub fn DeleteCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 
+    #[cfg(not(target_os = "uwp"))]
     pub fn ReadConsoleW(hConsoleInput: HANDLE,
                         lpBuffer: LPVOID,
                         nNumberOfCharsToRead: DWORD,
                         lpNumberOfCharsRead: LPDWORD,
                         pInputControl: PCONSOLE_READCONSOLE_CONTROL) -> BOOL;
 
+    #[cfg(not(target_os = "uwp"))]
     pub fn WriteConsoleW(hConsoleOutput: HANDLE,
                          lpBuffer: LPCVOID,
                          nNumberOfCharsToWrite: DWORD,
                          lpNumberOfCharsWritten: LPDWORD,
                          lpReserved: LPVOID) -> BOOL;
 
+    #[cfg(not(target_os = "uwp"))]
     pub fn GetConsoleMode(hConsoleHandle: HANDLE,
                           lpMode: LPDWORD) -> BOOL;
     pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;

src/libstd/sys/windows/stdio.rs

@@ -1,17 +1,18 @@
 #![unstable(issue = "0", feature = "windows_stdio")]
 
 use crate::char::decode_utf16;
-use crate::cmp;
 use crate::io;
-use crate::ptr;
-use crate::str;
+#[cfg(not(target_os = "uwp"))]
+use crate::{ptr, cmp, str};
 use crate::sys::c;
+#[cfg(not(target_os = "uwp"))]
 use crate::sys::cvt;
 use crate::sys::handle::Handle;
 
 // Don't cache handles but get them fresh for every read/write. This allows us to track changes to
 // the value over time (such as if a process calls `SetStdHandle` while it's running). See #40490.
 pub struct Stdin {
+    #[allow(dead_code)]
     surrogate: u16,
 }
 pub struct Stdout;
@@ -42,6 +43,7 @@ pub fn get_handle(handle_id: c::DWORD) -> io::Result<c::HANDLE> {
     }
 }
 
+#[cfg(not(target_os = "uwp"))]
 fn is_console(handle: c::HANDLE) -> bool {
     // `GetConsoleMode` will return false (0) if this is a pipe (we don't care about the reported
     // mode). This will only detect Windows Console, not other terminals connected to a pipe like
@@ -50,6 +52,16 @@ fn is_console(handle: c::HANDLE) -> bool {
     unsafe { c::GetConsoleMode(handle, &mut mode) != 0 }
 }
 
+#[cfg(target_os = "uwp")]
+fn write(handle_id: c::DWORD, data: &[u8]) -> io::Result<usize> {
+    let handle = get_handle(handle_id)?;
+    let handle = Handle::new(handle);
+    let ret = handle.write(data);
+    handle.into_raw(); // Don't close the handle
+    return ret;
+}
+
+#[cfg(not(target_os = "uwp"))]
 fn write(handle_id: c::DWORD, data: &[u8]) -> io::Result<usize> {
     let handle = get_handle(handle_id)?;
     if !is_console(handle) {
@@ -113,6 +125,7 @@ fn write(handle_id: c::DWORD, data: &[u8]) -> io::Result<usize> {
     }
 }
 
+#[cfg(not(target_os = "uwp"))]
 fn write_u16s(handle: c::HANDLE, data: &[u16]) -> io::Result<usize> {
     let mut written = 0;
     cvt(unsafe {
@@ -132,6 +145,7 @@ impl Stdin {
 }
 
 impl io::Read for Stdin {
+    #[cfg(not(target_os = "uwp"))]
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let handle = get_handle(c::STD_INPUT_HANDLE)?;
         if !is_console(handle) {
@@ -158,12 +172,22 @@ impl io::Read for Stdin {
 
         utf16_to_utf8(&utf16_buf[..read], buf)
     }
+
+    #[cfg(target_os = "uwp")]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let handle = get_handle(c::STD_INPUT_HANDLE)?;
+        let handle = Handle::new(handle);
+        let ret = handle.read(buf);
+        handle.into_raw(); // Don't close the handle
+        ret
+    }
 }
 
 
 // We assume that if the last `u16` is an unpaired surrogate they got sliced apart by our
 // buffer size, and keep it around for the next read hoping to put them together.
 // This is a best effort, and may not work if we are not the only reader on Stdin.
+#[cfg(not(target_os = "uwp"))]
 fn read_u16s_fixup_surrogates(handle: c::HANDLE,
                               buf: &mut [u16],
                               mut amount: usize,
@@ -194,6 +218,7 @@ fn read_u16s_fixup_surrogates(handle: c::HANDLE,
     Ok(amount)
 }
 
+#[cfg(not(target_os = "uwp"))]
 fn read_u16s(handle: c::HANDLE, buf: &mut [u16]) -> io::Result<usize> {
     // Configure the `pInputControl` parameter to not only return on `\r\n` but also Ctrl-Z, the
     // traditional DOS method to indicate end of character stream / user input (SUB).