mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

std::str: s/from_utf8_slice/from_utf8/, to make the basic case shorter.

Browse Source
This commit is contained in:
Huon Wilson 2013-12-02 00:33:04 +11:00
parent 9d64e46013
commit b0426edc0a
21 changed files with 70 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiletest/runtest.rs
View File

@ -298,7 +298,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
config.adb_test_dir.clone(), config.adb_test_dir.clone(),
str::from_utf8_slice(exe_file.filename().unwrap()));
str::from_utf8(exe_file.filename().unwrap()));
let mut process = procsrv::run_background("", config.adb_path.clone(),
[~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""));

2
src/libextra/ebml.rs
View File

@ -41,7 +41,7 @@ impl Doc {
}
pub fn as_str_slice<'a>(&'a self) -> &'a str {
str::from_utf8_slice(self.data.slice(self.start, self.end))
str::from_utf8(self.data.slice(self.start, self.end))
}
pub fn as_str(&self) -> ~str {

2
src/libextra/test.rs
View File

@ -701,7 +701,7 @@ fn should_sort_failures_before_printing_them() {
st.write_failures();
let s = match st.out {
Right(ref m) => str::from_utf8_slice(*m.inner_ref()),
Right(ref m) => str::from_utf8(*m.inner_ref()),
Left(_) => unreachable!()
};

4
src/librustc/back/archive.rs
View File

@ -41,8 +41,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
let o = Process::new(ar, args.as_slice(), opts).finish_with_output();
if !o.status.success() {
sess.err(format!("{} failed with: {}", ar, o.status));
sess.note(format!("stdout ---\n{}", str::from_utf8_slice(o.output)));
sess.note(format!("stderr ---\n{}", str::from_utf8_slice(o.error)));
sess.note(format!("stdout ---\n{}", str::from_utf8(o.output)));
sess.note(format!("stderr ---\n{}", str::from_utf8(o.error)));
sess.abort_if_errors();
}
o

4
src/librustc/metadata/tydecode.rs
View File

@ -98,7 +98,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident {
scan(st, is_last, |bytes| {
st.tcx.sess.ident_of(str::from_utf8_slice(bytes))
st.tcx.sess.ident_of(str::from_utf8(bytes))
})
}
@ -494,7 +494,7 @@ fn parse_abi_set(st: &mut PState) -> AbiSet {
let mut abis = AbiSet::empty();
while peek(st) != ']' {
scan(st, |c| c == ',', |bytes| {
let abi_str = str::from_utf8_slice(bytes).to_owned();
let abi_str = str::from_utf8(bytes).to_owned();
let abi = abi::lookup(abi_str).expect(abi_str);
abis.add(abi);
});

2
src/librustc/metadata/tyencode.rs
View File

@ -72,7 +72,7 @@ pub fn enc_ty(w: @mut MemWriter, cx: @ctxt, t: ty::t) {
None => {
let wr = @mut MemWriter::new();
enc_sty(wr, cx, &ty::get(t).sty);
let s = str::from_utf8_slice(*wr.inner_ref()).to_managed();
let s = str::from_utf8(*wr.inner_ref()).to_managed();
cx.tcx.short_names_cache.insert(t, s);
s
}

2
src/librustpkg/lib.rs
View File

@ -184,7 +184,7 @@ impl<'self> PkgScript<'self> {
[sysroot.as_str().unwrap().to_owned(), ~"configs"]);
debug!("run_custom: second pkg command did {:?}", output.status);
// Run the configs() function to get the configs
let cfgs = str::from_utf8_slice(output.output).words()
let cfgs = str::from_utf8(output.output).words()
.map(|w| w.to_owned()).collect();
(cfgs, output.status)
}

32
src/librustpkg/tests.rs
View File

@ -154,7 +154,7 @@ fn run_git(args: &[~str], env: Option<~[(~str, ~str)]>, cwd: &Path, err_msg: &st
let rslt = prog.finish_with_output();
if !rslt.status.success() {
fail!("{} [git returned {:?}, output = {}, error = {}]", err_msg,
rslt.status, str::from_utf8_slice(rslt.output), str::from_utf8_slice(rslt.error));
rslt.status, str::from_utf8(rslt.output), str::from_utf8(rslt.error));
}
}
@ -290,13 +290,13 @@ fn command_line_test_with_env(args: &[~str], cwd: &Path, env: Option<~[(~str, ~s
});
let output = prog.finish_with_output();
debug!("Output from command {} with args {:?} was {} \\{{}\\}[{:?}]",
cmd, args, str::from_utf8_slice(output.output),
str::from_utf8_slice(output.error),
cmd, args, str::from_utf8(output.output),
str::from_utf8(output.error),
output.status);
if !output.status.success() {
debug!("Command {} {:?} failed with exit code {:?}; its output was --- {} ---",
debug!("Command {} {:?} failed with exit code {:?}; its output was --- {} {} ---",
cmd, args, output.status,
str::from_utf8_slice(output.output) + str::from_utf8_slice(output.error));
str::from_utf8(output.output), str::from_utf8(output.error));
Fail(output)
}
else {
@ -455,7 +455,7 @@ fn built_library_exists(repo: &Path, short_name: &str) -> bool {
fn command_line_test_output(args: &[~str]) -> ~[~str] {
let mut result = ~[];
let p_output = command_line_test(args, &os::getcwd());
let test_output = str::from_utf8_slice(p_output.output);
let test_output = str::from_utf8(p_output.output);
for s in test_output.split('\n') {
result.push(s.to_owned());
}
@ -469,7 +469,7 @@ fn command_line_test_output_with_env(args: &[~str], env: ~[(~str, ~str)]) -> ~[~
Fail(_) => fail!("Command-line test failed"),
Success(r) => r
};
let test_output = str::from_utf8_slice(p_output.output);
let test_output = str::from_utf8(p_output.output);
for s in test_output.split('\n') {
result.push(s.to_owned());
}
@ -1212,7 +1212,7 @@ fn test_uninstall() {
let workspace = create_local_package(&PkgId::new("foo"));
command_line_test([~"uninstall", ~"foo"], workspace.path());
let output = command_line_test([~"list"], workspace.path());
assert!(!str::from_utf8_slice(output.output).contains("foo"));
assert!(!str::from_utf8(output.output).contains("foo"));
}
#[test]
@ -1282,8 +1282,8 @@ fn test_extern_mod() {
let outp = prog.finish_with_output();
if !outp.status.success() {
fail!("output was {}, error was {}",
str::from_utf8_slice(outp.output),
str::from_utf8_slice(outp.error));
str::from_utf8(outp.output),
str::from_utf8(outp.error));
}
assert!(exec_file.exists() && is_executable(&exec_file));
}
@ -1337,8 +1337,8 @@ fn test_extern_mod_simpler() {
let outp = prog.finish_with_output();
if !outp.status.success() {
fail!("output was {}, error was {}",
str::from_utf8_slice(outp.output),
str::from_utf8_slice(outp.error));
str::from_utf8(outp.output),
str::from_utf8(outp.error));
}
assert!(exec_file.exists() && is_executable(&exec_file));
}
@ -2101,7 +2101,7 @@ fn test_rustpkg_test_creates_exec() {
fn test_rustpkg_test_output() {
let workspace = create_local_package_with_test(&PkgId::new("foo"));
let output = command_line_test([~"test", ~"foo"], workspace.path());
let output_str = str::from_utf8_slice(output.output);
let output_str = str::from_utf8(output.output);
// The first two assertions are separate because test output may
// contain color codes, which could appear between "test f" and "ok".
assert!(output_str.contains("test f"));
@ -2132,7 +2132,7 @@ fn test_rustpkg_test_cfg() {
"#[test] #[cfg(not(foobar))] fn f() { assert!('a' != 'a'); }");
let output = command_line_test([~"test", ~"--cfg", ~"foobar", ~"foo"],
foo_workspace);
let output_str = str::from_utf8_slice(output.output);
let output_str = str::from_utf8(output.output);
assert!(output_str.contains("0 passed; 0 failed; 0 ignored; 0 measured"));
}
@ -2430,8 +2430,8 @@ fn correct_error_dependency() {
Fail(ProcessOutput{ error: error, output: output, .. }) => {
assert!(str::is_utf8(error));
assert!(str::is_utf8(output));
let error_str = str::from_utf8_slice(error);
let out_str = str::from_utf8_slice(output);
let error_str = str::from_utf8(error);
let out_str = str::from_utf8(output);
debug!("ss = {}", error_str);
debug!("out_str = {}", out_str);
if out_str.contains("Package badpkg depends on some_package_that_doesnt_exist") &&

8
src/librustpkg/version.rs
View File

@ -114,7 +114,7 @@ pub fn try_getting_local_version(local_path: &Path) -> Option<Version> {
}
let mut output = None;
let output_text = str::from_utf8_slice(outp.output);
let output_text = str::from_utf8(outp.output);
for l in output_text.lines() {
if !l.is_whitespace() {
output = Some(l);
@ -145,8 +145,8 @@ pub fn try_getting_version(remote_path: &Path) -> Option<Version> {
tmp_dir.as_str().unwrap().to_owned()]);
if outp.status.success() {
debug!("Cloned it... ( {}, {} )",
str::from_utf8_slice(outp.output),
str::from_utf8_slice(outp.error));
str::from_utf8(outp.output),
str::from_utf8(outp.error));
let mut output = None;
let git_dir = tmp_dir.join(".git");
debug!("(getting version, now getting tags) executing \\{git --git-dir={} tag -l\\}",
@ -155,7 +155,7 @@ pub fn try_getting_version(remote_path: &Path) -> Option<Version> {
let outp = run::process_output("git",
["--git-dir=" + git_dir.as_str().unwrap(),
~"tag", ~"-l"]);
let output_text = str::from_utf8_slice(outp.output);
let output_text = str::from_utf8(outp.output);
debug!("Full output: ( {} ) [{:?}]", output_text, outp.status);
for l in output_text.lines() {
debug!("A line of output: {}", l);

2
src/librustuv/file.rs
View File

@ -487,7 +487,7 @@ mod test {
let nread = result.unwrap();
assert!(nread > 0);
let read_str = str::from_utf8_slice(read_mem.slice_to(nread as uint));
let read_str = str::from_utf8(read_mem.slice_to(nread as uint));
assert_eq!(read_str, "hello");
}
// unlink

2
src/librustuv/net.rs
View File

@ -81,7 +81,7 @@ pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
};
port as u16
};
let ip_str = str::from_utf8_slice(ip_name).trim_right_chars(&'\x00');
let ip_str = str::from_utf8(ip_name).trim_right_chars(&'\x00');
let ip_addr = FromStr::from_str(ip_str).unwrap();
SocketAddr { ip: ip_addr, port: ip_port }

2
src/libstd/c_str.rs
View File

@ -167,7 +167,7 @@ impl CString {
if self.buf.is_null() { return None; }
let buf = self.as_bytes();
let buf = buf.slice_to(buf.len()-1); // chop off the trailing NUL
str::from_utf8_slice_opt(buf)
str::from_utf8_opt(buf)
}
/// Return a CString iterator.

2
src/libstd/fmt/mod.rs
View File

@ -802,7 +802,7 @@ impl<'self> Formatter<'self> {
fn runplural(&mut self, value: uint, pieces: &[rt::Piece]) {
::uint::to_str_bytes(value, 10, |buf| {
let valuestr = str::from_utf8_slice(buf);
let valuestr = str::from_utf8(buf);
for piece in pieces.iter() {
self.run(piece, Some(valuestr));
}

2
src/libstd/io/flate.rs
View File

@ -117,7 +117,7 @@ mod test {
let mut out_bytes = [0, .. 100];
let bytes_read = inflate_reader.read(out_bytes).unwrap();
assert_eq!(bytes_read, in_bytes.len());
let out_msg = str::from_utf8_slice(out_bytes);
let out_msg = str::from_utf8(out_bytes);
assert_eq!(in_msg, out_msg);
}
}

14
src/libstd/io/fs.rs
View File

@ -821,7 +821,7 @@ mod test {
}
}
unlink(filename);
let read_str = str::from_utf8_slice(read_mem);
let read_str = str::from_utf8(read_mem);
assert_eq!(read_str, message);
})
@ -845,7 +845,7 @@ mod test {
tell_pos_post_read = read_stream.tell();
}
unlink(filename);
let read_str = str::from_utf8_slice(read_mem);
let read_str = str::from_utf8(read_mem);
assert_eq!(read_str, message.slice(4, 8));
assert_eq!(tell_pos_pre_read, set_cursor);
assert_eq!(tell_pos_post_read, message.len() as u64);
@ -870,7 +870,7 @@ mod test {
read_stream.read(read_mem);
}
unlink(filename);
let read_str = str::from_utf8_slice(read_mem);
let read_str = str::from_utf8(read_mem);
assert!(read_str == final_msg.to_owned());
})
@ -892,15 +892,15 @@ mod test {
read_stream.seek(-4, SeekEnd);
read_stream.read(read_mem);
assert_eq!(str::from_utf8_slice(read_mem), chunk_three);
assert_eq!(str::from_utf8(read_mem), chunk_three);
read_stream.seek(-9, SeekCur);
read_stream.read(read_mem);
assert_eq!(str::from_utf8_slice(read_mem), chunk_two);
assert_eq!(str::from_utf8(read_mem), chunk_two);
read_stream.seek(0, SeekSet);
read_stream.read(read_mem);
assert_eq!(str::from_utf8_slice(read_mem), chunk_one);
assert_eq!(str::from_utf8(read_mem), chunk_one);
}
unlink(filename);
})
@ -974,7 +974,7 @@ mod test {
{
let n = f.filestem_str();
File::open(f).read(mem);
let read_str = str::from_utf8_slice(mem);
let read_str = str::from_utf8(mem);
let expected = match n {
None|Some("") => fail!("really shouldn't happen.."),
Some(n) => prefix+n

2
src/libstd/io/mod.rs
View File

@ -1049,7 +1049,7 @@ pub trait Buffer: Reader {
Some(n) if n == width => {}
Some(..) | None => return None // read error
}
match str::from_utf8_slice_opt(buf.slice_to(width)) {
match str::from_utf8_opt(buf.slice_to(width)) {
Some(s) => Some(s.char_at(0)),
None => None
}

14
src/libstd/path/mod.rs
View File

@ -176,7 +176,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// If the path is not representable in utf-8, this returns None.
#[inline]
fn as_str<'a>(&'a self) -> Option<&'a str> {
str::from_utf8_slice_opt(self.as_vec())
str::from_utf8_opt(self.as_vec())
}
/// Returns the path as a byte vector
@ -207,7 +207,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// See `dirname` for details.
#[inline]
fn dirname_str<'a>(&'a self) -> Option<&'a str> {
str::from_utf8_slice_opt(self.dirname())
str::from_utf8_opt(self.dirname())
}
/// Returns the file component of `self`, as a byte vector.
/// If `self` represents the root of the file hierarchy, returns None.
@ -217,7 +217,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// See `filename` for details.
#[inline]
fn filename_str<'a>(&'a self) -> Option<&'a str> {
self.filename().and_then(str::from_utf8_slice_opt)
self.filename().and_then(str::from_utf8_opt)
}
/// Returns the stem of the filename of `self`, as a byte vector.
/// The stem is the portion of the filename just before the last '.'.
@ -239,7 +239,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// See `filestem` for details.
#[inline]
fn filestem_str<'a>(&'a self) -> Option<&'a str> {
self.filestem().and_then(str::from_utf8_slice_opt)
self.filestem().and_then(str::from_utf8_opt)
}
/// Returns the extension of the filename of `self`, as an optional byte vector.
/// The extension is the portion of the filename just after the last '.'.
@ -262,7 +262,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
/// See `extension` for details.
#[inline]
fn extension_str<'a>(&'a self) -> Option<&'a str> {
self.extension().and_then(str::from_utf8_slice_opt)
self.extension().and_then(str::from_utf8_opt)
}
/// Replaces the filename portion of the path with the given byte vector or string.
@ -493,12 +493,12 @@ pub trait BytesContainer {
/// Raises `str::null_byte` if not utf-8
#[inline]
fn container_as_str<'a>(&'a self) -> &'a str {
str::from_utf8_slice(self.container_as_bytes())
str::from_utf8(self.container_as_bytes())
}
/// Returns the receiver interpreted as a utf-8 string, if possible
#[inline]
fn container_as_str_opt<'a>(&'a self) -> Option<&'a str> {
str::from_utf8_slice_opt(self.container_as_bytes())
str::from_utf8_opt(self.container_as_bytes())
}
/// Returns whether .container_as_str() is guaranteed to not fail
// FIXME (#8888): Remove unused arg once ::<for T> works

