about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/fs.rs12
-rw-r--r--src/libstd/getopts.rs6
-rw-r--r--src/libstd/json.rs24
-rw-r--r--src/libstd/rand.rs6
-rw-r--r--src/libstd/rope.rs10
-rw-r--r--src/libstd/sha1.rs2
6 files changed, 30 insertions, 30 deletions
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 167e0f125d6..3ba2f8b105a 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -45,7 +45,7 @@ fn splitDirnameBasename (pp: path) -> {dirname: str, basename: str} {
     }
 
     ret {dirname: str::slice(pp, 0u, ii),
-         basename: str::slice(pp, ii + 1u, str::len_bytes(pp))};
+         basename: str::slice(pp, ii + 1u, str::len(pp))};
 }
 
 /*
@@ -93,8 +93,8 @@ fn connect(pre: path, post: path) -> path unsafe {
     let pre_ = pre;
     let post_ = post;
     let sep = os_fs::path_sep as u8;
-    let pre_len = str::len_bytes(pre);
-    let post_len = str::len_bytes(post);
+    let pre_len  = str::len(pre);
+    let post_len = str::len(post);
     if pre_len > 1u && pre[pre_len-1u] == sep { str::unsafe::pop_byte(pre_); }
     if post_len > 1u && post[0] == sep { str::unsafe::shift_byte(post_); }
     ret pre_ + path_sep() + post_;
@@ -170,7 +170,7 @@ Lists the contents of a directory.
 */
 fn list_dir(p: path) -> [str] {
     let p = p;
-    let pl = str::len_bytes(p);
+    let pl = str::len(p);
     if pl == 0u || p[pl - 1u] as char != os_fs::path_sep { p += path_sep(); }
     let full_paths: [str] = [];
     for filename: str in os_fs::list_dir(p) {
@@ -336,7 +336,7 @@ fn normalize(p: path) -> path {
     let s = reabsolute(p, s);
     let s = reterminate(p, s);
 
-    let s = if str::len_bytes(s) == 0u {
+    let s = if str::len(s) == 0u {
         "."
     } else {
         s
@@ -403,7 +403,7 @@ fn normalize(p: path) -> path {
     }
 
     fn reterminate(orig: path, new: path) -> path {
-        let last = orig[str::len_bytes(orig) - 1u];
+        let last = orig[str::len(orig) - 1u];
         if last == os_fs::path_sep as u8
             || last == os_fs::path_sep as u8 {
             ret new + path_sep();
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 25681185f9b..7b409053cb0 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -79,7 +79,7 @@ A description of a possible option
 type opt = {name: name, hasarg: hasarg, occur: occur};
 
 fn mkname(nm: str) -> name {
-    ret if str::len_bytes(nm) == 1u {
+    ret if str::len(nm) == 1u {
             short(str::char_at(nm, 0u))
         } else { long(nm) };
 }
@@ -141,7 +141,7 @@ of matches and a vector of free strings.
 type match = {opts: [opt], vals: [mutable [optval]], free: [str]};
 
 fn is_arg(arg: str) -> bool {
-    ret str::len_bytes(arg) > 1u && arg[0] == '-' as u8;
+    ret str::len(arg) > 1u && arg[0] == '-' as u8;
 }
 
 fn name_str(nm: name) -> str {
@@ -218,7 +218,7 @@ fn getopts(args: [str], opts: [opt]) -> result unsafe {
     let i = 0u;
     while i < l {
         let cur = args[i];
-        let curlen = str::len_bytes(cur);
+        let curlen = str::len(cur);
         if !is_arg(cur) {
             free += [cur];
         } else if str::eq(cur, "--") {
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 32294f38fb9..7a888f250ed 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -70,13 +70,13 @@ fn to_str(j: json) -> str {
 }
 
 fn rest(s: str) -> str {
-    assert(str::len_bytes(s) >= 1u);
-    str::slice(s, 1u, str::len_bytes(s))
+    assert(str::len(s) >= 1u);
+    str::slice(s, 1u, str::len(s))
 }
 
 fn from_str_str(s: str) -> (option<json>, str) {
     let pos = 0u;
-    let len = str::len_bytes(s);
+    let len = str::len(s);
     let escape = false;
     let res = "";
 
@@ -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_bytes(s)));
+                 str::slice(s, pos, str::len(s)));
         }
         res = res + str::from_char(c);
     }
@@ -172,7 +172,7 @@ fn from_str_dict(s: str) -> (option<json>, str) {
 
 fn from_str_float(s: str) -> (option<json>, str) {
     let pos = 0u;
-    let len = str::len_bytes(s);
+    let len = str::len(s);
     let res = 0f;
     let neg = 1f;
 
@@ -200,13 +200,13 @@ fn from_str_float(s: str) -> (option<json>, str) {
             }
             '.' { break; }
             _ { ret (some(num(neg * res)),
-                     str::slice(s, opos, str::len_bytes(s))); }
+                     str::slice(s, opos, str::len(s))); }
         }
     }
 
     if pos == len {
         ret (some(num(neg * res)),
-             str::slice(s, pos, str::len_bytes(s)));
+             str::slice(s, pos, str::len(s)));
     }
 
     let dec = 1f;
@@ -221,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_bytes(s))); }
+                     str::slice(s, opos, str::len(s))); }
         }
     }
