---

yaml
---
r: 72191
b: refs/heads/dist-snap
c: 51a68eb
h: refs/heads/master
i:
  72189: 36038d7
  72187: 01d3df8
  72183: b4d4db0
  72175: b121c0e
  72159: b12ff77
  72127: 2c1ed41
  72063: 79b0b28
  71935: 1bbe313
  71679: 4addab6
v: v3

Author: Thiez

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 3c2a44b60f472827884c868c527debbd7e61b054
+refs/heads/dist-snap: 51a68eb9b14f5d6f8ac358eed8c11e8567d5f87b
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/at_vec.rs

@@ -41,7 +41,7 @@ pub mod rustrt {
 pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr =
-            ::cast::reinterpret_cast(&addr_of(&v));
+            ::cast::transmute(addr_of(&v));
         (**repr).unboxed.alloc / sys::size_of::<T>()
     }
 }
@@ -208,7 +208,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
+        let repr: **mut VecRepr = ::cast::transmute(addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -226,7 +226,7 @@ pub mod raw {
 
     #[inline(always)] // really pretty please
     pub unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&v);
+        let repr: **mut VecRepr = ::cast::transmute(v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = addr_of(&((**repr).unboxed.data));
@@ -322,4 +322,4 @@ mod test {
         assert!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]);
         assert!(from_slice([@[42]]) == @[@[42]]);
     }
-}
+}

branches/dist-snap/src/libcore/gc.rs

