use fmt;
use io::{IoResult, IoError};
use iter::{Iterator, IteratorExt};
+use kinds::Copy;
use libc::{c_void, c_int};
use libc;
use boxed::Box;
use ops::Drop;
-use option::{Some, None, Option};
+use option::Option;
+use option::Option::{Some, None};
use os;
use path::{Path, GenericPath, BytesContainer};
use sys;
use sys::os as os_imp;
use ptr::RawPtr;
use ptr;
-use result::{Err, Ok, Result};
+use result::Result;
+use result::Result::{Err, Ok};
use slice::{AsSlice, SlicePrelude, PartialEqSlicePrelude};
use slice::CloneSliceAllocPrelude;
use str::{Str, StrPrelude, StrAllocating};
}
#[cfg(windows)]
-pub mod windows {
+pub mod windoze {
use libc::types::os::arch::extra::DWORD;
use libc;
- use option::{None, Option};
+ use option::Option;
+ use option::Option::None;
use option;
use os::TMPBUF_SZ;
use slice::{SlicePrelude};
// set `res` to None and continue.
let s = String::from_utf16(sub)
.expect("fill_utf16_buf_and_decode: closure created invalid UTF-16");
- res = option::Some(s)
+ res = option::Option::Some(s)
}
}
return res;
fn env_convert(input: Vec<Vec<u8>>) -> Vec<(Vec<u8>, Vec<u8>)> {
let mut pairs = Vec::new();
for p in input.iter() {
- let mut it = p.as_slice().splitn(1, |b| *b == b'=');
+ let mut it = p.splitn(1, |b| *b == b'=');
let key = it.next().unwrap().to_vec();
let default: &[u8] = &[];
let val = it.next().unwrap_or(default).to_vec();
pub fn getenv(n: &str) -> Option<String> {
unsafe {
with_env_lock(|| {
- use os::windows::{fill_utf16_buf_and_decode};
+ use os::windoze::{fill_utf16_buf_and_decode};
let mut n: Vec<u16> = n.utf16_units().collect();
n.push(0);
fill_utf16_buf_and_decode(|buf, sz| {
pub writer: c_int,
}
+impl Copy for Pipe {}
+
/// Creates a new low-level OS in-memory pipe.
///
/// This function can fail to succeed if there are no more resources available
#[cfg(windows)]
fn load_self() -> Option<Vec<u8>> {
unsafe {
- use os::windows::fill_utf16_buf_and_decode;
+ use os::windoze::fill_utf16_buf_and_decode;
fill_utf16_buf_and_decode(|buf, sz| {
libc::GetModuleFileNameW(0u as libc::DWORD, buf, sz)
}).map(|s| s.into_string().into_bytes())
kind: MemoryMapKind,
}
+#[cfg(not(stage0))]
+impl Copy for MemoryMap {}
+
/// Type of memory map
pub enum MemoryMapKind {
/// Virtual memory map. Usually used to change the permissions of a given
MapVirtual
}
+impl Copy for MemoryMapKind {}
+
/// Options the memory map is created with
pub enum MapOption {
/// The memory should be readable
/// Create a map for a specific address range. Corresponds to `MAP_FIXED` on
/// POSIX.
MapAddr(*const u8),
+ /// Create a memory mapping for a file with a given HANDLE.
+ #[cfg(windows)]
+ MapFd(libc::HANDLE),
/// Create a memory mapping for a file with a given fd.
+ #[cfg(not(windows))]
MapFd(c_int),
/// When using `MapFd`, the start of the map is `uint` bytes from the start
/// of the file.
MapNonStandardFlags(c_int),
}
+impl Copy for MapOption {}
+
/// Possible errors when creating a map.
pub enum MapError {
/// ## The following are POSIX-specific
ErrMapViewOfFile(uint)
}
+impl Copy for MapError {}
+
impl fmt::Show for MapError {
fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
let str = match *self {
let mut readable = false;
let mut writable = false;
let mut executable = false;
- let mut fd: c_int = -1;
+ let mut handle: HANDLE = libc::INVALID_HANDLE_VALUE;
let mut offset: uint = 0;
let len = round_up(min_len, page_size());
MapWritable => { writable = true; },
MapExecutable => { executable = true; }
MapAddr(addr_) => { lpAddress = addr_ as LPVOID; },
- MapFd(fd_) => { fd = fd_; },
+ MapFd(handle_) => { handle = handle_; },
MapOffset(offset_) => { offset = offset_; },
MapNonStandardFlags(..) => {}
}
}
let flProtect = match (executable, readable, writable) {
- (false, false, false) if fd == -1 => libc::PAGE_NOACCESS,
+ (false, false, false) if handle == libc::INVALID_HANDLE_VALUE => libc::PAGE_NOACCESS,
(false, true, false) => libc::PAGE_READONLY,
(false, true, true) => libc::PAGE_READWRITE,
- (true, false, false) if fd == -1 => libc::PAGE_EXECUTE,
+ (true, false, false) if handle == libc::INVALID_HANDLE_VALUE => libc::PAGE_EXECUTE,
(true, true, false) => libc::PAGE_EXECUTE_READ,
(true, true, true) => libc::PAGE_EXECUTE_READWRITE,
_ => return Err(ErrUnsupProt)
};
- if fd == -1 {
+ if handle == libc::INVALID_HANDLE_VALUE {
if offset != 0 {
return Err(ErrUnsupOffset);
}
// we should never get here.
};
unsafe {
- let hFile = libc::get_osfhandle(fd) as HANDLE;
+ let hFile = handle;
let mapping = libc::CreateFileMappingW(hFile,
ptr::null_mut(),
flProtect,
fn test_setenv() {
let n = make_rand_name();
setenv(n.as_slice(), "VALUE");
- assert_eq!(getenv(n.as_slice()), option::Some("VALUE".to_string()));
+ assert_eq!(getenv(n.as_slice()), option::Option::Some("VALUE".to_string()));
}
#[test]
let n = make_rand_name();
setenv(n.as_slice(), "VALUE");
unsetenv(n.as_slice());
- assert_eq!(getenv(n.as_slice()), option::None);
+ assert_eq!(getenv(n.as_slice()), option::Option::None);
}
#[test]
let n = make_rand_name();
setenv(n.as_slice(), "1");
setenv(n.as_slice(), "2");
- assert_eq!(getenv(n.as_slice()), option::Some("2".to_string()));
+ assert_eq!(getenv(n.as_slice()), option::Option::Some("2".to_string()));
setenv(n.as_slice(), "");
- assert_eq!(getenv(n.as_slice()), option::Some("".to_string()));
+ assert_eq!(getenv(n.as_slice()), option::Option::Some("".to_string()));
}
// Windows GetEnvironmentVariable requires some extra work to make sure
let n = make_rand_name();
setenv(n.as_slice(), s.as_slice());
debug!("{}", s.clone());
- assert_eq!(getenv(n.as_slice()), option::Some(s));
+ assert_eq!(getenv(n.as_slice()), option::Option::Some(s));
}
#[test]
// MingW seems to set some funky environment variables like
// "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned
// from env() but not visible from getenv().
- assert!(v2.is_none() || v2 == option::Some(v));
+ assert!(v2.is_none() || v2 == option::Option::Some(v));
}
}
#[test]
fn memory_map_rw() {
- use result::{Ok, Err};
+ use result::Result::{Ok, Err};
let chunk = match os::MemoryMap::new(16, &[
os::MapReadable,
#[test]
fn memory_map_file() {
- use result::{Ok, Err};
use os::*;
- use libc::*;
- use io::fs;
-
- #[cfg(unix)]
- fn lseek_(fd: c_int, size: uint) {
- unsafe {
- assert!(lseek(fd, size as off_t, SEEK_SET) == size as off_t);
- }
+ use io::fs::{File, unlink};
+ use io::SeekStyle::SeekSet;
+ use io::FileMode::Open;
+ use io::FileAccess::ReadWrite;
+ use libc::HANDLE;
+
+ #[cfg(not(windows))]
+ fn get_fd(file: &File) -> c_int {
+ use os::unix::AsRawFd;
+ file.as_raw_fd()
}
+
#[cfg(windows)]
- fn lseek_(fd: c_int, size: uint) {
- unsafe {
- assert!(lseek(fd, size as c_long, SEEK_SET) == size as c_long);
- }
+ fn get_fd(file: &File) -> HANDLE {
+ use os::windows::AsRawHandle;
+ file.as_raw_handle()
}
let mut path = tmpdir();
path.push("mmap_file.tmp");
let size = MemoryMap::granularity() * 2;
+ let mut file = File::open_mode(&path, Open, ReadWrite).unwrap();
+ file.seek(size as i64, SeekSet);
+ file.write_u8(0);
- let fd = unsafe {
- let fd = path.with_c_str(|path| {
- open(path, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR)
- });
- lseek_(fd, size);
- "x".with_c_str(|x| assert!(write(fd, x as *const c_void, 1) == 1));
- fd
- };
- let chunk = match MemoryMap::new(size / 2, &[
+ let chunk = MemoryMap::new(size / 2, &[
MapReadable,
MapWritable,
- MapFd(fd),
+ MapFd(get_fd(&file)),
MapOffset(size / 2)
- ]) {
- Ok(chunk) => chunk,
- Err(msg) => panic!("{}", msg)
- };
+ ]).unwrap();
assert!(chunk.len > 0);
unsafe {
*chunk.data = 0xbe;
assert!(*chunk.data == 0xbe);
- close(fd);
}
drop(chunk);
- fs::unlink(&path).unwrap();
+ unlink(&path).unwrap();
}
#[test]
#[cfg(unix)]
fn join_paths_unix() {
fn test_eq(input: &[&str], output: &str) -> bool {
- join_paths(input).unwrap().as_slice() == output.as_bytes()
+ join_paths(input).unwrap() == output.as_bytes()
}
assert!(test_eq(&[], ""));
#[cfg(windows)]
fn join_paths_windows() {
fn test_eq(input: &[&str], output: &str) -> bool {
- join_paths(input).unwrap().as_slice() == output.as_bytes()
+ join_paths(input).unwrap() == output.as_bytes()
}
assert!(test_eq(&[], ""));
projects / rust.git / blobdiff