6
src/libstd/path/posix.rs
View File

@ -396,13 +396,13 @@ impl Path {
/// Returns an iterator that yields each component of the path as Option<&str>.
/// See components() for details.
pub fn str_components<'a>(&'a self) -> StrComponentIter<'a> {
self.components().map(str::from_utf8_slice_opt)
self.components().map(str::from_utf8_opt)
}
/// Returns an iterator that yields each component of the path in reverse as Option<&str>.
/// See components() for details.
pub fn rev_str_components<'a>(&'a self) -> RevStrComponentIter<'a> {
self.rev_components().map(str::from_utf8_slice_opt)
self.rev_components().map(str::from_utf8_opt)
}
}
@ -684,7 +684,7 @@ mod tests {
(s: $path:expr, $op:ident, $exp:expr, opt) => (
{
let path = Path::init($path);
let left = path.$op().map(|x| str::from_utf8_slice(x));
let left = path.$op().map(|x| str::from_utf8(x));
assert_eq!(left, $exp);
}
);

30
src/libstd/str.rs
View File

@ -159,16 +159,16 @@ pub fn from_utf8_owned_opt(vv: ~[u8]) -> Option<~str> {
/// # Failure
///
/// Fails if invalid UTF-8
pub fn from_utf8_slice<'a>(v: &'a [u8]) -> &'a str {
from_utf8_slice_opt(v).expect("from_utf8_slice: not utf-8")
pub fn from_utf8<'a>(v: &'a [u8]) -> &'a str {
from_utf8_opt(v).expect("from_utf8: not utf-8")
}
/// Converts a vector to a string slice without performing any allocations.
///
/// Returns None if the slice is not utf-8.
pub fn from_utf8_slice_opt<'a>(v: &'a [u8]) -> Option<&'a str> {
pub fn from_utf8_opt<'a>(v: &'a [u8]) -> Option<&'a str> {
if is_utf8(v) {
Some(unsafe { raw::from_utf8_slice(v) })
Some(unsafe { raw::from_utf8(v) })
} else { None }
}
@ -1029,7 +1029,7 @@ pub mod raw {
/// Converts a slice of bytes to a string slice without checking
/// that the string contains valid UTF-8.
pub unsafe fn from_utf8_slice<'a>(v: &'a [u8]) -> &'a str {
pub unsafe fn from_utf8<'a>(v: &'a [u8]) -> &'a str {
cast::transmute(v)
}
@ -3153,7 +3153,7 @@ mod tests {
let s1: ~str = ~"All mimsy were the borogoves";
let v: ~[u8] = s1.as_bytes().to_owned();
let s2: ~str = from_utf8_slice(v).to_owned();
let s2: ~str = from_utf8(v).to_owned();
let mut i: uint = 0u;
let n1: uint = s1.len();
let n2: uint = v.len();
@ -3676,31 +3676,31 @@ mod tests {
}
#[test]
fn test_str_from_utf8_slice() {
fn test_str_from_utf8() {
let xs = bytes!("hello");
assert_eq!(from_utf8_slice(xs), "hello");
assert_eq!(from_utf8(xs), "hello");
let xs = bytes!("ศไทย中华Việt Nam");
assert_eq!(from_utf8_slice(xs), "ศไทย中华Việt Nam");
assert_eq!(from_utf8(xs), "ศไทย中华Việt Nam");
}
#[test]
#[should_fail]
fn test_str_from_utf8_slice_invalid() {
fn test_str_from_utf8_invalid() {
let xs = bytes!("hello", 0xff);
let _ = from_utf8_slice(xs);
let _ = from_utf8(xs);
}
#[test]
fn test_str_from_utf8_slice_opt() {
fn test_str_from_utf8_opt() {
let xs = bytes!("hello");
assert_eq!(from_utf8_slice_opt(xs), Some("hello"));
assert_eq!(from_utf8_opt(xs), Some("hello"));
let xs = bytes!("ศไทย中华Việt Nam");
assert_eq!(from_utf8_slice_opt(xs), Some("ศไทย中华Việt Nam"));
assert_eq!(from_utf8_opt(xs), Some("ศไทย中华Việt Nam"));
let xs = bytes!("hello", 0xff);
assert_eq!(from_utf8_slice_opt(xs), None);
assert_eq!(from_utf8_opt(xs), None);
}
#[test]

4
src/test/run-pass/const-str-ptr.rs
View File

@ -17,13 +17,13 @@ static C: *u8 = B as *u8;
pub fn main() {
unsafe {
let foo = &A as *u8;
assert_eq!(str::raw::from_utf8_slice(A), "hi");
assert_eq!(str::raw::from_utf8(A), "hi");
assert_eq!(str::raw::from_buf_len(foo, A.len()), ~"hi");
assert_eq!(str::raw::from_buf_len(C, B.len()), ~"hi");
assert!(*C == A[0]);
assert!(*(&B[0] as *u8) == A[0]);
let bar = str::raw::from_utf8_slice(A).to_c_str();
let bar = str::raw::from_utf8(A).to_c_str();
assert_eq!(bar.with_ref(|buf| str::raw::from_c_str(buf)), ~"hi");
}
}

2
src/test/run-pass/rtio-processes.rs
View File

@ -108,7 +108,7 @@ fn read_all(input: &mut Reader) -> ~str {
loop {
match input.read(buf) {
None => { break }
Some(n) => { ret.push_str(str::from_utf8_slice(buf.slice_to(n))); }
Some(n) => { ret.push_str(str::from_utf8(buf.slice_to(n))); }
}
}
return ret;