@@ -77,14 +77,14 @@ pub mod rustrt {
 }
 
 unsafe fn bump<T, U>(ptr: *T, count: uint) -> *U {
-    return cast::reinterpret_cast(&ptr::offset(ptr, count));
+    return cast::transmute(ptr::offset(ptr, count));
 }
 
 unsafe fn align_to_pointer<T>(ptr: *T) -> *T {
     let align = sys::min_align_of::<*T>();
-    let ptr: uint = cast::reinterpret_cast(&ptr);
+    let ptr: uint = cast::transmute(ptr);
     let ptr = (ptr + (align - 1)) & -align;
-    return cast::reinterpret_cast(&ptr);
+    return cast::transmute(ptr);
 }
 
 unsafe fn get_safe_point_count() -> uint {
@@ -129,8 +129,8 @@ type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
 unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
-    let fp_bytes: *u8 = cast::reinterpret_cast(&fp);
-    let sp_meta: *u32 = cast::reinterpret_cast(&sp.sp_meta);
+    let fp_bytes: *u8 = cast::transmute(fp);
+    let sp_meta: *u32 = cast::transmute(sp.sp_meta);
 
     let num_stack_roots = *sp_meta as uint;
     let num_reg_roots = *ptr::offset(sp_meta, 1) as uint;
@@ -171,9 +171,9 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
 
 // Is fp contained in segment?
 unsafe fn is_frame_in_segment(fp: *Word, segment: *StackSegment) -> bool {
-    let begin: Word = cast::reinterpret_cast(&segment);
-    let end: Word = cast::reinterpret_cast(&(*segment).end);
-    let frame: Word = cast::reinterpret_cast(&fp);
+    let begin: Word = cast::transmute(segment);
+    let end: Word = cast::transmute((*segment).end);
+    let frame: Word = cast::transmute(fp);
 
     return begin <= frame && frame <= end;
 }
@@ -339,7 +339,7 @@ pub fn cleanup_stack_for_failure() {
         // own stack roots on the stack anyway.
         let sentinel_box = ~0;
         let sentinel: **Word = if expect_sentinel() {
-            cast::reinterpret_cast(&ptr::addr_of(&sentinel_box))
+            cast::transmute(ptr::addr_of(&sentinel_box))
         } else {
             ptr::null()
         };

branches/dist-snap/src/libcore/iterator.rs

@@ -39,8 +39,6 @@ pub trait IteratorUtil<A> {
     fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>;
     fn skip(self, n: uint) -> SkipIterator<Self>;
     fn take(self, n: uint) -> TakeIterator<Self>;
-    fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
-        -> ScanIterator<'r, A, B, Self, St>;
     fn advance(&mut self, f: &fn(A) -> bool);
 }
 
@@ -95,12 +93,6 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
         TakeIterator{iter: self, n: n}
     }
 
-    #[inline(always)]
-    fn scan<'r, St, B>(self, initial_state: St, f: &'r fn(&mut St, A) -> Option<B>)
-        -> ScanIterator<'r, A, B, T, St> {
-        ScanIterator{iter: self, f: f, state: initial_state}
-    }
-
     /// A shim implementing the `for` loop iteration protocol for iterator objects
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) {
@@ -314,13 +306,12 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
 
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
-    state: St
+    priv state: St
 }
 
 pub impl<'self, A, St> UnfoldrIterator<'self, A, St> {
     #[inline]
-    fn new(f: &'self fn(&mut St) -> Option<A>, initial_state: St)
-        -> UnfoldrIterator<'self, A, St> {
+    fn new(f: &'self fn(&mut St) -> Option<A>, initial_state: St) -> UnfoldrIterator<'self, A, St> {
         UnfoldrIterator {
             f: f,
             state: initial_state
@@ -335,19 +326,6 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
-}
-
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -428,25 +406,6 @@ mod tests {
         assert_eq!(i, ys.len());
     }
 
-    #[test]
-    fn test_iterator_scan() {
-        // test the type inference
-        fn add(old: &mut int, new: &uint) -> Option<float> {
-            *old += *new as int;
-            Some(*old as float)
-        }
-        let xs = [0u, 1, 2, 3, 4];
-        let ys = [0f, 1f, 3f, 6f, 10f];
-
-        let mut it = xs.iter().scan(0, add);
-        let mut i = 0;
-        for it.advance |x| {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
     #[test]
     fn test_unfoldr() {
         fn count(st: &mut uint) -> Option<uint> {

branches/dist-snap/src/libcore/os.rs

@@ -239,10 +239,10 @@ pub fn getenv(n: &str) -> Option<~str> {
     unsafe {
         do with_env_lock {
             let s = str::as_c_str(n, |s| libc::getenv(s));
-            if ptr::null::<u8>() == cast::reinterpret_cast(&s) {
+            if ptr::null::<u8>() == cast::transmute(s) {
                 option::None::<~str>
             } else {
-                let s = cast::reinterpret_cast(&s);
+                let s = cast::transmute(s);
                 option::Some::<~str>(str::raw::from_buf(s))
             }
         }
@@ -644,7 +644,7 @@ pub fn make_dir(p: &Path, mode: c_int) -> bool {
             // FIXME: turn mode into something useful? #2623
             do as_utf16_p(p.to_str()) |buf| {
                 libc::CreateDirectoryW(buf, unsafe {
-                    cast::reinterpret_cast(&0)
+                    cast::transmute(0)
                 })
                     != (0 as libc::BOOL)
             }

branches/dist-snap/src/libcore/ptr.rs

@@ -86,11 +86,11 @@ pub unsafe fn position<T>(buf: *T, f: &fn(&T) -> bool) -> uint {
 
 /// Create an unsafe null pointer
 #[inline(always)]
-pub fn null<T>() -> *T { unsafe { cast::reinterpret_cast(&0u) } }
+pub fn null<T>() -> *T { unsafe { cast::transmute(0u) } }
 
 /// Create an unsafe mutable null pointer
 #[inline(always)]
-pub fn mut_null<T>() -> *mut T { unsafe { cast::reinterpret_cast(&0u) } }
+pub fn mut_null<T>() -> *mut T { unsafe { cast::transmute(0u) } }
 
 /// Returns true if the pointer is equal to the null pointer.
 #[inline(always)]
@@ -134,7 +134,7 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: int, count: uint) {
 */
 #[inline(always)]
 pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
-    unsafe { cast::reinterpret_cast(&thing) }
+    unsafe { cast::transmute(thing) }
 }
 
 /**
@@ -144,7 +144,7 @@ pub fn to_unsafe_ptr<T>(thing: &T) -> *T {
 */
 #[inline(always)]
 pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
-    unsafe { cast::reinterpret_cast(&thing) }
+    unsafe { cast::transmute(thing) }
 }
 
 /**
@@ -154,7 +154,7 @@ pub fn to_const_unsafe_ptr<T>(thing: &const T) -> *const T {
 */
 #[inline(always)]
 pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
-    unsafe { cast::reinterpret_cast(&thing) }
+    unsafe { cast::transmute(thing) }
 }
 
 /**
@@ -167,7 +167,7 @@ pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
 #[inline(always)]
 pub fn to_uint<T>(thing: &T) -> uint {
     unsafe {
-        cast::reinterpret_cast(&thing)
+        cast::transmute(thing)
     }
 }
 
@@ -259,8 +259,8 @@ impl<T> Eq for *const T {
     #[inline(always)]
     fn eq(&self, other: &*const T) -> bool {
         unsafe {
-            let a: uint = cast::reinterpret_cast(&(*self));
-            let b: uint = cast::reinterpret_cast(&(*other));
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
             return a == b;
         }
     }
@@ -274,32 +274,32 @@ impl<T> Ord for *const T {
     #[inline(always)]
     fn lt(&self, other: &*const T) -> bool {
         unsafe {
-            let a: uint = cast::reinterpret_cast(&(*self));
-            let b: uint = cast::reinterpret_cast(&(*other));
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
             return a < b;
         }
     }
     #[inline(always)]
     fn le(&self, other: &*const T) -> bool {
         unsafe {
-            let a: uint = cast::reinterpret_cast(&(*self));
-            let b: uint = cast::reinterpret_cast(&(*other));
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
             return a <= b;
         }
     }
     #[inline(always)]
     fn ge(&self, other: &*const T) -> bool {
         unsafe {
-            let a: uint = cast::reinterpret_cast(&(*self));
-            let b: uint = cast::reinterpret_cast(&(*other));
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
             return a >= b;
         }
     }
     #[inline(always)]
     fn gt(&self, other: &*const T) -> bool {
         unsafe {
-            let a: uint = cast::reinterpret_cast(&(*self));
-            let b: uint = cast::reinterpret_cast(&(*other));
+            let a: uint = cast::transmute(*self);
+            let b: uint = cast::transmute(*other);
             return a > b;
         }
     }
@@ -350,7 +350,7 @@ pub mod ptr_tests {
             struct Pair {mut fst: int, mut snd: int};
             let mut p = Pair {fst: 10, snd: 20};
             let pptr: *mut Pair = &mut p;
-            let iptr: *mut int = cast::reinterpret_cast(&pptr);
+            let iptr: *mut int = cast::transmute(pptr);
             assert!((*iptr == 10));;
             *iptr = 30;
             assert!((*iptr == 30));

branches/dist-snap/src/libcore/run.rs

@@ -147,7 +147,7 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
         }
         ptrs.push(ptr::null());
         vec::as_imm_buf(ptrs, |p, _len|
-            unsafe { cb(::cast::reinterpret_cast(&p)) }
+            unsafe { cb(::cast::transmute(p)) }
         )
       }
       _ => cb(ptr::null())
@@ -167,12 +167,12 @@ fn with_envp<T>(env: &Option<~[(~str,~str)]>,
             for vec::each(*es) |e| {
                 let (k,v) = copy *e;
                 let t = fmt!("%s=%s", k, v);
-                let mut v : ~[u8] = ::cast::reinterpret_cast(&t);
+                let mut v : ~[u8] = ::cast::transmute(t);
                 blk += v;
                 ::cast::forget(v);
             }
             blk += ~[0_u8];
-            vec::as_imm_buf(blk, |p, _len| cb(::cast::reinterpret_cast(&p)))
+            vec::as_imm_buf(blk, |p, _len| cb(::cast::transmute(p)))
           }
           _ => cb(ptr::null())
         }

branches/dist-snap/src/libcore/stackwalk.rs

@@ -10,7 +10,7 @@
 
 #[doc(hidden)]; // FIXME #3538
 
-use cast::reinterpret_cast;
+use cast::transmute;
 
 pub type Word = uint;
 
@@ -30,16 +30,16 @@ pub fn walk_stack(visit: &fn(Frame) -> bool) {
 
     do frame_address |frame_pointer| {
         let mut frame_address: *Word = unsafe {
-            reinterpret_cast(&frame_pointer)
+            transmute(frame_pointer)
         };
         loop {
             let fr = Frame(frame_address);
 
-            debug!("frame: %x", unsafe { reinterpret_cast(&fr.fp) });
+            debug!("frame: %x", unsafe { transmute(fr.fp) });
             visit(fr);
 
             unsafe {
-                let next_fp: **Word = reinterpret_cast(&frame_address);
+                let next_fp: **Word = transmute(frame_address);
                 frame_address = *next_fp;
                 if *frame_address == 0u {
                     debug!("encountered task_start_wrapper. ending walk");