---

yaml
---
r: 35554
b: refs/heads/master
c: 2f3d4f6
h: refs/heads/master
v: v3

Author: ttaubert

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ebd9ad4d0446ac76bdbb0ada21e943ad0cbeef60
+refs/heads/master: 2f3d4f61817fcfe48c03990f94175258bdbcc0cb
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024

trunk/RELEASES.txt

@@ -28,7 +28,7 @@ Version 0.5 (December 2012)
       * `use` statements now take crate-relative paths
 
    * Improved support for language features
-      * Trait constraints work in many scenarios
+      * Trait inheritance is much more complete
       * More support for explicit self arguments in methods - `self`, `&self`
         `@self`, and `~self` all generally work as expected
       * Static methods work in more situations

trunk/doc/manual.css

@@ -30,12 +30,8 @@ doc/rust.css: rust.css
 	@$(call E, cp: $@)
 	$(Q)cp -a $< $@ 2> /dev/null
 
-doc/manual.css: manual.css
-	@$(call E, cp: $@)
-	$(Q)cp -a $< $@ 2> /dev/null
-
 DOCS += doc/rust.html
-doc/rust.html: rust.md doc/version_info.html doc/rust.css doc/manual.css
+doc/rust.html: rust.md doc/version_info.html doc/rust.css
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
 	"$(CFG_PANDOC)" \
@@ -44,7 +40,6 @@ doc/rust.html: rust.md doc/version_info.html doc/rust.css doc/manual.css
          --number-sections \
          --from=markdown --to=html \
          --css=rust.css \
-         --css=manual.css \
 	 --include-before-body=doc/version_info.html \
          --output=$@
   endif

trunk/mk/docs.mk

