Rename str::unsafe to str::raw

brson · brson · commit 308ca06012df · 2012-09-12T19:55:16.000-07:00
diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs
@@ -170,7 +170,7 @@ impl T : FromStr {
 fn to_str(n: T, radix: uint) -> ~str {
     do to_str_bytes(n, radix) |slice| {
         do vec::as_buf(slice) |p, len| {
-            unsafe { str::unsafe::from_buf_len(p, len) }
+            unsafe { str::raw::from_buf_len(p, len) }
         }
     }
 }
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
@@ -69,7 +69,7 @@ fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
     let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
     do vec::as_mut_buf(buf) |b, sz| {
         if f(b, sz as size_t) unsafe {
-            Some(str::unsafe::from_buf(b as *u8))
+            Some(str::raw::from_buf(b as *u8))
         } else {
             None
         }
@@ -226,7 +226,7 @@ mod global_env {
                     option::None::<~str>
                 } else {
                     let s = unsafe::reinterpret_cast(&s);
-                    option::Some::<~str>(str::unsafe::from_buf(s))
+                    option::Some::<~str>(str::raw::from_buf(s))
                 };
             }
         }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
@@ -114,7 +114,7 @@ export
    escape_default,
    escape_unicode,
 
-   unsafe,
+   raw,
    extensions,
    StrSlice,
    UniqueStr;
@@ -132,12 +132,12 @@ Section: Creating a string
  */
 pure fn from_bytes(vv: &[const u8]) -> ~str {
     assert is_utf8(vv);
-    return unsafe { unsafe::from_bytes(vv) };
+    return unsafe { raw::from_bytes(vv) };
 }
 
 /// Copy a slice into a new unique str
 pure fn from_slice(s: &str) -> ~str {
-    unsafe { unsafe::slice_bytes(s, 0, len(s)) }
+    unsafe { raw::slice_bytes(s, 0, len(s)) }
 }
 
 /**
@@ -219,7 +219,7 @@ fn push_char(&s: ~str, ch: char) {
             }
         }
 
-        unsafe::set_len(s, new_len);
+        raw::set_len(s, new_len);
     }
 }
 
@@ -254,7 +254,7 @@ fn push_str_no_overallocate(&lhs: ~str, rhs: &str) {
                 ptr::memcpy(dst, rbuf, rlen);
             }
         }
-        unsafe::set_len(lhs, llen + rlen);
+        raw::set_len(lhs, llen + rlen);
     }
 }
 /// Appends a string slice to the back of a string
@@ -271,7 +271,7 @@ fn push_str(&lhs: ~str, rhs: &str) {
                 ptr::memcpy(dst, rbuf, rlen);
             }
         }
-        unsafe::set_len(lhs, llen + rlen);
+        raw::set_len(lhs, llen + rlen);
     }
 }
 
@@ -318,7 +318,7 @@ fn pop_char(&s: ~str) -> char {
     let end = len(s);
     assert end > 0u;
     let {ch, prev} = char_range_at_reverse(s, end);
-    unsafe { unsafe::set_len(s, prev); }
+    unsafe { raw::set_len(s, prev); }
     return ch;
 }
 
@@ -331,7 +331,7 @@ fn pop_char(&s: ~str) -> char {
  */
 fn shift_char(&s: ~str) -> char {
     let {ch, next} = char_range_at(s, 0u);
-    s = unsafe { unsafe::slice_bytes(s, next, len(s)) };
+    s = unsafe { raw::slice_bytes(s, next, len(s)) };
     return ch;
 }
 
@@ -347,7 +347,7 @@ fn shift_char(&s: ~str) -> char {
 #[inline]
 fn view_shift_char(s: &a/str) -> (char, &a/str) {
     let {ch, next} = char_range_at(s, 0u);
-    let next_s = unsafe { unsafe::view_bytes(s, next, len(s)) };
+    let next_s = unsafe { raw::view_bytes(s, next, len(s)) };
     return (ch, next_s);
 }
 
@@ -368,7 +368,7 @@ pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {
 
     match find(s, |c| !chars_to_trim.contains(c)) {
       None => ~"",
-      Some(first) => unsafe { unsafe::slice_bytes(s, first, s.len()) }
+      Some(first) => unsafe { raw::slice_bytes(s, first, s.len()) }
     }
 }
 
@@ -388,7 +388,7 @@ pure fn trim_right_chars(s: &str, chars_to_trim: &[char]) -> ~str {
       None => ~"",
       Some(last) => {
         let {next, _} = char_range_at(s, last);
-        unsafe { unsafe::slice_bytes(s, 0u, next) }
+        unsafe { raw::slice_bytes(s, 0u, next) }
       }
     }
 }
