---

yaml
---
r: 73621
b: refs/heads/dist-snap
c: e694e5f
h: refs/heads/master
i:
  73619: 695d33d
v: v3

Author: alexcrichton

[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: 91a707390045eb29e5392de1f7f5b9d5fdb64e65
+refs/heads/dist-snap: e694e5fc592491097470e996fb41bd25104252fc
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/kate/rust.xml

@@ -49,7 +49,6 @@
 		<item> Copy </item>
 		<item> Send </item>
 		<item> Owned </item>
-		<item> Sized </item>
 		<item> Eq </item>
 		<item> Ord </item>
 		<item> Num </item>

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -44,7 +44,7 @@ syn keyword   rustType        size_t ptrdiff_t clock_t time_t
 syn keyword   rustType        c_longlong c_ulonglong intptr_t uintptr_t
 syn keyword   rustType        off_t dev_t ino_t pid_t mode_t ssize_t
 
-syn keyword   rustTrait       Const Copy Send Owned Sized " inherent traits
+syn keyword   rustTrait       Const Copy Send Owned " inherent traits
 syn keyword   rustTrait       Eq Ord Num Ptr
 syn keyword   rustTrait       Drop Add Sub Mul Quot Rem Neg BitAnd BitOr
 syn keyword   rustTrait       BitXor Shl Shr Index

branches/dist-snap/src/etc/zsh/_rust

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -13,6 +13,7 @@ use core::prelude::*;
 use core::cmp;
 use core::ops;
 use core::uint;
+use core::vec::from_elem;
 use core::vec;
 
 struct SmallBitv {

branches/dist-snap/src/libextra/bitv.rs

@@ -51,34 +51,32 @@ pub enum EbmlEncoderTag {
     EsI16,      // 8
     EsI8,       // 9
     EsBool,     // 10
-    EsChar,     // 11
-    EsStr,      // 12
-    EsF64,      // 13
-    EsF32,      // 14
-    EsFloat,    // 15
-    EsEnum,     // 16
-    EsEnumVid,  // 17
-    EsEnumBody, // 18
-    EsVec,      // 19
-    EsVecLen,   // 20
-    EsVecElt,   // 21
-    EsMap,      // 22
-    EsMapLen,   // 23
-    EsMapKey,   // 24
-    EsMapVal,   // 25
+    EsStr,      // 11
+    EsF64,      // 12
+    EsF32,      // 13
+    EsFloat,    // 14
+    EsEnum,     // 15
+    EsEnumVid,  // 16
+    EsEnumBody, // 17
+    EsVec,      // 18
+    EsVecLen,   // 19
+    EsVecElt,   // 20
 
     EsOpaque,
 
-    EsLabel, // Used only when debugging
+    EsLabel // Used only when debugging
 }
 // --------------------------------------
 
 pub mod reader {
-    use super::*;
+    use core::prelude::*;
 
+    use ebml::{Doc, EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen, TaggedDoc};
     use serialize;
 
-    use core::prelude::*;
     use core::cast::transmute;
     use core::int;
     use core::io;
@@ -323,14 +321,12 @@ pub mod reader {
             r_doc
         }
 
-        fn push_doc<T>(&mut self, exp_tag: EbmlEncoderTag,
-                       f: &fn(&mut Decoder) -> T) -> T {
-            let d = self.next_doc(exp_tag);
+        fn push_doc<T>(&mut self, d: Doc, f: &fn() -> T) -> T {
             let old_parent = self.parent;
             let old_pos = self.pos;
             self.parent = d;
             self.pos = d.start;
-            let r = f(self);
+            let r = f();
             self.parent = old_parent;
             self.pos = old_pos;
             r
@@ -399,21 +395,10 @@ pub mod reader {
             doc_as_u8(self.next_doc(EsBool)) as bool
         }
 
-        fn read_f64(&mut self) -> f64 {
-            let bits = doc_as_u64(self.next_doc(EsF64));
-            unsafe { transmute(bits) }
-        }
-        fn read_f32(&mut self) -> f32 {
-            let bits = doc_as_u32(self.next_doc(EsF32));
-            unsafe { transmute(bits) }
-        }
-        fn read_float(&mut self) -> float {
-            let bits = doc_as_u64(self.next_doc(EsFloat));
-            (unsafe { transmute::<u64, f64>(bits) }) as float
-        }
-        fn read_char(&mut self) -> char {
-            doc_as_u32(self.next_doc(EsChar)) as char
-        }
+        fn read_f64(&mut self) -> f64 { fail!("read_f64()"); }
+        fn read_f32(&mut self) -> f32 { fail!("read_f32()"); }
+        fn read_float(&mut self) -> float { fail!("read_float()"); }
+        fn read_char(&mut self) -> char { fail!("read_char()"); }
         fn read_str(&mut self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
 
         // Compound types:
@@ -556,50 +541,66 @@ pub mod reader {
 
         fn read_seq<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
             debug!("read_seq()");
-            do self.push_doc(EsVec) |d| {
-                let len = d._next_uint(EsVecLen);
-                debug!("  len=%u", len);
-                f(d, len)
-            }
+            let doc = self.next_doc(EsVec);
+
+            let (old_parent, old_pos) = (self.parent, self.pos);
+            self.parent = doc;
+            self.pos = self.parent.start;
+
+            let len = self._next_uint(EsVecLen);
+            debug!("  len=%u", len);
+            let result = f(self, len);
+
+            self.parent = old_parent;
+            self.pos = old_pos;
+            result
         }
 
         fn read_seq_elt<T>(&mut self, idx: uint, f: &fn(&mut Decoder) -> T)
                            -> T {
             debug!("read_seq_elt(idx=%u)", idx);
-            self.push_doc(EsVecElt, f)
+            let doc = self.next_doc(EsVecElt);
+
+            let (old_parent, old_pos) = (self.parent, self.pos);
+            self.parent = doc;
+            self.pos = self.parent.start;
+
+            let result = f(self);
+
+            self.parent = old_parent;
+            self.pos = old_pos;
+            result
         }
 
-        fn read_map<T>(&mut self, f: &fn(&mut Decoder, uint) -> T) -> T {
+        fn read_map<T>(&mut self, _: &fn(&mut Decoder, uint) -> T) -> T {
             debug!("read_map()");
-            do self.push_doc(EsMap) |d| {
-                let len = d._next_uint(EsMapLen);
-                debug!("  len=%u", len);
-                f(d, len)
-            }
+            fail!("read_map is unimplemented");
         }
 
         fn read_map_elt_key<T>(&mut self,
                                idx: uint,
-                               f: &fn(&mut Decoder) -> T)
+                               _: &fn(&mut Decoder) -> T)
                                -> T {
             debug!("read_map_elt_key(idx=%u)", idx);
-            self.push_doc(EsMapKey, f)
+            fail!("read_map_elt_val is unimplemented");
         }
 
         fn read_map_elt_val<T>(&mut self,
                                idx: uint,
-                               f: &fn(&mut Decoder) -> T)
+                               _: &fn(&mut Decoder) -> T)
                                -> T {
             debug!("read_map_elt_val(idx=%u)", idx);
-            self.push_doc(EsMapVal, f)
+            fail!("read_map_elt_val is unimplemented");
         }
     }
 }
 
 pub mod writer {
-    use super::*;
+    use ebml::{EbmlEncoderTag, EsBool, EsEnum, EsEnumBody, EsEnumVid};
+    use ebml::{EsI16, EsI32, EsI64, EsI8, EsInt};
+    use ebml::{EsLabel, EsOpaque, EsStr, EsU16, EsU32, EsU64, EsU8, EsUint};
+    use ebml::{EsVec, EsVecElt, EsVecLen};
 
-    use core::cast;
     use core::io;
     use core::str;
 
@@ -805,21 +806,19 @@ pub mod writer {
             self.wr_tagged_u8(EsBool as uint, v as u8)
         }
 
-        fn emit_f64(&mut self, v: f64) {
-            let bits = unsafe { cast::transmute(v) };
-            self.wr_tagged_u64(EsF64 as uint, bits);
+        // FIXME (#2742): implement these
+        fn emit_f64(&mut self, _v: f64) {
+            fail!("Unimplemented: serializing an f64");
         }
-        fn emit_f32(&mut self, v: f32) {
-            let bits = unsafe { cast::transmute(v) };
-            self.wr_tagged_u32(EsF32 as uint, bits);
+        fn emit_f32(&mut self, _v: f32) {
+            fail!("Unimplemented: serializing an f32");
         }
-        fn emit_float(&mut self, v: float) {
-            let bits = unsafe { cast::transmute(v as f64) };
-            self.wr_tagged_u64(EsFloat as uint, bits);
+        fn emit_float(&mut self, _v: float) {
+            fail!("Unimplemented: serializing a float");
         }
 
-        fn emit_char(&mut self, v: char) {
-            self.wr_tagged_u32(EsChar as uint, v as u32);
+        fn emit_char(&mut self, _v: char) {
+            fail!("Unimplemented: serializing a char");
         }
 
         fn emit_str(&mut self, v: &str) {
@@ -915,23 +914,16 @@ pub mod writer {
             self.end_tag();
         }
 
-        fn emit_map(&mut self, len: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMap as uint);
-            self._emit_tagged_uint(EsMapLen, len);
-            f(self);
-            self.end_tag();
+        fn emit_map(&mut self, _len: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map is unimplemented");
         }
 
-        fn emit_map_elt_key(&mut self, _idx: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMapKey as uint);
-            f(self);
-            self.end_tag();
+        fn emit_map_elt_key(&mut self, _idx: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map_elt_key is unimplemented");
         }
 
-        fn emit_map_elt_val(&mut self, _idx: uint, f: &fn(&mut Encoder)) {
-            self.start_tag(EsMapVal as uint);
-            f(self);
-            self.end_tag();
+        fn emit_map_elt_val(&mut self, _idx: uint, _f: &fn(&mut Encoder)) {
+            fail!("emit_map_elt_val is unimplemented");
         }
     }
 }