fixup mutability of vec::each, make iter_bytes pure

also, change DVec() to work with imm vectors rather than mut ones

Author: nikomatsakis

src/libcore/dvec.rs

@@ -50,7 +50,7 @@ export unwrap;
  * type could only produce 47 million pushes/second.
  */
 type DVec_<A> = {
-    mut data: ~[mut A]
+    mut data: ~[A]
 };
 
 enum DVec<A> {
@@ -59,21 +59,21 @@ enum DVec<A> {
 
 /// Creates a new, empty dvec
 fn DVec<A>() -> DVec<A> {
-    DVec_({mut data: ~[mut]})
+    DVec_({mut data: ~[]})
 }
 
 /// Creates a new dvec with a single element
 fn from_elem<A>(+e: A) -> DVec<A> {
-    DVec_({mut data: ~[mut move e]})
+    DVec_({mut data: ~[move e]})
 }
 
 /// Creates a new dvec with the contents of a vector
-fn from_vec<A>(+v: ~[mut A]) -> DVec<A> {
+fn from_vec<A>(+v: ~[A]) -> DVec<A> {
     DVec_({mut data: move v})
 }
 
 /// Consumes the vector and returns its contents
-fn unwrap<A>(+d: DVec<A>) -> ~[mut A] {
+fn unwrap<A>(+d: DVec<A>) -> ~[A] {
     let DVec_({data: v}) <- d;
     move v
 }
@@ -89,7 +89,7 @@ priv impl<A> DVec<A> {
     }
 
     #[inline(always)]
-    fn check_out<B>(f: fn(-~[mut A]) -> B) -> B {
+    fn check_out<B>(f: fn(-~[A]) -> B) -> B {
         unsafe {
             let mut data = unsafe::reinterpret_cast(&null::<()>());
             data <-> self.data;
@@ -100,9 +100,9 @@ priv impl<A> DVec<A> {
     }
 
     #[inline(always)]
-    fn give_back(-data: ~[mut A]) {
+    fn give_back(+data: ~[A]) {
         unsafe {
-            self.data <- data;
+            self.data = move data;
         }
     }
 }
@@ -122,10 +122,22 @@ impl<A> DVec<A> {
      * and return a new vector to replace it with.
      */
     #[inline(always)]
-    fn swap(f: fn(-~[mut A]) -> ~[mut A]) {
+    fn swap(f: fn(-~[A]) -> ~[A]) {
         self.check_out(|v| self.give_back(f(move v)))
     }
 
+    /**
+     * Swaps out the current vector and hands it off to a user-provided
+     * function `f`.  The function should transform it however is desired
+     * and return a new vector to replace it with.
+     */
+    #[inline(always)]
+    fn swap_mut(f: fn(-~[mut A]) -> ~[mut A]) {
+        do self.swap |v| {
+            vec::from_mut(f(vec::to_mut(move v)))
+        }
+    }
+
     /// Returns the number of elements currently in the dvec
     pure fn len() -> uint {
         unchecked {
@@ -138,7 +150,7 @@ impl<A> DVec<A> {
     }
 
     /// Overwrite the current contents
-    fn set(+w: ~[mut A]) {
+    fn set(+w: ~[A]) {
         self.check_not_borrowed();
         self.data <- w;
     }
@@ -161,7 +173,7 @@ impl<A> DVec<A> {
             let data_ptr: *() = unsafe::reinterpret_cast(&data);
             if data_ptr.is_null() { fail ~"Recursive use of dvec"; }
             log(error, ~"a");
-            self.data <- ~[mut move t];
+            self.data <- ~[move t];
             vec::push_all_move(self.data, move data);
             log(error, ~"b");
         }
@@ -176,16 +188,17 @@ impl<A> DVec<A> {
     /// Remove and return the first element
     fn shift() -> A {
         do self.check_out |v| {
-            let mut v = vec::from_mut(move v);
+            let mut v = move v;
             let result = vec::shift(v);
-            self.give_back(vec::to_mut(move v));
+            self.give_back(move v);
             move result
         }
     }
 
     /// Reverse the elements in the list, in place
     fn reverse() {
         do self.check_out |v| {
+            let mut v = move v;
             vec::reverse(v);
             self.give_back(move v);
         }
@@ -203,6 +216,7 @@ impl<A> DVec<A> {
     /// Gives access to the vector as a slice with mutable contents
     fn borrow_mut<R>(op: fn(x: &[mut A]) -> R) -> R {
         do self.check_out |v| {
+            let mut v = move v;
             let result = op(v);
             self.give_back(move v);
             move result
@@ -268,7 +282,7 @@ impl<A: Copy> DVec<A> {
     pure fn get() -> ~[A] {
         unchecked {
             do self.check_out |v| {
-                let w = vec::from_mut(copy v);
+                let w = copy v;
                 self.give_back(move v);
                 move w
             }
@@ -295,9 +309,9 @@ impl<A: Copy> DVec<A> {
      */
     fn grow_set_elt(idx: uint, initval: A, val: A) {
         do self.swap |v| {
-            let mut v <- v;
+            let mut v = vec::to_mut(move v);
             vec::grow_set(v, idx, initval, val);
-            move v
+            move vec::from_mut(v)
         }
     }
 

src/libcore/hash.rs

@@ -130,7 +130,7 @@ pure fn hash_keyed_5<A: IterBytes,
     }
 }
 
-pure fn hash_bytes_keyed(val: &[const u8], k0: u64, k1: u64) -> u64 {
+pure fn hash_bytes_keyed(val: &[u8], k0: u64, k1: u64) -> u64 {
     val.hash_keyed(k0, k1)
 }
 pure fn hash_str_keyed(val: &str, k0: u64, k1: u64) -> u64 {
@@ -152,7 +152,7 @@ pure fn hash_uint_keyed(val: uint, k0: u64, k1: u64) -> u64 {
     val.hash_keyed(k0, k1)
 }
 
-pure fn hash_bytes(val: &[const u8]) -> u64 { hash_bytes_keyed(val, 0, 0) }
+pure fn hash_bytes(val: &[u8]) -> u64 { hash_bytes_keyed(val, 0, 0) }
 pure fn hash_str(val: &str) -> u64 { hash_str_keyed(val, 0, 0) }
 pure fn hash_u64(val: u64) -> u64 { hash_u64_keyed(val, 0, 0) }
 pure fn hash_u32(val: u32) -> u64 { hash_u32_keyed(val, 0, 0) }

src/libcore/io.rs

@@ -214,7 +214,7 @@ fn convert_whence(whence: SeekStyle) -> i32 {
 
 impl *libc::FILE: Reader {
     fn read(buf: &[mut u8], len: uint) -> uint {
-        do vec::as_buf(buf) |buf_p, buf_len| {
+        do vec::as_mut_buf(buf) |buf_p, buf_len| {
             assert buf_len <= len;
 
             let count = libc::fread(buf_p as *mut c_void, 1u as size_t,

src/libcore/ptr.rs

@@ -2,6 +2,7 @@
 
 export addr_of;
 export to_unsafe_ptr;
+export to_const_unsafe_ptr;
 export to_mut_unsafe_ptr;
 export mut_addr_of;
 export offset;
@@ -26,11 +27,16 @@ use libc::{c_void, size_t};
 #[abi = "cdecl"]
 extern mod libc_ {
     #[rust_stack]
-    fn memcpy(dest: *c_void, src: *c_void, n: libc::size_t) -> *c_void;
+    fn memcpy(dest: *mut c_void, src: *const c_void,
+              n: libc::size_t) -> *c_void;
+
     #[rust_stack]
-    fn memmove(dest: *c_void, src: *c_void, n: libc::size_t) -> *c_void;
+    fn memmove(dest: *mut c_void, src: *const c_void,
+               n: libc::size_t) -> *c_void;
+
     #[rust_stack]
-    fn memset(dest: *c_void, c: libc::c_int, len: libc::size_t) -> *c_void;
+    fn memset(dest: *mut c_void, c: libc::c_int,
+              len: libc::size_t) -> *c_void;
 }
 
 #[abi = "rust-intrinsic"]
@@ -105,9 +111,9 @@ pure fn is_not_null<T>(ptr: *const T) -> bool { !is_null(ptr) }
  * and destination may not overlap.
  */
 #[inline(always)]
-unsafe fn memcpy<T>(dst: *T, src: *T, count: uint) {
+unsafe fn memcpy<T>(dst: *mut T, src: *const T, count: uint) {
     let n = count * sys::size_of::<T>();
-    libc_::memcpy(dst as *c_void, src as *c_void, n as size_t);
+    libc_::memcpy(dst as *mut c_void, src as *c_void, n as size_t);
 }
 
 /**
@@ -117,15 +123,15 @@ unsafe fn memcpy<T>(dst: *T, src: *T, count: uint) {
  * and destination may overlap.
  */
 #[inline(always)]
-unsafe fn memmove<T>(dst: *T, src: *T, count: uint)  {
+unsafe fn memmove<T>(dst: *mut T, src: *const T, count: uint)  {
     let n = count * sys::size_of::<T>();
-    libc_::memmove(dst as *c_void, src as *c_void, n as size_t);
+    libc_::memmove(dst as *mut c_void, src as *c_void, n as size_t);
 }
 
 #[inline(always)]
 unsafe fn memset<T>(dst: *mut T, c: int, count: uint)  {
     let n = count * sys::size_of::<T>();
-    libc_::memset(dst as *c_void, c as libc::c_int, n as size_t);
+    libc_::memset(dst as *mut c_void, c as libc::c_int, n as size_t);
 }
 
 
@@ -135,8 +141,18 @@ unsafe fn memset<T>(dst: *mut T, c: int, count: uint)  {
   reinterpret_cast.
 */
 #[inline(always)]
-fn to_unsafe_ptr<T>(thing: &T) -> *T unsafe {
-    unsafe::reinterpret_cast(&thing)
+fn to_unsafe_ptr<T>(thing: &T) -> *T {
+    unsafe { unsafe::reinterpret_cast(&thing) }
+}
+
+/**
+  Transform a const region pointer - &const T - to a const unsafe pointer -
+  *const T. This is safe, but is implemented with an unsafe block due to
+  reinterpret_cast.
+*/
+#[inline(always)]
+fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
+    unsafe { unsafe::reinterpret_cast(&thing) }
 }
 
 /**
@@ -145,8 +161,8 @@ fn to_unsafe_ptr<T>(thing: &T) -> *T unsafe {
   reinterpret_cast.
 */
 #[inline(always)]
-fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T unsafe {
-    unsafe::reinterpret_cast(&thing)
+fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
+    unsafe { unsafe::reinterpret_cast(&thing) }
 }
 
 /**
@@ -246,16 +262,16 @@ fn test() {
         assert (p.fst == 50);
         assert (p.snd == 60);
 
-        let v0 = ~[32000u16, 32001u16, 32002u16];
-        let v1 = ~[0u16, 0u16, 0u16];
+        let mut v0 = ~[32000u16, 32001u16, 32002u16];
+        let mut v1 = ~[0u16, 0u16, 0u16];
 
-        ptr::memcpy(ptr::offset(vec::unsafe::to_ptr(v1), 1u),
+        ptr::memcpy(ptr::mut_offset(vec::unsafe::to_mut_ptr(v1), 1u),
                     ptr::offset(vec::unsafe::to_ptr(v0), 1u), 1u);
         assert (v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16);
-        ptr::memcpy(vec::unsafe::to_ptr(v1),
+        ptr::memcpy(vec::unsafe::to_mut_ptr(v1),
                     ptr::offset(vec::unsafe::to_ptr(v0), 2u), 1u);
         assert (v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16);
-        ptr::memcpy(ptr::offset(vec::unsafe::to_ptr(v1), 2u),
+        ptr::memcpy(ptr::mut_offset(vec::unsafe::to_mut_ptr(v1), 2u),
                     vec::unsafe::to_ptr(v0), 1u);
         assert (v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16);
     }

src/libcore/str.rs

@@ -250,6 +250,7 @@ fn push_str_no_overallocate(&lhs: ~str, rhs: &str) {
         do as_buf(lhs) |lbuf, _llen| {
             do as_buf(rhs) |rbuf, _rlen| {
                 let dst = ptr::offset(lbuf, llen);
+                let dst = ::unsafe::transmute_mut_unsafe(dst);
                 ptr::memcpy(dst, rbuf, rlen);
             }
         }
@@ -266,6 +267,7 @@ fn push_str(&lhs: ~str, rhs: &str) {
         do as_buf(lhs) |lbuf, _llen| {
             do as_buf(rhs) |rbuf, _rlen| {
                 let dst = ptr::offset(lbuf, llen);
+                let dst = ::unsafe::transmute_mut_unsafe(dst);
                 ptr::memcpy(dst, rbuf, rlen);
             }
         }
@@ -1990,7 +1992,10 @@ mod unsafe {
     unsafe fn from_buf_len(buf: *const u8, len: uint) -> ~str {
         let mut v: ~[mut u8] = ~[mut];
         vec::reserve(v, len + 1u);
-        vec::as_buf(v, |b, _len| ptr::memcpy(b, buf as *u8, len));
+        vec::as_buf(v, |vbuf, _len| {
+            let vbuf = ::unsafe::transmute_mut_unsafe(vbuf);
+            ptr::memcpy(vbuf, buf as *u8, len)
+        });
         vec::unsafe::set_len(v, len);
         vec::push(v, 0u8);
 
@@ -2045,6 +2050,7 @@ mod unsafe {
             vec::reserve(v, end - begin + 1u);
             unsafe {
                 do vec::as_buf(v) |vbuf, _vlen| {
+                    let vbuf = ::unsafe::transmute_mut_unsafe(vbuf);
                     let src = ptr::offset(sbuf, begin);
                     ptr::memcpy(vbuf, src, end - begin);
                 }