---

yaml
---
r: 11215
b: refs/heads/master
c: 0121cd5
h: refs/heads/master
i:
  11213: 63427f6
  11211: d29467d
  11207: 047a017
  11199: b8e9f37
v: v3

Author: killerswan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e0af23b664a1307fe376f2638bb7a69f04e2ac1c
+refs/heads/master: 0121cd5b0e302746d2cfe1b5524c2909fcc96ccf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/cargo/cargo.rs

@@ -651,27 +651,25 @@ fn cmd_install(c: cargo) unsafe {
 
     if str::starts_with(target, "uuid:") {
         let uuid = rest(target, 5u);
-        alt str::index(uuid, '/') {
-            option::some(idx) {
-               let source = str::slice(uuid, 0u, idx);
-               uuid = str::slice(uuid, idx + 1u, str::char_len(uuid));
-               install_uuid_specific(c, wd, source, uuid);
-            }
-            option::none {
-               install_uuid(c, wd, uuid);
-            }
+        let idx = str::index(uuid, '/' as u8);
+        if idx != -1 {
+            let source = str::unsafe::slice_bytes(uuid, 0u, idx as uint);
+            uuid = str::unsafe::slice_bytes(uuid, idx as uint + 1u,
+                                      str::byte_len(uuid));
+            install_uuid_specific(c, wd, source, uuid);
+        } else {
+            install_uuid(c, wd, uuid);
         }
     } else {
         let name = target;
-        alt str::index(name, '/') {
-            option::some(idx) {
-               let source = str::slice(name, 0u, idx);
-               name = str::slice(name, idx + 1u, str::char_len(name));
-               install_named_specific(c, wd, source, name);
-            }
-            option::none {
-               install_named(c, wd, name);
-            }
+        let idx = str::index(name, '/' as u8);
+        if idx != -1 {
+            let source = str::unsafe::slice_bytes(name, 0u, idx as uint);
+            name = str::unsafe::slice_bytes(name, idx as uint + 1u,
+                                      str::byte_len(name));
+            install_named_specific(c, wd, source, name);
+        } else {
+            install_named(c, wd, name);
         }
     }
 }

trunk/src/comp/back/link.rs

@@ -109,16 +109,14 @@ mod write {
     // Decides what to call an intermediate file, given the name of the output
     // and the extension to use.
     fn mk_intermediate_name(output_path: str, extension: str) -> str unsafe {
-        let stem = alt str::index(output_path, '.') {
-                       option::some(dot_pos) {
-                           str::slice(output_path, 0u, dot_pos)
-                       }
-                       option::none { output_path }
-                   };
-
+        let dot_pos = str::index(output_path, '.' as u8);
+        let stem;
+        if dot_pos < 0 {
+            stem = output_path;
+        } else { stem = str::unsafe::slice_bytes(output_path, 0u,
+                                                 dot_pos as uint); }
         ret stem + "." + extension;
     }
-
     fn run_passes(sess: session, llmod: ModuleRef, output: str) {
         let opts = sess.opts;
         if opts.time_llvm_passes { llvm::LLVMRustEnableTimePasses(); }

trunk/src/comp/syntax/codemap.rs

@@ -119,13 +119,16 @@ fn get_line(fm: filemap, line: int) -> str unsafe {
     let end: uint;
     if line as uint < vec::len(fm.lines) - 1u {
         end = fm.lines[line + 1].byte - fm.start_pos.byte;
-        ret str::unsafe::slice_bytes(*fm.src, begin, end);
     } else {
         // If we're not done parsing the file, we're at the limit of what's
         // parsed. If we just slice the rest of the string, we'll print out
         // the remainder of the file, which is undesirable.
-        ret str::splitn_char(*fm.src, '\n', 1u)[0];
+        end = str::byte_len(*fm.src);
+        let rest = str::unsafe::slice_bytes(*fm.src, begin, end);
+        let newline = str::index(rest, '\n' as u8);
+        if newline != -1 { end = begin + (newline as uint); }
     }
+    ret str::unsafe::slice_bytes(*fm.src, begin, end);
 }
 
 fn lookup_byte_offset(cm: codemap::codemap, chpos: uint)

trunk/src/fuzzer/fuzzer.rs

@@ -283,9 +283,10 @@ fn check_variants_T<T: copy>(
     }
 }
 
-fn last_part(filename: str) -> str {
-  let ix = option::get(str::rindex(filename, '/'));
-  str::slice(filename, ix + 1u, str::char_len(filename) - 3u)
+fn last_part(filename: str) -> str unsafe {
+  let ix = str::rindex(filename, 47u8 /* '/' */);
+  assert ix >= 0;
+  str::unsafe::slice_bytes(filename, ix as uint + 1u, str::byte_len(filename) - 3u)
 }
 
 enum happiness { passed, cleanly_rejected(str), known_bug(str), failed(str), }

trunk/src/libcore/char.rs

@@ -37,6 +37,7 @@ export is_alphabetic,
        is_XID_start, is_XID_continue,
        is_lowercase, is_uppercase,
        is_whitespace, is_alphanumeric,
+       is_ascii, is_digit,
        to_digit, to_lower, to_upper, maybe_digit, cmp;
 
 import is_alphabetic = unicode::derived_property::Alphabetic;
@@ -84,6 +85,17 @@ pure fn is_alphanumeric(c: char) -> bool {
         unicode::general_category::No(c);
 }
 
+#[doc( brief = "Indicates whether the character is an ASCII character" )]
+pure fn is_ascii(c: char) -> bool {
+   c - ('\x7F' & c) == '\x00'
+}
+
+#[doc( brief = "Indicates whether the character is numeric (Nd, Nl, or No)" )]
+pure fn is_digit(c: char) -> bool {
+    ret unicode::general_category::Nd(c) ||
+        unicode::general_category::Nl(c) ||
+        unicode::general_category::No(c);
+}
 
 #[doc(
   brief = "Convert a char to the corresponding digit. \
@@ -221,3 +233,20 @@ fn test_to_upper() {
     //assert (to_upper('ü') == 'Ü');
     assert (to_upper('ß') == 'ß');
 }
+
+#[test]
+fn test_is_ascii() unsafe {
+   assert str::all("banana", char::is_ascii);
+   assert ! str::all("ประเทศไทย中华Việt Nam", char::is_ascii);
+}
+
+#[test]
+fn test_is_digit() {
+   assert is_digit('2');
+   assert is_digit('7');
+   assert ! is_digit('c');
+   assert ! is_digit('i');
+   assert ! is_digit('z');
+   assert ! is_digit('Q');
+}
+

trunk/src/libcore/str.rs

@@ -72,8 +72,6 @@ export
    // Searching
    index,
    rindex,
-   index_byte,
-   rindex_byte,
    find,
    contains,
    starts_with,
@@ -255,12 +253,15 @@ Function: pop_char
 Remove the final character from a string and return it.
 
 Failure:
+
 If the string does not contain any characters.
 */
 fn pop_char(&s: str) -> char unsafe {
     let end = byte_len(s);
-    let {ch:ch, prev:end} = char_range_at_reverse(s, end);
-    s = unsafe::slice_bytes(s, 0u, end);
+    while end > 0u && s[end - 1u] & 192u8 == tag_cont_u8 { end -= 1u; }
+    assert (end > 0u);
+    let ch = char_at(s, end - 1u);
+    s = unsafe::slice_bytes(s, 0u, end - 1u);
     ret ch;
 }
 
@@ -867,52 +868,6 @@ fn lines_iter(ss: str, ff: fn(&&str)) {
 Section: Searching
 */
 
-// Function: index
-//
-// Returns the index of the first matching char
-// (as option some/none)
-fn index(ss: str, cc: char) -> option<uint> {
-    let bii = 0u;
-    let cii = 0u;
-    let len = byte_len(ss);
-    while bii < len {
-        let {ch, next} = char_range_at(ss, bii);
-
-        // found here?
-        if ch == cc {
-            ret option::some(cii);
-        }
-
-        cii += 1u;
-        bii = next;
-    }
-
-    // wasn't found
-    ret option::none;
-}
-
-// Function: rindex
-//
-// Returns the index of the first matching char
-// (as option some/none)
-fn rindex(ss: str, cc: char) -> option<uint> {
-    let bii = byte_len(ss);
-    let cii = char_len(ss);
-    while bii > 0u {
-        let {ch, prev} = char_range_at_reverse(ss, bii);
-        cii -= 1u;
-        bii = prev;
-
-        // found here?
-        if ch == cc {
-            ret option::some(cii);
-        }
-    }
-
-    // wasn't found
-    ret option::none;
-}
-
 /*
 Function: index
 
@@ -921,7 +876,7 @@ no match is found.
 
 FIXME: UTF-8
 */
-fn index_byte(s: str, c: u8) -> int {
+fn index(s: str, c: u8) -> int {
     let i: int = 0;
     for k: u8 in s { if k == c { ret i; } i += 1; }
     ret -1;
@@ -935,7 +890,7 @@ if no match is found.
 
 FIXME: UTF-8
 */
-fn rindex_byte(s: str, c: u8) -> int {
+fn rindex(s: str, c: u8) -> int {
     let n: int = byte_len(s) as int;
     while n >= 0 { if s[n] == c { ret n; } n -= 1; }
     ret n;
@@ -1278,25 +1233,6 @@ Pluck a character out of a string
 */
 fn char_at(s: str, i: uint) -> char { ret char_range_at(s, i).ch; }
 
-// Function: char_range_at_reverse
-//
-// Given a byte position and a str, return the previous char and its position
-// This function can be used to iterate over a unicode string in reverse.
-fn char_range_at_reverse(ss: str, start: uint) -> {ch: char, prev: uint} {
-    let prev = start;
-
-    // while there is a previous byte == 10......
-    while prev > 0u && ss[prev - 1u] & 192u8 == tag_cont_u8 {
-        prev -= 1u;
-    }
-
-    // now refer to the initial byte of previous char
-    prev -= 1u;
-
-    let ch = char_at(ss, prev);
-    ret {ch:ch, prev:prev};
-}
-
 /*
 Function: substr_all
 
@@ -1506,56 +1442,13 @@ mod tests {
     }
 
     #[test]
-    fn test_index() {
-        assert ( index("hello", 'h') == option::some(0u));
-        assert ( index("hello", 'e') == option::some(1u));
-        assert ( index("hello", 'o') == option::some(4u));
-        assert ( index("hello", 'z') == option::none);
-    }
-
-    #[test]
-    fn test_rindex() {
-        assert (rindex("hello", 'l') == option::some(3u));
-        assert (rindex("hello", 'o') == option::some(4u));
-        assert (rindex("hello", 'h') == option::some(0u));
-        assert (rindex("hello", 'z') == option::none);
-    }
-
-    #[test]
-    fn test_index_byte() {
-        assert ( index_byte("hello", 'e' as u8) == 1);
-        assert ( index_byte("hello", 'o' as u8) == 4);
-        assert ( index_byte("hello", 'z' as u8) == -1);
-    }
-
-    #[test]
-    fn test_rindex_byte() {
-        assert (rindex_byte("hello", 'l' as u8) == 3);
-        assert (rindex_byte("hello", 'h' as u8) == 0);
-        assert (rindex_byte("hello", 'z' as u8) == -1);
-    }
-
-    #[test]
-    fn test_pop_char() {
-        let data = "ประเทศไทย中华";
-        let cc = pop_char(data);
-        assert "ประเทศไทย中" == data;
-        assert '华' == cc;
-    }
-
-    #[test]
-    fn test_pop_char_2() {
-        let data2 = "华";
-        let cc2 = pop_char(data2);
-        assert "" == data2;
-        assert '华' == cc2;
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_pop_char_fail() {
-        let data = "";
-        let _cc3 = pop_char(data);
+    fn test_index_and_rindex() {
+        assert (index("hello", 'e' as u8) == 1);
+        assert (index("hello", 'o' as u8) == 4);
+        assert (index("hello", 'z' as u8) == -1);
+        assert (rindex("hello", 'l' as u8) == 3);
+        assert (rindex("hello", 'h' as u8) == 0);
+        assert (rindex("hello", 'z' as u8) == -1);
     }
 
     #[test]