#![allow(non_snake_case_functions)]
use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
use fmt;
use io::{IoResult, IoError};
use iter::Iterator;
use result::{Err, Ok, Result};
use slice::{Vector, ImmutableVector, MutableVector, ImmutableEqVector};
use str::{Str, StrSlice, StrAllocating};
-use str;
use string::String;
use sync::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst};
use vec::Vec;
use c_str::ToCStr;
#[cfg(unix)]
use libc::c_char;
-#[cfg(windows)]
-use str::OwnedStr;
/// Get the number of cores available
pub fn num_cpus() -> uint {
fail!();
}
}
- Path::new(String::from_utf16(str::truncate_utf16_at_nul(buf))
+ Path::new(String::from_utf16(::str::truncate_utf16_at_nul(buf))
.expect("GetCurrentDirectoryW returned invalid UTF-16"))
}
use slice::{MutableVector, ImmutableVector};
use string::String;
use str::StrSlice;
- use str;
use vec::Vec;
pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD)
/// Returns a vector of (variable, value) pairs, for all the environment
/// variables of the current process.
///
-/// Invalid UTF-8 bytes are replaced with \uFFFD. See `str::from_utf8_lossy()`
+/// Invalid UTF-8 bytes are replaced with \uFFFD. See `String::from_utf8_lossy()`
/// for details.
///
/// # Example
/// ```
pub fn env() -> Vec<(String,String)> {
env_as_bytes().move_iter().map(|(k,v)| {
- let k = String::from_str(str::from_utf8_lossy(k.as_slice()).as_slice());
- let v = String::from_str(str::from_utf8_lossy(v.as_slice()).as_slice());
+ let k = String::from_utf8_lossy(k.as_slice()).into_string();
+ let v = String::from_utf8_lossy(v.as_slice()).into_string();
(k,v)
}).collect()
}
/// None if the variable isn't set.
///
/// Any invalid UTF-8 bytes in the value are replaced by \uFFFD. See
-/// `str::from_utf8_lossy()` for details.
+/// `String::from_utf8_lossy()` for details.
///
/// # Failure
///
/// }
/// ```
pub fn getenv(n: &str) -> Option<String> {
- getenv_as_bytes(n).map(|v| String::from_str(str::from_utf8_lossy(v.as_slice()).as_slice()))
+ getenv_as_bytes(n).map(|v| String::from_utf8_lossy(v.as_slice()).into_string())
}
#[cfg(unix)]
fn _setenv(n: &str, v: &[u8]) {
let n: Vec<u16> = n.utf16_units().collect();
let n = n.append_one(0);
- let v: Vec<u16> = str::from_utf8(v).unwrap().utf16_units().collect();
+ let v: Vec<u16> = ::str::from_utf8(v).unwrap().utf16_units().collect();
let v = v.append_one(0);
unsafe {
pub fn self_exe_name() -> Option<Path> {
#[cfg(target_os = "freebsd")]
+ #[cfg(target_os = "dragonfly")]
fn load_self() -> Option<Vec<u8>> {
unsafe {
use libc::funcs::bsd44::*;
#[cfg(windows)]
fn load_self() -> Option<Vec<u8>> {
- use str::OwnedStr;
-
unsafe {
use os::win32::fill_utf16_buf_and_decode;
fill_utf16_buf_and_decode(|buf, sz| {
}
}
+ #[cfg(target_os = "dragonfly")]
+ fn errno_location() -> *const c_int {
+ extern {
+ fn __dfly_error() -> *const c_int;
+ }
+ unsafe {
+ __dfly_error()
+ }
+ }
+
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
fn errno_location() -> *const c_int {
#[cfg(target_os = "ios")]
#[cfg(target_os = "android")]
#[cfg(target_os = "freebsd")]
+ #[cfg(target_os = "dragonfly")]
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: libc::size_t)
-> c_int {
extern {
fail!("strerror_r failure");
}
- str::raw::from_c_str(p as *const c_char).into_string()
+ ::string::raw::from_buf(p as *const u8)
}
}
return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err);
}
- let msg = String::from_utf16(str::truncate_utf16_at_nul(buf));
+ let msg = String::from_utf16(::str::truncate_utf16_at_nul(buf));
match msg {
Some(msg) => format!("OS Error {}: {}", errnum, msg),
None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
#[cfg(target_os = "freebsd")]
+#[cfg(target_os = "dragonfly")]
fn real_args_as_bytes() -> Vec<Vec<u8>> {
use rt;
fn real_args() -> Vec<String> {
real_args_as_bytes().move_iter()
.map(|v| {
- str::from_utf8_lossy(v.as_slice()).into_string()
+ String::from_utf8_lossy(v.as_slice()).into_string()
}).collect()
}
// Push it onto the list.
let opt_s = slice::raw::buf_as_slice(ptr as *const _, len, |buf| {
- String::from_utf16(str::truncate_utf16_at_nul(buf))
+ String::from_utf16(::str::truncate_utf16_at_nul(buf))
});
opt_s.expect("CommandLineToArgvW returned invalid UTF-16")
});
/// via the command line).
///
/// The arguments are interpreted as utf-8, with invalid bytes replaced with \uFFFD.
-/// See `str::from_utf8_lossy` for details.
+/// See `String::from_utf8_lossy` for details.
/// # Example
///
/// ```rust
pub static EXE_EXTENSION: &'static str = "";
}
+#[cfg(target_os = "dragonfly")]
+pub mod consts {
+ pub use os::arch_consts::ARCH;
+
+ pub static FAMILY: &'static str = "unix";
+
+ /// A string describing the specific operating system in use: in this
+ /// case, `dragonfly`.
+ pub static SYSNAME: &'static str = "dragonfly";
+
+ /// Specifies the filename prefix used for shared libraries on this
+ /// platform: in this case, `lib`.
+ pub static DLL_PREFIX: &'static str = "lib";
+
+ /// Specifies the filename suffix used for shared libraries on this
+ /// platform: in this case, `.so`.
+ pub static DLL_SUFFIX: &'static str = ".so";
+
+ /// Specifies the file extension used for shared libraries on this
+ /// platform that goes after the dot: in this case, `so`.
+ pub static DLL_EXTENSION: &'static str = "so";
+
+ /// Specifies the filename suffix used for executable binaries on this
+ /// platform: in this case, the empty string.
+ pub static EXE_SUFFIX: &'static str = "";
+
+ /// Specifies the file extension, if any, used for executable binaries
+ /// on this platform: in this case, the empty string.
+ pub static EXE_EXTENSION: &'static str = "";
+}
+
#[cfg(target_os = "android")]
pub mod consts {
pub use os::arch_consts::ARCH;