diff options
Diffstat (limited to 'src/libstd/sys/windows')
35 files changed, 261 insertions, 253 deletions
diff --git a/src/libstd/sys/windows/alloc.rs b/src/libstd/sys/windows/alloc.rs index 0d7f803c7ee..a33c4019a2e 100644 --- a/src/libstd/sys/windows/alloc.rs +++ b/src/libstd/sys/windows/alloc.rs @@ -1,6 +1,6 @@ -use alloc::{GlobalAlloc, Layout, System}; -use sys::c; -use sys_common::alloc::{MIN_ALIGN, realloc_fallback}; +use crate::alloc::{GlobalAlloc, Layout, System}; +use crate::sys::c; +use crate::sys_common::alloc::{MIN_ALIGN, realloc_fallback}; #[repr(C)] struct Header(*mut u8); diff --git a/src/libstd/sys/windows/args.rs b/src/libstd/sys/windows/args.rs index f6728069109..3f10e6e5983 100644 --- a/src/libstd/sys/windows/args.rs +++ b/src/libstd/sys/windows/args.rs @@ -1,14 +1,15 @@ #![allow(dead_code)] // runtime init functions not used during testing -use os::windows::prelude::*; -use sys::windows::os::current_exe; -use sys::c; -use ffi::OsString; -use fmt; -use vec; +use crate::os::windows::prelude::*; +use crate::sys::windows::os::current_exe; +use crate::sys::c; +use crate::ffi::OsString; +use crate::fmt; +use crate::vec; +use crate::slice; +use crate::path::PathBuf; + use core::iter; -use slice; -use path::PathBuf; pub unsafe fn init(_argc: isize, _argv: *const *const u8) { } @@ -80,7 +81,7 @@ unsafe fn parse_lp_cmd_line<F: Fn() -> OsString>(lp_cmd_line: *const u16, exe_na // "However, if lpCmdLine starts with any amount of whitespace, CommandLineToArgvW // will consider the first argument to be an empty string. Excess whitespace at the // end of lpCmdLine is ignored." - 0...SPACE => { + 0..=SPACE => { ret_val.push(OsString::new()); &cmd_line[1..] }, @@ -192,8 +193,8 @@ impl ExactSizeIterator for Args { #[cfg(test)] mod tests { - use sys::windows::args::*; - use ffi::OsString; + use crate::sys::windows::args::*; + use crate::ffi::OsString; fn chk(string: &str, parts: &[&str]) { let mut wide: Vec<u16> = OsString::from(string).encode_wide().collect(); diff --git a/src/libstd/sys/windows/backtrace/backtrace_gnu.rs b/src/libstd/sys/windows/backtrace/backtrace_gnu.rs index e8aa9399742..7ac1f8122f7 100644 --- a/src/libstd/sys/windows/backtrace/backtrace_gnu.rs +++ b/src/libstd/sys/windows/backtrace/backtrace_gnu.rs @@ -1,10 +1,11 @@ -use io; -use sys::c; +use crate::io; +use crate::sys::c; +use crate::path::PathBuf; +use crate::fs::{OpenOptions, File}; +use crate::sys::ext::fs::OpenOptionsExt; +use crate::sys::handle::Handle; + use libc::c_char; -use path::PathBuf; -use fs::{OpenOptions, File}; -use sys::ext::fs::OpenOptionsExt; -use sys::handle::Handle; use super::super::{fill_utf16_buf, os2path, to_u16s, wide_char_to_multi_byte}; fn query_full_process_image_name() -> io::Result<PathBuf> { diff --git a/src/libstd/sys/windows/backtrace/mod.rs b/src/libstd/sys/windows/backtrace/mod.rs index 4bda8ac91da..c5b0cc87210 100644 --- a/src/libstd/sys/windows/backtrace/mod.rs +++ b/src/libstd/sys/windows/backtrace/mod.rs @@ -14,13 +14,14 @@ #![allow(deprecated)] // dynamic_lib -use io; +use crate::io; +use crate::mem; +use crate::ptr; +use crate::sys::c; +use crate::sys::dynamic_lib::DynamicLibrary; +use crate::sys_common::backtrace::Frame; + use libc::c_void; -use mem; -use ptr; -use sys::c; -use sys::dynamic_lib::DynamicLibrary; -use sys_common::backtrace::Frame; macro_rules! sym { ($lib:expr, $e:expr, $t:ident) => ( diff --git a/src/libstd/sys/windows/backtrace/printing/mod.rs b/src/libstd/sys/windows/backtrace/printing/mod.rs index d44df7e5f24..9497d51ac17 100644 --- a/src/libstd/sys/windows/backtrace/printing/mod.rs +++ b/src/libstd/sys/windows/backtrace/printing/mod.rs @@ -4,11 +4,11 @@ mod printing; #[cfg(target_env = "gnu")] mod printing { - pub use sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; + pub use crate::sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; // dummy functions to mirror those present in msvc version. - use sys::dynamic_lib::DynamicLibrary; - use io; + use crate::sys::dynamic_lib::DynamicLibrary; + use crate::io; pub struct PrintingFnsEx {} pub struct PrintingFns64 {} pub fn load_printing_fns_ex(_: &DynamicLibrary) -> io::Result<PrintingFnsEx> { diff --git a/src/libstd/sys/windows/backtrace/printing/msvc.rs b/src/libstd/sys/windows/backtrace/printing/msvc.rs index b186bb42334..13a1512d0eb 100644 --- a/src/libstd/sys/windows/backtrace/printing/msvc.rs +++ b/src/libstd/sys/windows/backtrace/printing/msvc.rs @@ -1,12 +1,13 @@ -use ffi::CStr; -use io; +use crate::ffi::CStr; +use crate::io; +use crate::mem; +use crate::sys::backtrace::BacktraceContext; +use crate::sys::backtrace::StackWalkVariant; +use crate::sys::c; +use crate::sys::dynamic_lib::DynamicLibrary; +use crate::sys_common::backtrace::Frame; + use libc::{c_char, c_ulong}; -use mem; -use sys::backtrace::BacktraceContext; -use sys::backtrace::StackWalkVariant; -use sys::c; -use sys::dynamic_lib::DynamicLibrary; -use sys_common::backtrace::Frame; // Structs holding printing functions and loaders for them // Two versions depending on whether dbghelp.dll has StackWalkEx or not @@ -190,7 +191,7 @@ where { unsafe { let mut line: c::IMAGEHLP_LINE64 = mem::zeroed(); - line.SizeOfStruct = ::mem::size_of::<c::IMAGEHLP_LINE64>() as u32; + line.SizeOfStruct = mem::size_of::<c::IMAGEHLP_LINE64>() as u32; let ret = line_getter( context.handle, diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index a78b599204b..518eccf754c 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -4,11 +4,12 @@ #![cfg_attr(test, allow(dead_code))] #![unstable(issue = "0", feature = "windows_c")] -use os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort, c_char}; +use crate::os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort, c_char}; #[cfg(target_arch = "x86_64")] -use os::raw::c_ulonglong; +use crate::os::raw::c_ulonglong; +use crate::ptr; + use libc::{wchar_t, size_t, c_void}; -use ptr; pub use self::FILE_INFO_BY_HANDLE_CLASS::*; pub use self::EXCEPTION_DISPOSITION::*; @@ -65,7 +66,7 @@ pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; pub type PLARGE_INTEGER = *mut c_longlong; pub type PSRWLOCK = *mut SRWLOCK; -pub type SOCKET = ::os::windows::raw::SOCKET; +pub type SOCKET = crate::os::windows::raw::SOCKET; pub type socklen_t = c_int; pub type ADDRESS_FAMILY = USHORT; @@ -450,7 +451,7 @@ pub struct MOUNT_POINT_REPARSE_BUFFER { pub PathBuffer: WCHAR, } -pub type LPPROGRESS_ROUTINE = ::option::Option<unsafe extern "system" fn( +pub type LPPROGRESS_ROUTINE = crate::option::Option<unsafe extern "system" fn( TotalFileSize: LARGE_INTEGER, TotalBytesTransferred: LARGE_INTEGER, StreamSize: LARGE_INTEGER, diff --git a/src/libstd/sys/windows/compat.rs b/src/libstd/sys/windows/compat.rs index b6c55344c62..748c1616d1d 100644 --- a/src/libstd/sys/windows/compat.rs +++ b/src/libstd/sys/windows/compat.rs @@ -11,9 +11,9 @@ //! manner we pay a semi-large one-time cost up front for detecting whether a //! function is available but afterwards it's just a load and a jump. -use ffi::CString; -use sync::atomic::{AtomicUsize, Ordering}; -use sys::c; +use crate::ffi::CString; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::sys::c; pub fn lookup(module: &str, symbol: &str) -> Option<usize> { let mut module: Vec<u16> = module.encode_utf16().collect(); @@ -44,14 +44,14 @@ macro_rules! compat_fn { )*) => ($( #[allow(unused_variables)] pub unsafe fn $symbol($($argname: $argtype),*) -> $rettype { - use sync::atomic::{AtomicUsize, Ordering}; - use mem; + use crate::sync::atomic::{AtomicUsize, Ordering}; + use crate::mem; type F = unsafe extern "system" fn($($argtype),*) -> $rettype; static PTR: AtomicUsize = AtomicUsize::new(0); fn load() -> usize { - ::sys::compat::store_func(&PTR, + crate::sys::compat::store_func(&PTR, stringify!($module), stringify!($symbol), fallback as usize) diff --git a/src/libstd/sys/windows/condvar.rs b/src/libstd/sys/windows/condvar.rs index 48d8af73913..62835ea7c94 100644 --- a/src/libstd/sys/windows/condvar.rs +++ b/src/libstd/sys/windows/condvar.rs @@ -1,8 +1,8 @@ -use cell::UnsafeCell; -use sys::c; -use sys::mutex::{self, Mutex}; -use sys::os; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::sys::c; +use crate::sys::mutex::{self, Mutex}; +use crate::sys::os; +use crate::time::Duration; pub struct Condvar { inner: UnsafeCell<c::CONDITION_VARIABLE> } diff --git a/src/libstd/sys/windows/dynamic_lib.rs b/src/libstd/sys/windows/dynamic_lib.rs index fa3c5ecb977..b9d5105cb73 100644 --- a/src/libstd/sys/windows/dynamic_lib.rs +++ b/src/libstd/sys/windows/dynamic_lib.rs @@ -1,8 +1,8 @@ -use os::windows::prelude::*; +use crate::os::windows::prelude::*; -use ffi::{CString, OsStr}; -use io; -use sys::c; +use crate::ffi::{CString, OsStr}; +use crate::io; +use crate::sys::c; pub struct DynamicLibrary { handle: c::HMODULE, diff --git a/src/libstd/sys/windows/ext/ffi.rs b/src/libstd/sys/windows/ext/ffi.rs index 6508c0cf447..547b1ef796b 100644 --- a/src/libstd/sys/windows/ext/ffi.rs +++ b/src/libstd/sys/windows/ext/ffi.rs @@ -59,13 +59,13 @@ #![stable(feature = "rust1", since = "1.0.0")] -use ffi::{OsString, OsStr}; -use sys::os_str::Buf; -use sys_common::wtf8::Wtf8Buf; -use sys_common::{FromInner, AsInner}; +use crate::ffi::{OsString, OsStr}; +use crate::sys::os_str::Buf; +use crate::sys_common::wtf8::Wtf8Buf; +use crate::sys_common::{FromInner, AsInner}; #[stable(feature = "rust1", since = "1.0.0")] -pub use sys_common::wtf8::EncodeWide; +pub use crate::sys_common::wtf8::EncodeWide; /// Windows-specific extensions to [`OsString`]. /// diff --git a/src/libstd/sys/windows/ext/fs.rs b/src/libstd/sys/windows/ext/fs.rs index 89038da6295..b6da5950280 100644 --- a/src/libstd/sys/windows/ext/fs.rs +++ b/src/libstd/sys/windows/ext/fs.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs::{self, OpenOptions, Metadata}; -use io; -use path::Path; -use sys; -use sys_common::{AsInnerMut, AsInner}; +use crate::fs::{self, OpenOptions, Metadata}; +use crate::io; +use crate::path::Path; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner}; /// Windows-specific extensions to [`File`]. /// diff --git a/src/libstd/sys/windows/ext/io.rs b/src/libstd/sys/windows/ext/io.rs index fbe0426ce5a..1a7d734b89e 100644 --- a/src/libstd/sys/windows/ext/io.rs +++ b/src/libstd/sys/windows/ext/io.rs @@ -1,12 +1,12 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs; -use os::windows::raw; -use net; -use sys_common::{self, AsInner, FromInner, IntoInner}; -use sys; -use io; -use sys::c; +use crate::fs; +use crate::os::windows::raw; +use crate::net; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::sys; +use crate::sys::c; +use crate::io; /// Raw HANDLEs. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/sys/windows/ext/process.rs b/src/libstd/sys/windows/ext/process.rs index 15f0fd4e11f..b2e6cdead4f 100644 --- a/src/libstd/sys/windows/ext/process.rs +++ b/src/libstd/sys/windows/ext/process.rs @@ -2,10 +2,10 @@ #![stable(feature = "process_extensions", since = "1.2.0")] -use os::windows::io::{FromRawHandle, RawHandle, AsRawHandle, IntoRawHandle}; -use process; -use sys; -use sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; +use crate::os::windows::io::{FromRawHandle, RawHandle, AsRawHandle, IntoRawHandle}; +use crate::process; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; #[stable(feature = "process_extensions", since = "1.2.0")] impl FromRawHandle for process::Stdio { diff --git a/src/libstd/sys/windows/ext/raw.rs b/src/libstd/sys/windows/ext/raw.rs index 77428d9e774..d2bab272036 100644 --- a/src/libstd/sys/windows/ext/raw.rs +++ b/src/libstd/sys/windows/ext/raw.rs @@ -2,7 +2,7 @@ #![stable(feature = "raw_ext", since = "1.1.0")] -use os::raw::c_void; +use crate::os::raw::c_void; #[stable(feature = "raw_ext", since = "1.1.0")] pub type HANDLE = *mut c_void; #[cfg(target_pointer_width = "32")] diff --git a/src/libstd/sys/windows/ext/thread.rs b/src/libstd/sys/windows/ext/thread.rs index 29d612fedc0..fdc7e7fa32f 100644 --- a/src/libstd/sys/windows/ext/thread.rs +++ b/src/libstd/sys/windows/ext/thread.rs @@ -2,9 +2,9 @@ #![stable(feature = "thread_extensions", since = "1.9.0")] -use os::windows::io::{RawHandle, AsRawHandle, IntoRawHandle}; -use thread; -use sys_common::{AsInner, IntoInner}; +use crate::os::windows::io::{RawHandle, AsRawHandle, IntoRawHandle}; +use crate::thread; +use crate::sys_common::{AsInner, IntoInner}; #[stable(feature = "thread_extensions", since = "1.9.0")] impl<T> AsRawHandle for thread::JoinHandle<T> { diff --git a/src/libstd/sys/windows/fast_thread_local.rs b/src/libstd/sys/windows/fast_thread_local.rs index f8b936b4810..0ccc67e3fd5 100644 --- a/src/libstd/sys/windows/fast_thread_local.rs +++ b/src/libstd/sys/windows/fast_thread_local.rs @@ -1,7 +1,7 @@ #![unstable(feature = "thread_local_internals", issue = "0")] #![cfg(target_thread_local)] -pub use sys_common::thread_local::register_dtor_fallback as register_dtor; +pub use crate::sys_common::thread_local::register_dtor_fallback as register_dtor; pub fn requires_move_before_drop() -> bool { false diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 533b8ae9ba2..f19c111f09a 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -1,17 +1,17 @@ -use os::windows::prelude::*; - -use ffi::OsString; -use fmt; -use io::{self, Error, SeekFrom}; -use mem; -use path::{Path, PathBuf}; -use ptr; -use slice; -use sync::Arc; -use sys::handle::Handle; -use sys::time::SystemTime; -use sys::{c, cvt}; -use sys_common::FromInner; +use crate::os::windows::prelude::*; + +use crate::ffi::OsString; +use crate::fmt; +use crate::io::{self, Error, SeekFrom}; +use crate::mem; +use crate::path::{Path, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::sync::Arc; +use crate::sys::handle::Handle; +use crate::sys::time::SystemTime; +use crate::sys::{c, cvt}; +use crate::sys_common::FromInner; use super::to_u16s; diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index 855efbd3eb5..02549088c87 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -1,13 +1,12 @@ #![unstable(issue = "0", feature = "windows_handle")] -use cmp; -use io::{ErrorKind, Read}; -use io; -use mem; -use ops::Deref; -use ptr; -use sys::c; -use sys::cvt; +use crate::cmp; +use crate::io::{self, ErrorKind, Read}; +use crate::mem; +use crate::ops::Deref; +use crate::ptr; +use crate::sys::c; +use crate::sys::cvt; /// An owned container for `HANDLE` object, closing them on Drop. /// diff --git a/src/libstd/sys/windows/io.rs b/src/libstd/sys/windows/io.rs index 662e3047923..54dd271c9d6 100644 --- a/src/libstd/sys/windows/io.rs +++ b/src/libstd/sys/windows/io.rs @@ -1,6 +1,6 @@ -use marker::PhantomData; -use slice; -use sys::c; +use crate::marker::PhantomData; +use crate::slice; +use crate::sys::c; #[repr(transparent)] pub struct IoVec<'a> { diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 56c76a169fe..1425254a2e1 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -1,11 +1,11 @@ #![allow(missing_docs, nonstandard_style)] -use ptr; -use ffi::{OsStr, OsString}; -use io::ErrorKind; -use os::windows::ffi::{OsStrExt, OsStringExt}; -use path::PathBuf; -use time::Duration; +use crate::ptr; +use crate::ffi::{OsStr, OsString}; +use crate::io::ErrorKind; +use crate::os::windows::ffi::{OsStrExt, OsStringExt}; +use crate::path::PathBuf; +use crate::time::Duration; pub use libc::strlen; pub use self::rand::hashmap_random_keys; @@ -76,11 +76,11 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind { } } -pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> ::io::Result<Vec<u16>> { - fn inner(s: &OsStr) -> ::io::Result<Vec<u16>> { +pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> crate::io::Result<Vec<u16>> { + fn inner(s: &OsStr) -> crate::io::Result<Vec<u16>> { let mut maybe_result: Vec<u16> = s.encode_wide().collect(); if maybe_result.iter().any(|&u| u == 0) { - return Err(::io::Error::new(::io::ErrorKind::InvalidInput, + return Err(crate::io::Error::new(ErrorKind::InvalidInput, "strings passed to WinAPI cannot contain NULs")); } maybe_result.push(0); @@ -103,7 +103,7 @@ pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> ::io::Result<Vec<u16>> { // Once the syscall has completed (errors bail out early) the second closure is // yielded the data which has been read from the syscall. The return value // from this closure is then the return value of the function. -fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> ::io::Result<T> +fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> crate::io::Result<T> where F1: FnMut(*mut u16, c::DWORD) -> c::DWORD, F2: FnOnce(&[u16]) -> T { @@ -135,7 +135,7 @@ fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> ::io::Result<T> c::SetLastError(0); let k = match f1(buf.as_mut_ptr(), n as c::DWORD) { 0 if c::GetLastError() == 0 => 0, - 0 => return Err(::io::Error::last_os_error()), + 0 => return Err(crate::io::Error::last_os_error()), n => n, } as usize; if k == n && c::GetLastError() == c::ERROR_INSUFFICIENT_BUFFER { @@ -158,7 +158,7 @@ fn wide_char_to_multi_byte(code_page: u32, flags: u32, s: &[u16], no_default_char: bool) - -> ::io::Result<Vec<i8>> { + -> crate::io::Result<Vec<i8>> { unsafe { let mut size = c::WideCharToMultiByte(code_page, flags, @@ -169,7 +169,7 @@ fn wide_char_to_multi_byte(code_page: u32, ptr::null(), ptr::null_mut()); if size == 0 { - return Err(::io::Error::last_os_error()); + return Err(crate::io::Error::last_os_error()); } let mut buf = Vec::with_capacity(size as usize); @@ -186,10 +186,10 @@ fn wide_char_to_multi_byte(code_page: u32, if no_default_char { &mut used_default_char } else { ptr::null_mut() }); if size == 0 { - return Err(::io::Error::last_os_error()); + return Err(crate::io::Error::last_os_error()); } if no_default_char && used_default_char == c::TRUE { - return Err(::io::Error::new(::io::ErrorKind::InvalidData, + return Err(crate::io::Error::new(crate::io::ErrorKind::InvalidData, "string cannot be converted to requested code page")); } @@ -221,9 +221,9 @@ macro_rules! impl_is_zero { impl_is_zero! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize } -pub fn cvt<I: IsZero>(i: I) -> ::io::Result<I> { +pub fn cvt<I: IsZero>(i: I) -> crate::io::Result<I> { if i.is_zero() { - Err(::io::Error::last_os_error()) + Err(crate::io::Error::last_os_error()) } else { Ok(i) } @@ -263,7 +263,7 @@ pub unsafe fn abort_internal() -> ! { #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { asm!("int $$0x29" :: "{ecx}"(7) ::: volatile); // 7 is FAST_FAIL_FATAL_APP_EXIT - ::intrinsics::unreachable(); + crate::intrinsics::unreachable(); } - ::intrinsics::abort(); + crate::intrinsics::abort(); } diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs index f690580ae38..1aa910f05c9 100644 --- a/src/libstd/sys/windows/mutex.rs +++ b/src/libstd/sys/windows/mutex.rs @@ -19,11 +19,11 @@ //! CriticalSection is used and we keep track of who's holding the mutex to //! detect recursive locks. -use cell::UnsafeCell; -use mem::{self, MaybeUninit}; -use sync::atomic::{AtomicUsize, Ordering}; -use sys::c; -use sys::compat; +use crate::cell::UnsafeCell; +use crate::mem::{self, MaybeUninit}; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::sys::c; +use crate::sys::compat; pub struct Mutex { lock: AtomicUsize, diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 76be26a9d1a..1231fd55e25 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -1,26 +1,27 @@ #![unstable(issue = "0", feature = "windows_net")] -use cmp; -use io::{self, Read, IoVec, IoVecMut}; +use crate::cmp; +use crate::io::{self, Read, IoVec, IoVecMut}; +use crate::mem; +use crate::net::{SocketAddr, Shutdown}; +use crate::ptr; +use crate::sync::Once; +use crate::sys::c; +use crate::sys; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::sys_common::net; +use crate::time::Duration; + use libc::{c_int, c_void, c_ulong, c_long}; -use mem; -use net::{SocketAddr, Shutdown}; -use ptr; -use sync::Once; -use sys::c; -use sys; -use sys_common::{self, AsInner, FromInner, IntoInner}; -use sys_common::net; -use time::Duration; pub type wrlen_t = i32; pub mod netc { - pub use sys::c::*; - pub use sys::c::SOCKADDR as sockaddr; - pub use sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage; - pub use sys::c::ADDRINFOA as addrinfo; - pub use sys::c::ADDRESS_FAMILY as sa_family_t; + pub use crate::sys::c::*; + pub use crate::sys::c::SOCKADDR as sockaddr; + pub use crate::sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage; + pub use crate::sys::c::ADDRINFOA as addrinfo; + pub use crate::sys::c::ADDRESS_FAMILY as sa_family_t; } pub struct Socket(c::SOCKET); diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 7399dd41a41..5b433ddfb4a 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -2,18 +2,18 @@ #![allow(nonstandard_style)] -use os::windows::prelude::*; - -use error::Error as StdError; -use ffi::{OsString, OsStr}; -use fmt; -use io; -use os::windows::ffi::EncodeWide; -use path::{self, PathBuf}; -use ptr; -use slice; -use sys::{c, cvt}; -use sys::handle::Handle; +use crate::os::windows::prelude::*; + +use crate::error::Error as StdError; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::io; +use crate::os::windows::ffi::EncodeWide; +use crate::path::{self, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::sys::{c, cvt}; +use crate::sys::handle::Handle; use super::to_u16s; @@ -285,8 +285,8 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option<PathBuf> { - ::env::var_os("HOME").or_else(|| { - ::env::var_os("USERPROFILE") + crate::env::var_os("HOME").or_else(|| { + crate::env::var_os("USERPROFILE") }).map(PathBuf::from).or_else(|| unsafe { let me = c::GetCurrentProcess(); let mut token = ptr::null_mut(); @@ -314,8 +314,8 @@ pub fn getpid() -> u32 { #[cfg(test)] mod tests { - use io::Error; - use sys::c; + use crate::io::Error; + use crate::sys::c; // tests `error_string` above #[test] diff --git a/src/libstd/sys/windows/os_str.rs b/src/libstd/sys/windows/os_str.rs index 7e4bcd990b1..8befa66ecdc 100644 --- a/src/libstd/sys/windows/os_str.rs +++ b/src/libstd/sys/windows/os_str.rs @@ -1,13 +1,13 @@ /// The underlying OsString/OsStr implementation on Windows is a /// wrapper around the "WTF-8" encoding; see the `wtf8` module for more. -use borrow::Cow; -use fmt; -use sys_common::wtf8::{Wtf8, Wtf8Buf}; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner, FromInner}; +use crate::borrow::Cow; +use crate::fmt; +use crate::sys_common::wtf8::{Wtf8, Wtf8Buf}; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner, FromInner}; #[derive(Clone, Hash)] pub struct Buf { diff --git a/src/libstd/sys/windows/path.rs b/src/libstd/sys/windows/path.rs index ad1759e84c3..b8532ca9b0d 100644 --- a/src/libstd/sys/windows/path.rs +++ b/src/libstd/sys/windows/path.rs @@ -1,6 +1,6 @@ -use path::Prefix; -use ffi::OsStr; -use mem; +use crate::path::Prefix; +use crate::ffi::OsStr; +use crate::mem; fn os_str_as_u8_slice(s: &OsStr) -> &[u8] { unsafe { mem::transmute(s) } @@ -20,7 +20,7 @@ pub fn is_verbatim_sep(b: u8) -> bool { } pub fn parse_prefix<'a>(path: &'a OsStr) -> Option<Prefix> { - use path::Prefix::*; + use crate::path::Prefix::*; unsafe { // The unsafety here stems from converting between &OsStr and &[u8] // and back. This is safe to do because (1) we only look at ASCII diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index d3b102268f6..07f4f5f0e58 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -1,17 +1,17 @@ -use os::windows::prelude::*; +use crate::os::windows::prelude::*; -use ffi::OsStr; -use io; -use mem; -use path::Path; -use ptr; -use slice; -use sync::atomic::Ordering::SeqCst; -use sync::atomic::AtomicUsize; -use sys::c; -use sys::fs::{File, OpenOptions}; -use sys::handle::Handle; -use sys::hashmap_random_keys; +use crate::ffi::OsStr; +use crate::io; +use crate::mem; +use crate::path::Path; +use crate::ptr; +use crate::slice; +use crate::sync::atomic::Ordering::SeqCst; +use crate::sync::atomic::AtomicUsize; +use crate::sys::c; +use crate::sys::fs::{File, OpenOptions}; +use crate::sys::handle::Handle; +use crate::sys::hashmap_random_keys; //////////////////////////////////////////////////////////////////////////////// // Anonymous pipes diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 2527168a968..95f061d22bd 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -1,27 +1,28 @@ #![unstable(feature = "process_internals", issue = "0")] -use collections::BTreeMap; -use env::split_paths; -use env; -use ffi::{OsString, OsStr}; -use fmt; -use fs; -use io::{self, Error, ErrorKind}; +use crate::collections::BTreeMap; +use crate::env::split_paths; +use crate::env; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::fs; +use crate::io::{self, Error, ErrorKind}; +use crate::mem; +use crate::os::windows::ffi::OsStrExt; +use crate::path::Path; +use crate::ptr; +use crate::sys::mutex::Mutex; +use crate::sys::c; +use crate::sys::fs::{OpenOptions, File}; +use crate::sys::handle::Handle; +use crate::sys::pipe::{self, AnonPipe}; +use crate::sys::stdio; +use crate::sys::cvt; +use crate::sys_common::{AsInner, FromInner, IntoInner}; +use crate::sys_common::process::{CommandEnv, EnvKey}; +use crate::borrow::Borrow; + use libc::{c_void, EXIT_SUCCESS, EXIT_FAILURE}; -use mem; -use os::windows::ffi::OsStrExt; -use path::Path; -use ptr; -use sys::mutex::Mutex; -use sys::c; -use sys::fs::{OpenOptions, File}; -use sys::handle::Handle; -use sys::pipe::{self, AnonPipe}; -use sys::stdio; -use sys::cvt; -use sys_common::{AsInner, FromInner, IntoInner}; -use sys_common::process::{CommandEnv, EnvKey}; -use borrow::Borrow; //////////////////////////////////////////////////////////////////////////////// // Command @@ -537,7 +538,7 @@ fn make_dirp(d: Option<&OsString>) -> io::Result<(*const u16, Vec<u16>)> { #[cfg(test)] mod tests { - use ffi::{OsStr, OsString}; + use crate::ffi::{OsStr, OsString}; use super::make_command_line; #[test] diff --git a/src/libstd/sys/windows/rand.rs b/src/libstd/sys/windows/rand.rs index 4f000dceb2f..0193f4defa1 100644 --- a/src/libstd/sys/windows/rand.rs +++ b/src/libstd/sys/windows/rand.rs @@ -1,6 +1,6 @@ -use io; -use mem; -use sys::c; +use crate::io; +use crate::mem; +use crate::sys::c; pub fn hashmap_random_keys() -> (u64, u64) { let mut v = (0, 0); diff --git a/src/libstd/sys/windows/rwlock.rs b/src/libstd/sys/windows/rwlock.rs index 3cd19470101..ef57562fc3a 100644 --- a/src/libstd/sys/windows/rwlock.rs +++ b/src/libstd/sys/windows/rwlock.rs @@ -1,5 +1,5 @@ -use cell::UnsafeCell; -use sys::c; +use crate::cell::UnsafeCell; +use crate::sys::c; pub struct RWLock { inner: UnsafeCell<c::SRWLOCK> } diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index 0c7de0bc9e8..d5b7765f9ff 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -1,7 +1,7 @@ #![cfg_attr(test, allow(dead_code))] -use sys_common::util::report_overflow; -use sys::c; +use crate::sys_common::util::report_overflow; +use crate::sys::c; pub struct Handler; diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index 99445f4e0d4..b1e76b3b755 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -1,13 +1,13 @@ #![unstable(issue = "0", feature = "windows_stdio")] -use char::decode_utf16; -use cmp; -use io; -use ptr; -use str; -use sys::c; -use sys::cvt; -use sys::handle::Handle; +use crate::char::decode_utf16; +use crate::cmp; +use crate::io; +use crate::ptr; +use crate::str; +use crate::sys::c; +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. @@ -201,7 +201,7 @@ fn read_u16s(handle: c::HANDLE, buf: &mut [u16]) -> io::Result<usize> { const CTRL_Z: u16 = 0x1A; const CTRL_Z_MASK: c::ULONG = 1 << CTRL_Z; let mut input_control = c::CONSOLE_READCONSOLE_CONTROL { - nLength: ::mem::size_of::<c::CONSOLE_READCONSOLE_CONTROL>() as c::ULONG, + nLength: crate::mem::size_of::<c::CONSOLE_READCONSOLE_CONTROL>() as c::ULONG, nInitialChars: 0, dwCtrlWakeupMask: CTRL_Z_MASK, dwControlKeyState: 0, diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs index bd7cb673a0d..1b0a811f13b 100644 --- a/src/libstd/sys/windows/thread.rs +++ b/src/libstd/sys/windows/thread.rs @@ -1,13 +1,14 @@ -use boxed::FnBox; -use io; -use ffi::CStr; -use mem; +use crate::boxed::FnBox; +use crate::io; +use crate::ffi::CStr; +use crate::mem; +use crate::ptr; +use crate::sys::c; +use crate::sys::handle::Handle; +use crate::sys_common::thread::*; +use crate::time::Duration; + use libc::c_void; -use ptr; -use sys::c; -use sys::handle::Handle; -use sys_common::thread::*; -use time::Duration; use super::to_u16s; diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 50bbd5476b3..4c9734fa0aa 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -1,8 +1,8 @@ -use mem; -use ptr; -use sync::atomic::AtomicPtr; -use sync::atomic::Ordering::SeqCst; -use sys::c; +use crate::mem; +use crate::ptr; +use crate::sync::atomic::AtomicPtr; +use crate::sync::atomic::Ordering::SeqCst; +use crate::sys::c; pub type Key = c::DWORD; pub type Dtor = unsafe extern fn(*mut u8); @@ -211,7 +211,7 @@ unsafe extern "system" fn on_tls_callback(h: c::LPVOID, #[cfg(target_env = "msvc")] unsafe fn reference_tls_used() { extern { static _tls_used: u8; } - ::intrinsics::volatile_load(&_tls_used); + crate::intrinsics::volatile_load(&_tls_used); } #[cfg(not(target_env = "msvc"))] unsafe fn reference_tls_used() {} diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index 8a8159af2f1..2c99bca7009 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -1,9 +1,10 @@ -use cmp::Ordering; -use fmt; -use mem; -use sys::c; -use time::Duration; -use convert::TryInto; +use crate::cmp::Ordering; +use crate::fmt; +use crate::mem; +use crate::sys::c; +use crate::time::Duration; +use crate::convert::TryInto; + use core::hash::{Hash, Hasher}; const NANOS_PER_SEC: u64 = 1_000_000_000; @@ -172,11 +173,11 @@ fn intervals2dur(intervals: u64) -> Duration { mod perf_counter { use super::{NANOS_PER_SEC}; - use sync::Once; - use sys_common::mul_div_u64; - use sys::c; - use sys::cvt; - use time::Duration; + use crate::sync::Once; + use crate::sys_common::mul_div_u64; + use crate::sys::c; + use crate::sys::cvt; + use crate::time::Duration; pub struct PerformanceCounterInstant { ts: c::LARGE_INTEGER |