bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

(core::char) rename slice -> slice_chars

Browse source
This commit is contained in:
Kevin Cantu 2012-02-21 22:08:32 -08:00 • committed by Marijn Haverbeke
parent 1cd5a0945a
commit 454b53a7c2
8 changed files with 37 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/cargo/cargo.rs
View file

@ -177,7 +177,7 @@ fn rest(s: str, start: uint) -> str {
if (start >= str::len_chars(s)) {
""
} else {
str::slice(s, start, str::len_chars(s))
str::slice_chars(s, start, str::len_chars(s))
}
}
@ -688,8 +688,8 @@ fn cmd_install(c: cargo) unsafe {
let uuid = rest(target, 5u);
alt str::index_chars(uuid, '/') {
option::some(idx) {
let source = str::slice(uuid, 0u, idx);
uuid = str::slice(uuid, idx + 1u, str::len_chars(uuid));
let source = str::slice_chars(uuid, 0u, idx);
uuid = str::slice_chars(uuid, idx + 1u, str::len_chars(uuid));
install_uuid_specific(c, wd, source, uuid);
}
option::none {
@ -700,8 +700,8 @@ fn cmd_install(c: cargo) unsafe {
let name = target;
alt str::index_chars(name, '/') {
option::some(idx) {
let source = str::slice(name, 0u, idx);
name = str::slice(name, idx + 1u, str::len_chars(name));
let source = str::slice_chars(name, 0u, idx);
name = str::slice_chars(name, idx + 1u, str::len_chars(name));
install_named_specific(c, wd, source, name);
}
option::none {

2
src/comp/back/link.rs
View file

@ -111,7 +111,7 @@ mod write {
fn mk_intermediate_name(output_path: str, extension: str) -> str unsafe {
let stem = alt str::index_chars(output_path, '.') {
option::some(dot_pos) {
str::slice(output_path, 0u, dot_pos)
str::slice_chars(output_path, 0u, dot_pos)
}
option::none { output_path }
};

4
src/comp/syntax/codemap.rs
View file

@ -180,13 +180,13 @@ fn span_to_snippet(sp: span, cm: codemap::codemap) -> str {
let begin = lookup_byte_offset(cm,sp.lo);
let end = lookup_byte_offset(cm,sp.hi);
assert begin.fm == end.fm;
ret str::slice(*begin.fm.src, begin.pos, end.pos);
ret str::slice_chars(*begin.fm.src, begin.pos, end.pos);
}
fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> str
{
let fm = cm.files[fidx];
ret str::slice(*fm.src, lo, hi)
ret str::slice_chars(*fm.src, lo, hi)
}
fn get_filemap(cm: codemap, filename: str) -> filemap {

2
src/fuzzer/fuzzer.rs
View file

@ -287,7 +287,7 @@ fn check_variants_T<T: copy>(
fn last_part(filename: str) -> str {
let ix = option::get(str::rindex_chars(filename, '/'));
str::slice(filename, ix + 1u, str::len_chars(filename) - 3u)
str::slice_chars(filename, ix + 1u, str::len_chars(filename) - 3u)
}
enum happiness { passed, cleanly_rejected(str), known_bug(str), failed(str), }

30
src/libcore/str.rs
View file

@ -36,7 +36,7 @@ export
bytes,
chars,
substr,
slice,
slice_chars,
split,
split_str,
split_char,
@ -391,11 +391,11 @@ Failure:
If `begin` + `len` is is greater than the char length of the string
*/
fn substr(s: str, begin: uint, len: uint) -> str {
ret slice(s, begin, begin + len);
ret slice_chars(s, begin, begin + len);
}
/*
Function: slice
Function: slice_chars
Unicode-safe slice. Returns a slice of the given string containing
the characters in the range [`begin`..`end`). `begin` and `end` are
@ -408,7 +408,7 @@ Failure:
FIXME: make faster by avoiding char conversion
*/
fn slice(s: str, begin: uint, end: uint) -> str {
fn slice_chars(s: str, begin: uint, end: uint) -> str {
from_chars(vec::slice(chars(s), begin, end))
}
@ -617,7 +617,7 @@ fn windowed(nn: uint, ss: str) -> [str] {
let ii = 0u;
while ii+nn <= len {
let w = slice( ss, ii, ii+nn );
let w = slice_chars( ss, ii, ii+nn );
vec::push(ww,w);
ii += 1u;
}
@ -1969,17 +1969,17 @@ mod tests {
}
#[test]
fn test_slice() {
assert (eq("ab", slice("abc", 0u, 2u)));
assert (eq("bc", slice("abc", 1u, 3u)));
assert (eq("", slice("abc", 1u, 1u)));
assert (eq("\u65e5", slice("\u65e5\u672c", 0u, 1u)));
fn test_slice_chars() {
assert (eq("ab", slice_chars("abc", 0u, 2u)));
assert (eq("bc", slice_chars("abc", 1u, 3u)));
assert (eq("", slice_chars("abc", 1u, 1u)));
assert (eq("\u65e5", slice_chars("\u65e5\u672c", 0u, 1u)));
let data = "ประเทศไทย中华";
assert (eq("ป", slice(data, 0u, 1u)));
assert (eq("ร", slice(data, 1u, 2u)));
assert (eq("华", slice(data, 10u, 11u)));
assert (eq("", slice(data, 1u, 1u)));
assert (eq("ป", slice_chars(data, 0u, 1u)));
assert (eq("ร", slice_chars(data, 1u, 2u)));
assert (eq("华", slice_chars(data, 10u, 11u)));
assert (eq("", slice_chars(data, 1u, 1u)));
fn a_million_letter_X() -> str {
let i = 0;
@ -1994,7 +1994,7 @@ mod tests {
ret rs;
}
assert (eq(half_a_million_letter_X(),
slice(a_million_letter_X(), 0u, 500000u)));
slice_chars(a_million_letter_X(), 0u, 500000u)));
}
#[test]

4
src/libstd/fs.rs
View file

@ -44,8 +44,8 @@ fn splitDirnameBasename (pp: path) -> {dirname: str, basename: str} {
}
}
ret {dirname: str::slice(pp, 0u, ii),
basename: str::slice(pp, ii + 1u, str::len_chars(pp))};
ret {dirname: str::slice_chars(pp, 0u, ii),
basename: str::slice_chars(pp, ii + 1u, str::len_chars(pp))};
}
/*

19
src/libstd/json.rs
View file

@ -71,7 +71,7 @@ fn to_str(j: json) -> str {
fn rest(s: str) -> str {
assert(str::len_chars(s) >= 1u);
str::slice(s, 1u, str::len_chars(s))
str::slice_chars(s, 1u, str::len_chars(s))
}
fn from_str_str(s: str) -> (option<json>, str) {
@ -99,7 +99,7 @@ fn from_str_str(s: str) -> (option<json>, str) {
cont;
} else if (c == '"') {
ret (some(string(res)),
str::slice(s, pos, str::len_chars(s)));
str::slice_chars(s, pos, str::len_chars(s)));
}
res = res + str::from_char(c);
}
@ -200,12 +200,13 @@ fn from_str_float(s: str) -> (option<json>, str) {
}
'.' { break; }
_ { ret (some(num(neg * res)),
str::slice(s, opos, str::len_chars(s))); }
str::slice_chars(s, opos, str::len_chars(s))); }
}
}
if pos == len {
ret (some(num(neg * res)), str::slice(s, pos, str::len_chars(s)));
ret (some(num(neg * res)),
str::slice_chars(s, pos, str::len_chars(s)));
}
let dec = 1f;
@ -220,17 +221,17 @@ fn from_str_float(s: str) -> (option<json>, str) {
res += (((c as int) - ('0' as int)) as float) * dec;
}
_ { ret (some(num(neg * res)),
str::slice(s, opos, str::len_chars(s))); }
str::slice_chars(s, opos, str::len_chars(s))); }
}
}
ret (some(num(neg * res)), str::slice(s, pos, str::len_chars(s)));
ret (some(num(neg * res)), str::slice_chars(s, pos, str::len_chars(s)));
}
fn from_str_bool(s: str) -> (option<json>, str) {
if (str::starts_with(s, "true")) {
(some(boolean(true)), str::slice(s, 4u, str::len_chars(s)))
(some(boolean(true)), str::slice_chars(s, 4u, str::len_chars(s)))
} else if (str::starts_with(s, "false")) {
(some(boolean(false)), str::slice(s, 5u, str::len_chars(s)))
(some(boolean(false)), str::slice_chars(s, 5u, str::len_chars(s)))
} else {
(none, s)
}
@ -238,7 +239,7 @@ fn from_str_bool(s: str) -> (option<json>, str) {
fn from_str_null(s: str) -> (option<json>, str) {
if (str::starts_with(s, "null")) {
(some(null), str::slice(s, 4u, str::len_chars(s)))
(some(null), str::slice_chars(s, 4u, str::len_chars(s)))
} else {
(none, s)
}

2
src/rustdoc/unindent_pass.rs
View file

@ -68,7 +68,7 @@ fn unindent(s: str) -> str {
line
} else {
assert str::len_bytes(line) >= min_indent;
str::slice(line, min_indent, str::len_chars(line))
str::slice_chars(line, min_indent, str::len_chars(line))
}
};
str::connect(unindented, "\n")