@@ -179,7 +179,7 @@ pub pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
                    f: fn(v: &[u8]) -> U) -> U {
 
     #[inline(always)]
-    fn digit(n: T) -> u8 {
+    pure fn digit(n: T) -> u8 {
         if n <= 9u as T {
             n as u8 + '0' as u8
         } else if n <= 15u as T {
@@ -195,35 +195,27 @@ pub pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
     // Worst case: 64-bit number, binary-radix, with
     // a leading negative sign = 65 bytes.
     let buf : [mut u8 * 65] = [mut 0u8, ..65];
+    let len = buf.len();
 
-    // FIXME (#2649): post-snapshot, you can do this without the raw
-    // pointers and unsafe bits, and the codegen will prove it's all
-    // in-bounds, no extra cost.
-
-    unsafe {
-        do vec::as_imm_buf(buf) |p, len| {
-            let mp = p as *mut u8;
-            let mut i = len;
-            let mut n = num;
-            let radix = radix as T;
-            loop {
-                i -= 1u;
-                assert 0u < i && i < len;
-                *ptr::mut_offset(mp, i) = digit(n % radix);
-                n /= radix;
-                if n == 0 as T { break; }
-            }
-
-            assert 0u < i && i < len;
-
-            if neg {
-                i -= 1u;
-                *ptr::mut_offset(mp, i) = '-' as u8;
-            }
-
-            vec::raw::buf_as_slice(ptr::offset(p, i), len - i, f)
-        }
+    let mut i = len;
+    let mut n = num;
+    let radix = radix as T;
+    loop {
+        i -= 1u;
+        assert 0u < i && i < len;
+        buf[i] = digit(n % radix);
+        n /= radix;
+        if n == 0 as T { break; }
+    }
+
+    assert 0u < i && i < len;
+
+    if neg {
+        i -= 1u;
+        buf[i] = '-' as u8;
     }
+
+    f(vec::view(buf, i, len))
 }
 
 /// Convert to a string

trunk/src/libcore/uint-template.rs

@@ -29,7 +29,6 @@ extern mod rustrt {
 #[abi = "rust-intrinsic"]
 extern mod rusti {
     fn move_val_init<T>(dst: &mut T, -src: T);
-    fn init<T>() -> T;
 }
 
 
@@ -399,51 +398,28 @@ pub fn rsplitn<T: Copy>(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] {
 // Mutators
 
 /// Removes the first element from a vector and return it
-pub fn shift<T>(v: &mut ~[T]) -> T unsafe {
-
-    assert v.is_not_empty();
-
-    if v.len() == 1 { return v.pop() }
-
-    if v.len() == 2 {
-        let last = v.pop();
-        let first = v.pop();
-        v.push(last);
-        return first;
-    }
-
+pub fn shift<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
-    let next_ln = v.len() - 1;
-
-    // Save the last element. We're going to overwrite its position
-    let mut work_elt = v.pop();
-    // We still should have room to work where what last element was
-    assert capacity(v) >= ln;
-    // Pretend like we have the original length so we can use
-    // the vector memcpy to overwrite the hole we just made
-    raw::set_len(v, ln);
-
-    // Memcopy the head element (the one we want) to the location we just
-    // popped. For the moment it unsafely exists at both the head and last
-    // positions
-    let first_slice = view(*v, 0, 1);
-    let last_slice = mut_view(*v, next_ln, ln);
-    raw::memcpy(last_slice, first_slice, 1);
+    assert (ln > 0);
 
-    // Memcopy everything to the left one element
-    let init_slice = mut_view(*v, 0, next_ln);
-    let tail_slice = view(*v, 1, ln);
-    raw::memcpy(init_slice, tail_slice, next_ln);
-
-    // Set the new length. Now the vector is back to normal
-    raw::set_len(v, next_ln);
+    let mut vv = ~[];
+    *v <-> vv;
 
-    // Swap out the element we want from the end
-    let vp = raw::to_mut_ptr(*v);
-    let vp = ptr::mut_offset(vp, next_ln - 1);
-    *vp <-> work_elt;
+    unsafe {
+        let mut rr;
+        {
+            let vv = raw::to_ptr(vv);
+            rr = move *vv;
+
+            for uint::range(1, ln) |i| {
+                let r = move *ptr::offset(vv, i);
+                v.push(r);
+            }
+        }
+        raw::set_len(&mut vv, 0);
 
-    return work_elt;
+        rr
+    }
 }
 
 /// Prepend an element to the vector
@@ -484,15 +460,9 @@ pub fn remove<T>(v: &mut ~[T], i: uint) -> T {
 pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
     let mut v = v; // FIXME(#3488)
 
-    do as_mut_buf(v) |p, ln| {
+    do as_imm_buf(v) |p, ln| {
         for uint::range(0, ln) |i| {
-            // NB: This unsafe operation counts on init writing 0s to the
-            // holes we create in the vector. That ensures that, if the
-            // iterator fails then we won't try to clean up the consumed
-            // elements during unwinding
-            let mut x = rusti::init();
-            let p = ptr::mut_offset(p, i);
-            x <-> *p;
+            let x = move *ptr::offset(p, i);
             f(i, x);
         }
     }
@@ -512,9 +482,7 @@ pub fn pop<T>(v: &mut ~[T]) -> T {
     }
     let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
     unsafe {
-        // XXX: Should be rusti::uninit() - we don't need this zeroed
-        let mut val = rusti::init();
-        val <-> *valptr;
+        let val = move *valptr;
         raw::set_len(v, ln - 1u);
         val
     }
@@ -583,11 +551,9 @@ pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
     let mut rhs = rhs; // FIXME(#3488)
     reserve(v, v.len() + rhs.len());
     unsafe {
-        do as_mut_buf(rhs) |p, len| {
+        do as_imm_buf(rhs) |p, len| {
             for uint::range(0, len) |i| {
-                // XXX Should be rusti::uninit() - don't need to zero
-                let mut x = rusti::init();
-                x <-> *ptr::mut_offset(p, i);
+                let x = move *ptr::offset(p, i);
                 push(v, x);
             }
         }
@@ -597,14 +563,12 @@ pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
 
 /// Shorten a vector, dropping excess elements.
 pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
-    do as_mut_buf(*v) |p, oldlen| {
+    do as_imm_buf(*v) |p, oldlen| {
         assert(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
-                // XXX Should be rusti::uninit() - don't need to zero
-                let mut dropped = rusti::init();
-                dropped <-> *ptr::mut_offset(p, i);
+                let _dropped = move *ptr::offset(p, i);
             }
             raw::set_len(v, newlen);
         }
@@ -627,14 +591,12 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
             // last_written < next_to_read < ln
             if *ptr::mut_offset(p, next_to_read) ==
                 *ptr::mut_offset(p, last_written) {
-                // XXX Should be rusti::uninit() - don't need to zero
-                let mut dropped = rusti::init();
-                dropped <-> *ptr::mut_offset(p, next_to_read);
+                let _dropped = move *ptr::mut_offset(p, next_to_read);
             } else {
                 last_written += 1;
                 // last_written <= next_to_read < ln
                 if next_to_read != last_written {
-                    *ptr::mut_offset(p, last_written) <->
+                    *ptr::mut_offset(p, last_written) = move
                         *ptr::mut_offset(p, next_to_read);
                 }
             }
@@ -1798,7 +1760,7 @@ pub struct UnboxedVecRepr {
 }
 
 /// Unsafe operations
-pub mod raw {
+mod raw {
 
     /// The internal representation of a (boxed) vector
     pub struct VecRepr {