---

yaml
---
r: 30003
b: refs/heads/incoming
c: 20773f3
h: refs/heads/master
i:
  30001: 8cbe821
  29999: 5766600
v: v3

Author: bblum

[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: d8988fe220865034f50b936dc5e219a1b6347314
+refs/heads/incoming: 20773f33f522ac7686e0ac7271332646e9944938
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/vec.rs

@@ -510,7 +510,9 @@ fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +T)) unsafe {
 /// Remove the last element from a vector and return it
 fn pop<T>(&v: ~[const T]) -> T {
     let ln = len(v);
-    assert ln > 0u;
+    if ln == 0 {
+        fail ~"sorry, cannot vec::pop an empty vector"
+    }
     let valptr = ptr::mut_addr_of(v[ln - 1u]);
     unsafe {
         let val <- *valptr;
@@ -519,6 +521,29 @@ fn pop<T>(&v: ~[const T]) -> T {
     }
 }
 
+/**
+ * Remove an element from anywhere in the vector and return it, replacing it
+ * with the last element. This does not preserve ordering, but is O(1).
+ *
+ * Fails if index >= length.
+ */
+fn swap_remove<T>(&v: ~[const T], index: uint) -> T {
+    let ln = len(v);
+    if index >= ln {
+        fail #fmt("vec::swap_remove - index %u >= length %u", index, ln);
+    }
+    let lastptr = ptr::mut_addr_of(v[ln - 1]);
+    unsafe {
+        let mut val <- *lastptr;
+        if index < ln - 1 {
+            let valptr = ptr::mut_addr_of(v[index]);
+            *valptr <-> val;
+        }
+        unsafe::set_len(v, ln - 1);
+        val
+    }
+}
+
 /// Append an element to a vector
 #[inline(always)]
 fn push<T>(&v: ~[const T], +initval: T) {
@@ -1935,6 +1960,34 @@ mod tests {
         assert (e == 5);
     }
 
+    #[test]
+    fn test_swap_remove() {
+        let mut v = ~[1, 2, 3, 4, 5];
+        let mut e = swap_remove(v, 0);
+        assert (len(v) == 4);
+        assert e == 1;
+        assert (v[0] == 5);
+        e = swap_remove(v, 3);
+        assert (len(v) == 3);
+        assert e == 4;
+        assert (v[0] == 5);
+        assert (v[1] == 2);
+        assert (v[2] == 3);
+    }
+
+    #[test]
+    fn test_swap_remove_noncopyable() {
+        // Tests that we don't accidentally run destructors twice.
+        let mut v = ~[::unsafe::exclusive(()), ::unsafe::exclusive(()),
+                      ::unsafe::exclusive(())];
+        let mut _e = swap_remove(v, 0);
+        assert (len(v) == 2);
+        _e = swap_remove(v, 1);
+        assert (len(v) == 1);
+        _e = swap_remove(v, 0);
+        assert (len(v) == 0);
+    }
+
     #[test]
     fn test_push() {
         // Test on-stack push().

branches/incoming/src/libstd/ebml.rs

@@ -284,8 +284,14 @@ impl writer {
         self.wr_tagged_bytes(tag_id, &[v as u8]);
     }
 
-    fn wr_tagged_str(tag_id: uint, v: &str) {
-        str::byte_slice(v, |b| self.wr_tagged_bytes(tag_id, b));
+    fn wr_tagged_str(tag_id: uint, v: ~str) {
+        // Lame: can't use str::as_bytes() here because the resulting
+        // vector is NULL-terminated.  Annoyingly, the underlying
+        // writer interface doesn't permit us to write a slice of a
+        // vector.  We need first-class slices, I think.
+
+        // str::as_bytes(v) {|b| self.wr_tagged_bytes(tag_id, b); }
+        self.wr_tagged_bytes(tag_id, str::bytes(v));
     }
 
     fn wr_bytes(b: &[u8]) {
@@ -363,7 +369,7 @@ impl ebml::writer: serialization::serializer {
     fn emit_f32(_v: f32) { fail ~"Unimplemented: serializing an f32"; }
     fn emit_float(_v: float) { fail ~"Unimplemented: serializing a float"; }
 
-    fn emit_str(v: &str) { self.wr_tagged_str(es_str as uint, v) }
+    fn emit_str(v: ~str) { self.wr_tagged_str(es_str as uint, v) }
 
     fn emit_enum(name: ~str, f: fn()) {
         self._emit_label(name);
@@ -445,7 +451,7 @@ priv impl ebml_deserializer {
         return r_doc;
     }
 
-    fn push_doc<T>(d: ebml::doc, f: fn() -> T) -> T{
+    fn push_doc<T: copy>(d: ebml::doc, f: fn() -> T) -> T{
         let old_parent = self.parent;
         let old_pos = self.pos;
         self.parent = d;
@@ -499,13 +505,13 @@ impl ebml_deserializer: serialization::deserializer {
     fn read_str() -> ~str { ebml::doc_as_str(self.next_doc(es_str)) }
 
     // Compound types:
-    fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
+    fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T {
         debug!{"read_enum(%s)", name};
         self._check_label(name);
         self.push_doc(self.next_doc(es_enum), f)
     }
 
-    fn read_enum_variant<T>(f: fn(uint) -> T) -> T {
+    fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T {
         debug!{"read_enum_variant()"};
         let idx = self._next_uint(es_enum_vid);
         debug!{"  idx=%u", idx};
@@ -514,12 +520,12 @@ impl ebml_deserializer: serialization::deserializer {
         }
     }
 
-    fn read_enum_variant_arg<T>(idx: uint, f: fn() -> T) -> T {
+    fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T {
         debug!{"read_enum_variant_arg(idx=%u)", idx};
         f()
     }
 
-    fn read_vec<T>(f: fn(uint) -> T) -> T {
+    fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         debug!{"read_vec()"};
         do self.push_doc(self.next_doc(es_vec)) {
             let len = self._next_uint(es_vec_len);
@@ -528,38 +534,38 @@ impl ebml_deserializer: serialization::deserializer {
         }
     }
 
-    fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T {
+    fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
         debug!{"read_vec_elt(idx=%u)", idx};
         self.push_doc(self.next_doc(es_vec_elt), f)
     }
 
-    fn read_box<T>(f: fn() -> T) -> T {
+    fn read_box<T:copy>(f: fn() -> T) -> T {
         debug!{"read_box()"};
         f()
     }
 
-    fn read_uniq<T>(f: fn() -> T) -> T {
+    fn read_uniq<T:copy>(f: fn() -> T) -> T {
         debug!{"read_uniq()"};
         f()
     }
 
-    fn read_rec<T>(f: fn() -> T) -> T {
+    fn read_rec<T:copy>(f: fn() -> T) -> T {
         debug!{"read_rec()"};
         f()
     }
 
-    fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
+    fn read_rec_field<T:copy>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
         debug!{"read_rec_field(%s, idx=%u)", f_name, f_idx};
         self._check_label(f_name);
         f()
     }
 
-    fn read_tup<T>(sz: uint, f: fn() -> T) -> T {
+    fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T {
         debug!{"read_tup(sz=%u)", sz};
         f()
     }
 
-    fn read_tup_elt<T>(idx: uint, f: fn() -> T) -> T {
+    fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
         debug!{"read_tup_elt(idx=%u)", idx};
         f()
     }

branches/incoming/src/libstd/prettyprint.rs

@@ -63,7 +63,7 @@ impl Writer: serializer {
         self.write_str(fmt!{"%?_f32", v});
     }
 
-    fn emit_str(v: &str) {
+    fn emit_str(v: ~str) {
         self.write_str(fmt!{"%?", v});
     }
 
@@ -127,4 +127,4 @@ impl Writer: serializer {
         if idx > 0u { self.write_str(~", "); }
         f();
     }
-}
+}

branches/incoming/src/libstd/serialization.rs

@@ -23,7 +23,7 @@ trait serializer {
     fn emit_float(v: float);
     fn emit_f64(v: f64);
     fn emit_f32(v: f32);
-    fn emit_str(v: &str);
+    fn emit_str(v: ~str);
 
     // Compound types:
     fn emit_enum(name: ~str, f: fn());
@@ -65,17 +65,17 @@ trait deserializer {
     fn read_float() -> float;
 
     // Compound types:
-    fn read_enum<T>(name: ~str, f: fn() -> T) -> T;
-    fn read_enum_variant<T>(f: fn(uint) -> T) -> T;
-    fn read_enum_variant_arg<T>(idx: uint, f: fn() -> T) -> T;
-    fn read_vec<T>(f: fn(uint) -> T) -> T;
-    fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T;
-    fn read_box<T>(f: fn() -> T) -> T;
-    fn read_uniq<T>(f: fn() -> T) -> T;
-    fn read_rec<T>(f: fn() -> T) -> T;
-    fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T;
-    fn read_tup<T>(sz: uint, f: fn() -> T) -> T;
-    fn read_tup_elt<T>(idx: uint, f: fn() -> T) -> T;
+    fn read_enum<T:copy>(name: ~str, f: fn() -> T) -> T;
+    fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_vec<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_box<T:copy>(f: fn() -> T) -> T;
+    fn read_uniq<T:copy>(f: fn() -> T) -> T;
+    fn read_rec<T:copy>(f: fn() -> T) -> T;
+    fn read_rec_field<T:copy>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T;
+    fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T;
+    fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
 }
 
 // ___________________________________________________________________________
@@ -201,7 +201,7 @@ fn deserialize_i64<D: deserializer>(d: D) -> i64 {
     d.read_i64()
 }
 
-fn serialize_str<S: serializer>(s: S, v: &str) {
+fn serialize_str<S: serializer>(s: S, v: ~str) {
     s.emit_str(v);
 }
 

branches/incoming/src/rustc/driver/driver.rs

@@ -583,9 +583,8 @@ fn parse_pretty(sess: session, &&name: ~str) -> pp_mode {
       ~"expanded,identified" => ppm_expanded_identified,
       ~"identified" => ppm_identified,
       _ => {
-        sess.fatal(~"argument to `pretty` must be one of `normal`, \
-                     `expanded`, `typed`, `identified`, \
-                     or `expanded,identified`");
+        sess.fatal(~"argument to `pretty` must be one of `normal`, `typed`, \
+                     or `identified`");
       }
     }
 }