@@ -410,7 +410,7 @@ pure fn trim_chars(s: &str, chars_to_trim: &[char]) -> ~str {
 pure fn trim_left(s: &str) -> ~str {
     match find(s, |c| !char::is_whitespace(c)) {
       None => ~"",
-      Some(first) => unsafe { unsafe::slice_bytes(s, first, len(s)) }
+      Some(first) => unsafe { raw::slice_bytes(s, first, len(s)) }
     }
 }
 
@@ -420,7 +420,7 @@ pure fn trim_right(s: &str) -> ~str {
       None => ~"",
       Some(last) => {
         let {next, _} = char_range_at(s, last);
-        unsafe { unsafe::slice_bytes(s, 0u, next) }
+        unsafe { raw::slice_bytes(s, 0u, next) }
       }
     }
 }
@@ -482,7 +482,7 @@ pure fn substr(s: &str, begin: uint, n: uint) -> ~str {
 pure fn slice(s: &str, begin: uint, end: uint) -> ~str {
     assert is_char_boundary(s, begin);
     assert is_char_boundary(s, end);
-    unsafe { unsafe::slice_bytes(s, begin, end) }
+    unsafe { raw::slice_bytes(s, begin, end) }
 }
 
 /**
@@ -494,7 +494,7 @@ pure fn slice(s: &str, begin: uint, end: uint) -> ~str {
 pure fn view(s: &a/str, begin: uint, end: uint) -> &a/str {
     assert is_char_boundary(s, begin);
     assert is_char_boundary(s, end);
-    unsafe { unsafe::view_bytes(s, begin, end) }
+    unsafe { raw::view_bytes(s, begin, end) }
 }
 
 /// Splits a string into substrings at each occurrence of a given character
@@ -527,15 +527,15 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool)
             if s[i] == b {
                 if allow_empty || start < i unchecked {
                     vec::push(result,
-                              unsafe { unsafe::slice_bytes(s, start, i) });
+                              unsafe { raw::slice_bytes(s, start, i) });
                 }
                 start = i + 1u;
                 done += 1u;
             }
             i += 1u;
         }
         if allow_empty || start < l {
-            unsafe { vec::push(result, unsafe::slice_bytes(s, start, l) ) };
+            unsafe { vec::push(result, raw::slice_bytes(s, start, l) ) };
         }
         move result
     } else {
@@ -570,15 +570,15 @@ pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint,
         let {ch, next} = char_range_at(s, i);
         if sepfn(ch) {
             if allow_empty || start < i unchecked {
-                vec::push(result, unsafe { unsafe::slice_bytes(s, start, i)});
+                vec::push(result, unsafe { raw::slice_bytes(s, start, i)});
             }
             start = next;
             done += 1u;
         }
         i = next;
     }
     if allow_empty || start < l unchecked {
-        vec::push(result, unsafe { unsafe::slice_bytes(s, start, l) });
+        vec::push(result, unsafe { raw::slice_bytes(s, start, l) });
     }
     move result
 }
@@ -632,7 +632,7 @@ pure fn iter_between_matches(s: &a/str, sep: &b/str, f: fn(uint, uint)) {
 pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
-        unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }
+        unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }
     }
     move result
 }
@@ -641,7 +641,7 @@ pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
         if to > from {
-            unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }
+            unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }
         }
     }
     move result
@@ -661,7 +661,7 @@ pure fn lines_any(s: &str) -> ~[~str] {
         let l = len(s);
         let mut cp = copy s;
         if l > 0u && s[l - 1u] == '\r' as u8 {
-            unsafe { unsafe::set_len(cp, l - 1u); }
+            unsafe { raw::set_len(cp, l - 1u); }
         }
         move cp
     })
@@ -703,7 +703,7 @@ pure fn replace(s: &str, from: &str, to: &str) -> ~str {
     let mut result = ~"", first = true;
     do iter_between_matches(s, from) |start, end| {
         if first { first = false; } else { unchecked {push_str(result, to); }}
-        unsafe { push_str(result, unsafe::slice_bytes(s, start, end)); }
+        unsafe { push_str(result, raw::slice_bytes(s, start, end)); }
     }
     move result
 }
@@ -1963,7 +1963,7 @@ pure fn escape_unicode(s: &str) -> ~str {
 }
 
 /// Unsafe operations
-mod unsafe {
+mod raw {
    export
       from_buf,
       from_buf_len,
@@ -2029,7 +2029,7 @@ mod unsafe {
     }
 
     /// Converts a byte to a string.
-    unsafe fn from_byte(u: u8) -> ~str { unsafe::from_bytes([u]) }
+    unsafe fn from_byte(u: u8) -> ~str { raw::from_bytes([u]) }
 
     /**
      * Takes a bytewise (not UTF-8) slice from a string.
@@ -2112,7 +2112,7 @@ mod unsafe {
         let len = len(s);
         assert (len > 0u);
         let b = s[0];
-        s = unsafe { unsafe::slice_bytes(s, 1u, len) };
+        s = unsafe { raw::slice_bytes(s, 1u, len) };
         return b;
     }
 
@@ -2646,9 +2646,9 @@ mod tests {
     #[test]
     fn test_unsafe_slice() {
         unsafe {
-            assert ~"ab" == unsafe::slice_bytes(~"abc", 0u, 2u);
-            assert ~"bc" == unsafe::slice_bytes(~"abc", 1u, 3u);
-            assert ~"" == unsafe::slice_bytes(~"abc", 1u, 1u);
+            assert ~"ab" == raw::slice_bytes(~"abc", 0u, 2u);
+            assert ~"bc" == raw::slice_bytes(~"abc", 1u, 3u);
+            assert ~"" == raw::slice_bytes(~"abc", 1u, 1u);
             fn a_million_letter_a() -> ~str {
                 let mut i = 0;
                 let mut rs = ~"";
@@ -2662,7 +2662,7 @@ mod tests {
                 return rs;
             }
             assert half_a_million_letter_a() ==
-                unsafe::slice_bytes(a_million_letter_a(), 0u, 500000u);
+                raw::slice_bytes(a_million_letter_a(), 0u, 500000u);
         }
     }
 
@@ -2881,23 +2881,23 @@ mod tests {
     #[test]
     fn test_shift_byte() {
         let mut s = ~"ABC";
-        let b = unsafe { unsafe::shift_byte(s) };
+        let b = unsafe { raw::shift_byte(s) };
         assert (s == ~"BC");
         assert (b == 65u8);
     }
 
     #[test]
     fn test_pop_byte() {
         let mut s = ~"ABC";
-        let b = unsafe { unsafe::pop_byte(s) };
+        let b = unsafe { raw::pop_byte(s) };
         assert (s == ~"AB");
         assert (b == 67u8);
     }
 
     #[test]
     fn test_unsafe_from_bytes() {
         let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
-        let b = unsafe { unsafe::from_bytes(a) };
+        let b = unsafe { raw::from_bytes(a) };
         assert (b == ~"AAAAAAA");
     }
 
@@ -2941,7 +2941,7 @@ mod tests {
         unsafe {
             let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
             let b = vec::raw::to_ptr(a);
-            let c = unsafe::from_buf(b);
+            let c = raw::from_buf(b);
             assert (c == ~"AAAAAAA");
         }
     }
@@ -2979,7 +2979,7 @@ mod tests {
         unsafe {
             let s = ~"hello";
             let sb = as_buf(s, |b, _l| b);
-            let s_cstr = unsafe::from_buf(sb);
+            let s_cstr = raw::from_buf(sb);
             assert s_cstr == s;
         }
     }
diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
@@ -175,7 +175,7 @@ fn from_str_radix(buf: &str, radix: u64) -> Option<u64> {
 pure fn to_str(num: T, radix: uint) -> ~str {
     do to_str_bytes(false, num, radix) |slice| {
         do vec::as_buf(slice) |p, len| {
-            unsafe { str::unsafe::from_buf_len(p, len) }
+            unsafe { str::raw::from_buf_len(p, len) }
         }
     }
 }
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
@@ -834,7 +834,7 @@ unsafe fn ip4_name(src: &sockaddr_in) -> ~str {
         // to see if it is the string representation of
         // INADDR_NONE (0xffffffff or 255.255.255.255 on
         // many platforms)
-        str::unsafe::from_buf(dst_buf)
+        str::raw::from_buf(dst_buf)
     }
 }
 unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
@@ -852,7 +852,7 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
         let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
                                               dst_buf, size as libc::size_t);
         match result {
-          0i32 => str::unsafe::from_buf(dst_buf),
+          0i32 => str::raw::from_buf(dst_buf),
           _ => ~""
         }
     }
@@ -962,17 +962,17 @@ unsafe fn free_base_of_buf(buf: uv_buf_t) {
 unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
     let err = last_error(uv_loop);
     let err_ptr = ptr::addr_of(err);
-    let err_name = str::unsafe::from_c_str(err_name(err_ptr));
-    let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
+    let err_name = str::raw::from_c_str(err_name(err_ptr));
+    let err_msg = str::raw::from_c_str(strerror(err_ptr));
     return fmt!("LIBUV ERROR: name: %s msg: %s",
                     err_name, err_msg);
 }
 
 unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
     let err = last_error(uv_loop);
     let err_ptr = ptr::addr_of(err);
-    let err_name = str::unsafe::from_c_str(err_name(err_ptr));
-    let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
+    let err_name = str::raw::from_c_str(err_name(err_ptr));
+    let err_msg = str::raw::from_c_str(strerror(err_ptr));
     { err_name: err_name, err_msg: err_msg }
 }
 
diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
@@ -37,7 +37,7 @@ fn llvm_err(sess: session, msg: ~str) -> ! unsafe {
     let cstr = llvm::LLVMRustGetLastError();
     if cstr == ptr::null() {
         sess.fatal(msg);
-    } else { sess.fatal(msg + ~": " + str::unsafe::from_c_str(cstr)); }
+    } else { sess.fatal(msg + ~": " + str::raw::from_c_str(cstr)); }
 }
 
 fn WriteOutputFile(sess:session,
diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs
@@ -181,7 +181,7 @@ fn get_metadata_section(os: os,
     let si = mk_section_iter(of.llof);
     while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
         let name_buf = llvm::LLVMGetSectionName(si.llsi);
-        let name = unsafe { str::unsafe::from_c_str(name_buf) };
+        let name = unsafe { str::raw::from_c_str(name_buf) };
         if name == meta_section_name(os) {
             let cbuf = llvm::LLVMGetSectionContents(si.llsi);
             let csz = llvm::LLVMGetSectionSize(si.llsi) as uint;
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ impl T : FromStr {`
`170`	`170`	`fn to_str(n: T, radix: uint) -> ~str {`
`171`	`171`	`do to_str_bytes(n, radix) \|slice\| {`
`172`	`172`	`do vec::as_buf(slice) \|p, len\| {`
`173`		`- unsafe { str::unsafe::from_buf_len(p, len) }`
	`173`	`+ unsafe { str::raw::from_buf_len(p, len) }`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)`
`69`	`69`	`let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));`
`70`	`70`	`do vec::as_mut_buf(buf) \|b, sz\| {`
`71`	`71`	`if f(b, sz as size_t) unsafe {`
`72`		`- Some(str::unsafe::from_buf(b as *u8))`
	`72`	`+ Some(str::raw::from_buf(b as *u8))`
`73`	`73`	`} else {`
`74`	`74`	`None`
`75`	`75`	`}`
`@@ -226,7 +226,7 @@ mod global_env {`
`226`	`226`	`option::None::<~str>`
`227`	`227`	`} else {`
`228`	`228`	`let s = unsafe::reinterpret_cast(&s);`
`229`		`- option::Some::<~str>(str::unsafe::from_buf(s))`
	`229`	`+ option::Some::<~str>(str::raw::from_buf(s))`
`230`	`230`	`};`
`231`	`231`	`}`
`232`	`232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ export`
`114`	`114`	`escape_default,`
`115`	`115`	`escape_unicode,`
`116`	`116`
`117`		`- unsafe,`
	`117`	`+ raw,`
`118`	`118`	`extensions,`
`119`	`119`	`StrSlice,`
`120`	`120`	`UniqueStr;`
`@@ -132,12 +132,12 @@ Section: Creating a string`
`132`	`132`	`*/`
`133`	`133`	`pure fn from_bytes(vv: &[const u8]) -> ~str {`
`134`	`134`	`assert is_utf8(vv);`
`135`		`- return unsafe { unsafe::from_bytes(vv) };`
	`135`	`+ return unsafe { raw::from_bytes(vv) };`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`/// Copy a slice into a new unique str`
`139`	`139`	`pure fn from_slice(s: &str) -> ~str {`
`140`		`- unsafe { unsafe::slice_bytes(s, 0, len(s)) }`
	`140`	`+ unsafe { raw::slice_bytes(s, 0, len(s)) }`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`/**`
`@@ -219,7 +219,7 @@ fn push_char(&s: ~str, ch: char) {`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`222`		`- unsafe::set_len(s, new_len);`
	`222`	`+ raw::set_len(s, new_len);`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`
`@@ -254,7 +254,7 @@ fn push_str_no_overallocate(&lhs: ~str, rhs: &str) {`
`254`	`254`	`ptr::memcpy(dst, rbuf, rlen);`
`255`	`255`	`}`
`256`	`256`	`}`
`257`		`- unsafe::set_len(lhs, llen + rlen);`
	`257`	`+ raw::set_len(lhs, llen + rlen);`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`	`/// Appends a string slice to the back of a string`
`@@ -271,7 +271,7 @@ fn push_str(&lhs: ~str, rhs: &str) {`
`271`	`271`	`ptr::memcpy(dst, rbuf, rlen);`
`272`	`272`	`}`
`273`	`273`	`}`
`274`		`- unsafe::set_len(lhs, llen + rlen);`
	`274`	`+ raw::set_len(lhs, llen + rlen);`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
`@@ -318,7 +318,7 @@ fn pop_char(&s: ~str) -> char {`
`318`	`318`	`let end = len(s);`
`319`	`319`	`assert end > 0u;`
`320`	`320`	`let {ch, prev} = char_range_at_reverse(s, end);`
`321`		`- unsafe { unsafe::set_len(s, prev); }`
	`321`	`+ unsafe { raw::set_len(s, prev); }`
`322`	`322`	`return ch;`
`323`	`323`	`}`
`324`	`324`
`@@ -331,7 +331,7 @@ fn pop_char(&s: ~str) -> char {`
`331`	`331`	`*/`
`332`	`332`	`fn shift_char(&s: ~str) -> char {`
`333`	`333`	`let {ch, next} = char_range_at(s, 0u);`
`334`		`- s = unsafe { unsafe::slice_bytes(s, next, len(s)) };`
	`334`	`+ s = unsafe { raw::slice_bytes(s, next, len(s)) };`
`335`	`335`	`return ch;`
`336`	`336`	`}`
`337`	`337`
`@@ -347,7 +347,7 @@ fn shift_char(&s: ~str) -> char {`
`347`	`347`	`#[inline]`
`348`	`348`	`fn view_shift_char(s: &a/str) -> (char, &a/str) {`
`349`	`349`	`let {ch, next} = char_range_at(s, 0u);`
`350`		`- let next_s = unsafe { unsafe::view_bytes(s, next, len(s)) };`
	`350`	`+ let next_s = unsafe { raw::view_bytes(s, next, len(s)) };`
`351`	`351`	`return (ch, next_s);`
`352`	`352`	`}`
`353`	`353`
`@@ -368,7 +368,7 @@ pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {`
`368`	`368`
`369`	`369`	`match find(s, \|c\| !chars_to_trim.contains(c)) {`
`370`	`370`	`None => ~"",`
`371`		`- Some(first) => unsafe { unsafe::slice_bytes(s, first, s.len()) }`
	`371`	`+ Some(first) => unsafe { raw::slice_bytes(s, first, s.len()) }`
`372`	`372`	`}`
`373`	`373`	`}`
`374`	`374`
`@@ -388,7 +388,7 @@ pure fn trim_right_chars(s: &str, chars_to_trim: &[char]) -> ~str {`
`388`	`388`	`None => ~"",`
`389`	`389`	`Some(last) => {`
`390`	`390`	`let {next, _} = char_range_at(s, last);`
`391`		`- unsafe { unsafe::slice_bytes(s, 0u, next) }`
	`391`	`+ unsafe { raw::slice_bytes(s, 0u, next) }`
`392`	`392`	`}`
`393`	`393`	`}`
`394`	`394`	`}`
`@@ -410,7 +410,7 @@ pure fn trim_chars(s: &str, chars_to_trim: &[char]) -> ~str {`
`410`	`410`	`pure fn trim_left(s: &str) -> ~str {`
`411`	`411`	`match find(s, \|c\| !char::is_whitespace(c)) {`
`412`	`412`	`None => ~"",`
`413`		`- Some(first) => unsafe { unsafe::slice_bytes(s, first, len(s)) }`
	`413`	`+ Some(first) => unsafe { raw::slice_bytes(s, first, len(s)) }`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
`@@ -420,7 +420,7 @@ pure fn trim_right(s: &str) -> ~str {`
`420`	`420`	`None => ~"",`
`421`	`421`	`Some(last) => {`
`422`	`422`	`let {next, _} = char_range_at(s, last);`
`423`		`- unsafe { unsafe::slice_bytes(s, 0u, next) }`
	`423`	`+ unsafe { raw::slice_bytes(s, 0u, next) }`
`424`	`424`	`}`
`425`	`425`	`}`
`426`	`426`	`}`
`@@ -482,7 +482,7 @@ pure fn substr(s: &str, begin: uint, n: uint) -> ~str {`
`482`	`482`	`pure fn slice(s: &str, begin: uint, end: uint) -> ~str {`
`483`	`483`	`assert is_char_boundary(s, begin);`
`484`	`484`	`assert is_char_boundary(s, end);`
`485`		`- unsafe { unsafe::slice_bytes(s, begin, end) }`
	`485`	`+ unsafe { raw::slice_bytes(s, begin, end) }`
`486`	`486`	`}`
`487`	`487`
`488`	`488`	`/**`
`@@ -494,7 +494,7 @@ pure fn slice(s: &str, begin: uint, end: uint) -> ~str {`
`494`	`494`	`pure fn view(s: &a/str, begin: uint, end: uint) -> &a/str {`
`495`	`495`	`assert is_char_boundary(s, begin);`
`496`	`496`	`assert is_char_boundary(s, end);`
`497`		`- unsafe { unsafe::view_bytes(s, begin, end) }`
	`497`	`+ unsafe { raw::view_bytes(s, begin, end) }`
`498`	`498`	`}`
`499`	`499`
`500`	`500`	`/// Splits a string into substrings at each occurrence of a given character`
`@@ -527,15 +527,15 @@ pure fn split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool)`
`527`	`527`	`if s[i] == b {`
`528`	`528`	`if allow_empty \|\| start < i unchecked {`
`529`	`529`	`vec::push(result,`
`530`		`- unsafe { unsafe::slice_bytes(s, start, i) });`
	`530`	`+ unsafe { raw::slice_bytes(s, start, i) });`
`531`	`531`	`}`
`532`	`532`	`start = i + 1u;`
`533`	`533`	`done += 1u;`
`534`	`534`	`}`
`535`	`535`	`i += 1u;`
`536`	`536`	`}`
`537`	`537`	`if allow_empty \|\| start < l {`
`538`		`- unsafe { vec::push(result, unsafe::slice_bytes(s, start, l) ) };`
	`538`	`+ unsafe { vec::push(result, raw::slice_bytes(s, start, l) ) };`
`539`	`539`	`}`
`540`	`540`	`move result`
`541`	`541`	`} else {`
`@@ -570,15 +570,15 @@ pure fn split_inner(s: &str, sepfn: fn(cc: char) -> bool, count: uint,`
`570`	`570`	`let {ch, next} = char_range_at(s, i);`
`571`	`571`	`if sepfn(ch) {`
`572`	`572`	`if allow_empty \|\| start < i unchecked {`
`573`		`- vec::push(result, unsafe { unsafe::slice_bytes(s, start, i)});`
	`573`	`+ vec::push(result, unsafe { raw::slice_bytes(s, start, i)});`
`574`	`574`	`}`
`575`	`575`	`start = next;`
`576`	`576`	`done += 1u;`
`577`	`577`	`}`
`578`	`578`	`i = next;`
`579`	`579`	`}`
`580`	`580`	`if allow_empty \|\| start < l unchecked {`
`581`		`- vec::push(result, unsafe { unsafe::slice_bytes(s, start, l) });`
	`581`	`+ vec::push(result, unsafe { raw::slice_bytes(s, start, l) });`
`582`	`582`	`}`
`583`	`583`	`move result`
`584`	`584`	`}`
`@@ -632,7 +632,7 @@ pure fn iter_between_matches(s: &a/str, sep: &b/str, f: fn(uint, uint)) {`
`632`	`632`	`pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {`
`633`	`633`	`let mut result = ~[];`
`634`	`634`	`do iter_between_matches(s, sep) \|from, to\| {`
`635`		`- unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }`
	`635`	`+ unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }`
`636`	`636`	`}`
`637`	`637`	`move result`
`638`	`638`	`}`
`@@ -641,7 +641,7 @@ pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {`
`641`	`641`	`let mut result = ~[];`
`642`	`642`	`do iter_between_matches(s, sep) \|from, to\| {`
`643`	`643`	`if to > from {`
`644`		`- unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }`
	`644`	`+ unsafe { vec::push(result, raw::slice_bytes(s, from, to)); }`
`645`	`645`	`}`
`646`	`646`	`}`
`647`	`647`	`move result`
`@@ -661,7 +661,7 @@ pure fn lines_any(s: &str) -> ~[~str] {`
`661`	`661`	`let l = len(s);`
`662`	`662`	`let mut cp = copy s;`
`663`	`663`	`if l > 0u && s[l - 1u] == '\r' as u8 {`
`664`		`- unsafe { unsafe::set_len(cp, l - 1u); }`
	`664`	`+ unsafe { raw::set_len(cp, l - 1u); }`
`665`	`665`	`}`
`666`	`666`	`move cp`
`667`	`667`	`})`
`@@ -703,7 +703,7 @@ pure fn replace(s: &str, from: &str, to: &str) -> ~str {`
`703`	`703`	`let mut result = ~"", first = true;`
`704`	`704`	`do iter_between_matches(s, from) \|start, end\| {`
`705`	`705`	`if first { first = false; } else { unchecked {push_str(result, to); }}`
`706`		`- unsafe { push_str(result, unsafe::slice_bytes(s, start, end)); }`
	`706`	`+ unsafe { push_str(result, raw::slice_bytes(s, start, end)); }`
`707`	`707`	`}`
`708`	`708`	`move result`
`709`	`709`	`}`
`@@ -1963,7 +1963,7 @@ pure fn escape_unicode(s: &str) -> ~str {`
`1963`	`1963`	`}`
`1964`	`1964`
`1965`	`1965`	`/// Unsafe operations`
`1966`		`-mod unsafe {`
	`1966`	`+mod raw {`
`1967`	`1967`	`export`
`1968`	`1968`	`from_buf,`
`1969`	`1969`	`from_buf_len,`
`@@ -2029,7 +2029,7 @@ mod unsafe {`
`2029`	`2029`	`}`
`2030`	`2030`
`2031`	`2031`	`/// Converts a byte to a string.`
`2032`		`- unsafe fn from_byte(u: u8) -> ~str { unsafe::from_bytes([u]) }`
	`2032`	`+ unsafe fn from_byte(u: u8) -> ~str { raw::from_bytes([u]) }`
`2033`	`2033`
`2034`	`2034`	`/**`
`2035`	`2035`	`* Takes a bytewise (not UTF-8) slice from a string.`
`@@ -2112,7 +2112,7 @@ mod unsafe {`
`2112`	`2112`	`let len = len(s);`
`2113`	`2113`	`assert (len > 0u);`
`2114`	`2114`	`let b = s[0];`
`2115`		`- s = unsafe { unsafe::slice_bytes(s, 1u, len) };`
	`2115`	`+ s = unsafe { raw::slice_bytes(s, 1u, len) };`
`2116`	`2116`	`return b;`
`2117`	`2117`	`}`
`2118`	`2118`
`@@ -2646,9 +2646,9 @@ mod tests {`
`2646`	`2646`	`#[test]`
`2647`	`2647`	`fn test_unsafe_slice() {`
`2648`	`2648`	`unsafe {`
`2649`		`- assert ~"ab" == unsafe::slice_bytes(~"abc", 0u, 2u);`
`2650`		`- assert ~"bc" == unsafe::slice_bytes(~"abc", 1u, 3u);`
`2651`		`- assert ~"" == unsafe::slice_bytes(~"abc", 1u, 1u);`
	`2649`	`+ assert ~"ab" == raw::slice_bytes(~"abc", 0u, 2u);`
	`2650`	`+ assert ~"bc" == raw::slice_bytes(~"abc", 1u, 3u);`
	`2651`	`+ assert ~"" == raw::slice_bytes(~"abc", 1u, 1u);`
`2652`	`2652`	`fn a_million_letter_a() -> ~str {`
`2653`	`2653`	`let mut i = 0;`
`2654`	`2654`	`let mut rs = ~"";`
`@@ -2662,7 +2662,7 @@ mod tests {`
`2662`	`2662`	`return rs;`
`2663`	`2663`	`}`
`2664`	`2664`	`assert half_a_million_letter_a() ==`
`2665`		`- unsafe::slice_bytes(a_million_letter_a(), 0u, 500000u);`
	`2665`	`+ raw::slice_bytes(a_million_letter_a(), 0u, 500000u);`
`2666`	`2666`	`}`
`2667`	`2667`	`}`
`2668`	`2668`
`@@ -2881,23 +2881,23 @@ mod tests {`
`2881`	`2881`	`#[test]`
`2882`	`2882`	`fn test_shift_byte() {`
`2883`	`2883`	`let mut s = ~"ABC";`
`2884`		`- let b = unsafe { unsafe::shift_byte(s) };`
	`2884`	`+ let b = unsafe { raw::shift_byte(s) };`
`2885`	`2885`	`assert (s == ~"BC");`
`2886`	`2886`	`assert (b == 65u8);`
`2887`	`2887`	`}`
`2888`	`2888`
`2889`	`2889`	`#[test]`
`2890`	`2890`	`fn test_pop_byte() {`
`2891`	`2891`	`let mut s = ~"ABC";`
`2892`		`- let b = unsafe { unsafe::pop_byte(s) };`
	`2892`	`+ let b = unsafe { raw::pop_byte(s) };`
`2893`	`2893`	`assert (s == ~"AB");`
`2894`	`2894`	`assert (b == 67u8);`
`2895`	`2895`	`}`
`2896`	`2896`
`2897`	`2897`	`#[test]`
`2898`	`2898`	`fn test_unsafe_from_bytes() {`
`2899`	`2899`	`let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];`
`2900`		`- let b = unsafe { unsafe::from_bytes(a) };`
	`2900`	`+ let b = unsafe { raw::from_bytes(a) };`
`2901`	`2901`	`assert (b == ~"AAAAAAA");`
`2902`	`2902`	`}`
`2903`	`2903`
`@@ -2941,7 +2941,7 @@ mod tests {`
`2941`	`2941`	`unsafe {`
`2942`	`2942`	`let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];`
`2943`	`2943`	`let b = vec::raw::to_ptr(a);`
`2944`		`- let c = unsafe::from_buf(b);`
	`2944`	`+ let c = raw::from_buf(b);`
`2945`	`2945`	`assert (c == ~"AAAAAAA");`
`2946`	`2946`	`}`
`2947`	`2947`	`}`
`@@ -2979,7 +2979,7 @@ mod tests {`
`2979`	`2979`	`unsafe {`
`2980`	`2980`	`let s = ~"hello";`
`2981`	`2981`	`let sb = as_buf(s, \|b, _l\| b);`
`2982`		`- let s_cstr = unsafe::from_buf(sb);`
	`2982`	`+ let s_cstr = raw::from_buf(sb);`
`2983`	`2983`	`assert s_cstr == s;`
`2984`	`2984`	`}`
`2985`	`2985`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ fn from_str_radix(buf: &str, radix: u64) -> Option<u64> {`
`175`	`175`	`pure fn to_str(num: T, radix: uint) -> ~str {`
`176`	`176`	`do to_str_bytes(false, num, radix) \|slice\| {`
`177`	`177`	`do vec::as_buf(slice) \|p, len\| {`
`178`		`- unsafe { str::unsafe::from_buf_len(p, len) }`
	`178`	`+ unsafe { str::raw::from_buf_len(p, len) }`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ fn llvm_err(sess: session, msg: ~str) -> ! unsafe {`
`37`	`37`	`let cstr = llvm::LLVMRustGetLastError();`
`38`	`38`	`if cstr == ptr::null() {`
`39`	`39`	`sess.fatal(msg);`
`40`		`- } else { sess.fatal(msg + ~": " + str::unsafe::from_c_str(cstr)); }`
	`40`	`+ } else { sess.fatal(msg + ~": " + str::raw::from_c_str(cstr)); }`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`fn WriteOutputFile(sess:session,`