---

yaml
---
r: 30506
b: refs/heads/incoming
c: ff54ac8
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 37cf649311bcf6fec2d9096b483ac4be81b70732
+refs/heads/incoming: ff54ac8e598bfc71e827c0b60e392c5f0fbd4d7e
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/at_vec.rs

@@ -15,7 +15,7 @@ export unsafe;
 #[abi = "cdecl"]
 extern mod rustrt {
     fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
-                                 ++v: **vec::unsafe::VecRepr,
+                                 ++v: **vec::raw::VecRepr,
                                  ++n: libc::size_t);
 }
 
@@ -142,8 +142,8 @@ impl<T: Copy> @[T]: Add<&[const T],@[T]> {
 
 
 mod unsafe {
-    type VecRepr = vec::unsafe::VecRepr;
-    type SliceRepr = vec::unsafe::SliceRepr;
+    type VecRepr = vec::raw::VecRepr;
+    type SliceRepr = vec::raw::SliceRepr;
 
     /**
      * Sets the length of a vector

branches/incoming/src/libcore/flate.rs

@@ -28,7 +28,7 @@ fn deflate_buf(buf: &[const u8]) -> ~[u8] {
                                                    ptr::addr_of(outsz),
                                                    lz_norm);
             assert res as int != 0;
-            let out = vec::unsafe::from_buf(res as *u8,
+            let out = vec::raw::from_buf(res as *u8,
                                             outsz as uint);
             libc::free(res);
             move out
@@ -46,7 +46,7 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {
                                                      ptr::addr_of(outsz),
                                                      0);
             assert res as int != 0;
-            let out = vec::unsafe::from_buf(res as *u8,
+            let out = vec::raw::from_buf(res as *u8,
                                             outsz as uint);
             libc::free(res);
             move out

branches/incoming/src/libcore/io.rs

@@ -53,11 +53,11 @@ impl<T: Reader> T : ReaderUtil {
     fn read_bytes(len: uint) -> ~[u8] {
         let mut buf = ~[mut];
         vec::reserve(buf, len);
-        unsafe { vec::unsafe::set_len(buf, len); }
+        unsafe { vec::raw::set_len(buf, len); }
 
         let count = self.read(buf, len);
 
-        unsafe { vec::unsafe::set_len(buf, count); }
+        unsafe { vec::raw::set_len(buf, count); }
         vec::from_mut(move buf)
     }
     fn read_line() -> ~str {
@@ -682,7 +682,7 @@ impl MemBuffer: Writer {
 
             let count = uint::max(buf_len, self.pos + v_len);
             vec::reserve(buf, count);
-            unsafe { vec::unsafe::set_len(buf, count); }
+            unsafe { vec::raw::set_len(buf, count); }
 
             vec::u8::memcpy(vec::mut_view(buf, self.pos, count), v, v_len);
 

branches/incoming/src/libcore/ptr.rs

@@ -265,14 +265,14 @@ fn test() {
         let mut v0 = ~[32000u16, 32001u16, 32002u16];
         let mut v1 = ~[0u16, 0u16, 0u16];
 
-        ptr::memcpy(ptr::mut_offset(vec::unsafe::to_mut_ptr(v1), 1u),
-                    ptr::offset(vec::unsafe::to_ptr(v0), 1u), 1u);
+        ptr::memcpy(ptr::mut_offset(vec::raw::to_mut_ptr(v1), 1u),
+                    ptr::offset(vec::raw::to_ptr(v0), 1u), 1u);
         assert (v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16);
-        ptr::memcpy(vec::unsafe::to_mut_ptr(v1),
-                    ptr::offset(vec::unsafe::to_ptr(v0), 2u), 1u);
+        ptr::memcpy(vec::raw::to_mut_ptr(v1),
+                    ptr::offset(vec::raw::to_ptr(v0), 2u), 1u);
         assert (v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16);
-        ptr::memcpy(ptr::mut_offset(vec::unsafe::to_mut_ptr(v1), 2u),
-                    vec::unsafe::to_ptr(v0), 1u);
+        ptr::memcpy(ptr::mut_offset(vec::raw::to_mut_ptr(v1), 2u),
+                    vec::raw::to_ptr(v0), 1u);
         assert (v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16);
     }
 }

branches/incoming/src/libcore/str.rs

@@ -439,15 +439,15 @@ Section: Transforming strings
  */
 pure fn to_bytes(s: &str) -> ~[u8] unsafe {
     let mut v: ~[u8] = ::unsafe::transmute(from_slice(s));
-    vec::unsafe::set_len(v, len(s));
+    vec::raw::set_len(v, len(s));
     move v
 }
 
 /// Work with the string as a byte slice, not including trailing null.
 #[inline(always)]
 pure fn byte_slice<T>(s: &str, f: fn(v: &[u8]) -> T) -> T {
     do as_buf(s) |p,n| {
-        unsafe { vec::unsafe::form_slice(p, n-1u, f) }
+        unsafe { vec::raw::form_slice(p, n-1u, f) }
     }
 }
 
@@ -1996,7 +1996,7 @@ mod unsafe {
             let vbuf = ::unsafe::transmute_mut_unsafe(vbuf);
             ptr::memcpy(vbuf, buf as *u8, len)
         });
-        vec::unsafe::set_len(v, len);
+        vec::raw::set_len(v, len);
         vec::push(v, 0u8);
 
         assert is_utf8(v);
@@ -2054,7 +2054,7 @@ mod unsafe {
                     let src = ptr::offset(sbuf, begin);
                     ptr::memcpy(vbuf, src, end - begin);
                 }
-                vec::unsafe::set_len(v, end - begin);
+                vec::raw::set_len(v, end - begin);
                 vec::push(v, 0u8);
                 ::unsafe::transmute(move v)
             }
@@ -2118,7 +2118,7 @@ mod unsafe {
 
     /// Sets the length of the string and adds the null terminator
     unsafe fn set_len(&v: ~str, new_len: uint) {
-        let repr: *vec::unsafe::VecRepr = ::unsafe::reinterpret_cast(&v);
+        let repr: *vec::raw::VecRepr = ::unsafe::reinterpret_cast(&v);
         (*repr).fill = new_len + 1u;
         let null = ptr::mut_offset(ptr::mut_addr_of((*repr).data), new_len);
         *null = 0u8;
@@ -2128,7 +2128,7 @@ mod unsafe {
     fn test_from_buf_len() {
         unsafe {
             let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
-            let b = vec::unsafe::to_ptr(a);
+            let b = vec::raw::to_ptr(a);
             let c = from_buf_len(b, 3u);
             assert (c == ~"AAA");
         }
@@ -2940,7 +2940,7 @@ mod tests {
     fn test_from_buf() {
         unsafe {
             let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
-            let b = vec::unsafe::to_ptr(a);
+            let b = vec::raw::to_ptr(a);
             let c = unsafe::from_buf(b);
             assert (c == ~"AAAAAAA");
         }

branches/incoming/src/libcore/uint-template.rs

@@ -239,7 +239,7 @@ pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
                 *ptr::mut_offset(mp, i) = '-' as u8;
             }
 
-            vec::unsafe::form_slice(ptr::offset(p, i),
+            vec::raw::form_slice(ptr::offset(p, i),
                                     len - i, f)
         }
     }