-    ret (some(num(neg * res)), str::slice(s, pos, str::len_bytes(s)));
+    ret (some(num(neg * res)), str::slice(s, pos, str::len(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_bytes(s)))
+        (some(boolean(true)), str::slice(s, 4u, str::len(s)))
     } else if (str::starts_with(s, "false")) {
-        (some(boolean(false)), str::slice(s, 5u, str::len_bytes(s)))
+        (some(boolean(false)), str::slice(s, 5u, str::len(s)))
     } else {
         (none, s)
     }
@@ -239,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_bytes(s)))
+        (some(null), str::slice(s, 4u, str::len(s)))
     } else {
         (none, s)
     }
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 33fac40fccc..35525b70710 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -77,7 +77,7 @@ fn mk_rng() -> rng {
             let i = 0u;
             while (i < len) {
                 let n = rustrt::rand_next(**self) as uint %
-                    str::len_bytes(charset);
+                    str::len(charset);
                 s = s + str::from_char(str::char_at(charset, n));
                 i += 1u;
             }
@@ -130,8 +130,8 @@ mod tests {
         log(debug, r.gen_str(10u));
         log(debug, r.gen_str(10u));
         log(debug, r.gen_str(10u));
-        assert(str::len_bytes(r.gen_str(10u)) == 10u);
-        assert(str::len_bytes(r.gen_str(16u)) == 16u);
+        assert(str::len(r.gen_str(10u)) == 10u);
+        assert(str::len(r.gen_str(16u)) == 16u);
     }
 }
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 4351ceb2d5a..81800afffa5 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -65,7 +65,7 @@ Performance notes:
 - the function runs in linear time.
  */
 fn of_str(str: @str) -> rope {
-    ret of_substr(str, 0u, str::len_bytes(*str));
+    ret of_substr(str, 0u, str::len(*str));
 }
 
 /*
@@ -93,7 +93,7 @@ Safety notes:
  */
 fn of_substr(str: @str, byte_offset: uint, byte_len: uint) -> rope {
     if byte_len == 0u { ret node::empty; }
-    if byte_offset + byte_len  > str::len_bytes(*str) { fail; }
+    if byte_offset + byte_len  > str::len(*str) { fail; }
     ret node::content(node::of_substr(str, byte_offset, byte_len));
 }
 
@@ -721,7 +721,7 @@ mod node {
     the length of `str`.
      */
     fn of_str(str: @str) -> @node {
-        ret of_substr(str, 0u, str::len_bytes(*str));
+        ret of_substr(str, 0u, str::len(*str));
     }
 
     /*
@@ -768,7 +768,7 @@ mod node {
     */
     fn of_substr_unsafer(str: @str, byte_start: uint, byte_len: uint,
                           char_len: uint) -> @node {
-        assert(byte_start + byte_len <= str::len_bytes(*str));
+        assert(byte_start + byte_len <= str::len(*str));
         let candidate = @leaf({
                 byte_offset: byte_start,
                 byte_len:    byte_len,
@@ -1388,7 +1388,7 @@ mod tests {
         assert rope_to_string(r) == *sample;
 
         let string_iter = 0u;
-        let string_len  = str::len_bytes(*sample);
+        let string_len  = str::len(*sample);
         let rope_iter   = iterator::char::start(r);
         let equal       = true;
         let pos         = 0u;
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 1b63f87f7c6..9360a84fb97 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -368,7 +368,7 @@ mod tests {
 
         // Test that it works when accepting the message in pieces
         for t: test in tests {
-            let len = str::len_bytes(t.input);
+            let len = str::len(t.input);
             let left = len;
             while left > 0u {
                 let take = (left + 1u) / 2u;
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-03-13 06:05:23 +0000