---

yaml
---
r: 48462
b: refs/heads/snap-stage3
c: d6e583a
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: ce23c8c0cfc6aee3eae7d0287651ef7bcd9c6b9f
+refs/heads/snap-stage3: d6e583ab1038ffe2706e5ecdc96a3da207f87c16
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/io.rs

@@ -144,12 +144,6 @@ pub trait ReaderUtil {
     /// Read a big-endian i16 (2 bytes).
     fn read_be_i16(&self) -> i16;
 
-    /// Read a big-endian IEEE754 double-precision floating-point (8 bytes).
-    fn read_be_f64(&self) -> f64;
-
-    /// Read a big-endian IEEE754 single-precision floating-point (4 bytes).
-    fn read_be_f32(&self) -> f32;
-
     /// Read a little-endian u64 (8 bytes).
     fn read_le_u64(&self) -> u64;
 
@@ -168,14 +162,6 @@ pub trait ReaderUtil {
     /// Read a litle-endian i16 (2 bytes).
     fn read_le_i16(&self) -> i16;
 
-    /// Read a litten-endian IEEE754 double-precision floating-point
-    /// (8 bytes).
-    fn read_le_f64(&self) -> f64;
-
-    /// Read a litten-endian IEEE754 single-precision floating-point
-    /// (4 bytes).
-    fn read_le_f32(&self) -> f32;
-
     /// Read a u8 (1 byte).
     fn read_u8(&self) -> u8;
 
@@ -382,18 +368,6 @@ impl<T:Reader> ReaderUtil for T {
         self.read_be_int_n(2) as i16
     }
 
-    fn read_be_f64(&self) -> f64 {
-        unsafe {
-            cast::transmute::<u64, f64>(self.read_be_u64())
-        }
-    }
-
-    fn read_be_f32(&self) -> f32 {
-        unsafe {
-            cast::transmute::<u32, f32>(self.read_be_u32())
-        }
-    }
-
     fn read_le_u64(&self) -> u64 {
         self.read_le_uint_n(8) as u64
     }
@@ -418,18 +392,6 @@ impl<T:Reader> ReaderUtil for T {
         self.read_le_int_n(2) as i16
     }
 
-    fn read_le_f64(&self) -> f64 {
-        unsafe {
-            cast::transmute::<u64, f64>(self.read_le_u64())
-        }
-    }
-
-    fn read_le_f32(&self) -> f32 {
-        unsafe {
-            cast::transmute::<u32, f32>(self.read_le_u32())
-        }
-    }
-
     fn read_u8(&self) -> u8 {
         self.read_byte() as u8
     }
@@ -912,12 +874,6 @@ pub trait WriterUtil {
     /// Write a big-endian i16 (2 bytes).
     fn write_be_i16(&self, n: i16);
 
-    /// Write a big-endian IEEE754 double-precision floating-point (8 bytes).
-    fn write_be_f64(&self, f: f64);
-
-    /// Write a big-endian IEEE754 single-precision floating-point (4 bytes).
-    fn write_be_f32(&self, f: f32);
-
     /// Write a little-endian u64 (8 bytes).
     fn write_le_u64(&self, n: u64);
 
@@ -936,14 +892,6 @@ pub trait WriterUtil {
     /// Write a little-endian i16 (2 bytes).
     fn write_le_i16(&self, n: i16);
 
-    /// Write a little-endian IEEE754 double-precision floating-point
-    /// (8 bytes).
-    fn write_le_f64(&self, f: f64);
-
-    /// Write a litten-endian IEEE754 single-precision floating-point
-    /// (4 bytes).
-    fn write_le_f32(&self, f: f32);
-
     /// Write a u8 (1 byte).
     fn write_u8(&self, n: u8);
 
@@ -1000,16 +948,6 @@ impl<T:Writer> WriterUtil for T {
     fn write_be_i16(&self, n: i16) {
         u64_to_be_bytes(n as u64, 2u, |v| self.write(v))
     }
-    fn write_be_f64(&self, f:f64) {
-        unsafe {
-            self.write_be_u64(cast::transmute(f))
-        }
-    }
-    fn write_be_f32(&self, f:f32) {
-        unsafe {
-            self.write_be_u32(cast::transmute(f))
-        }
-    }
     fn write_le_u64(&self, n: u64) {
         u64_to_le_bytes(n, 8u, |v| self.write(v))
     }
@@ -1028,20 +966,9 @@ impl<T:Writer> WriterUtil for T {
     fn write_le_i16(&self, n: i16) {
         u64_to_le_bytes(n as u64, 2u, |v| self.write(v))
     }
-    fn write_le_f64(&self, f:f64) {
-        unsafe {
-            self.write_le_u64(cast::transmute(f))
-        }
-    }
-    fn write_le_f32(&self, f:f32) {
-        unsafe {
-            self.write_le_u32(cast::transmute(f))
-        }
-    }
 
     fn write_u8(&self, n: u8) { self.write([n]) }
     fn write_i8(&self, n: i8) { self.write([n as u8]) }
-
 }
 
 #[allow(non_implicitly_copyable_typarams)]
@@ -1494,41 +1421,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_read_f32() {
-        let path = Path("tmp/lib-io-test-read-f32.tmp");
-        //big-endian floating-point 8.1250
-        let buf = ~[0x41, 0x02, 0x00, 0x00];
-
-        {
-            let file = io::file_writer(&path, [io::Create]).get();
-            file.write(buf);
-        }
-
-        {
-            let file = io::file_reader(&path).get();
-            let f = file.read_be_f32();
-            assert f == 8.1250;
-        }
-    }
-
-#[test]
-    fn test_read_write_f32() {
-        let path = Path("tmp/lib-io-test-read-write-f32.tmp");
-        let f:f32 = 8.1250;
-
-        {
-            let file = io::file_writer(&path, [io::Create]).get();
-            file.write_be_f32(f);
-            file.write_le_f32(f);
-        }
-
-        {
-            let file = io::file_reader(&path).get();
-            assert file.read_be_f32() == 8.1250;
-            assert file.read_le_f32() == 8.1250;
-        }
-    }
 }
 
 //

branches/snap-stage3/src/libcore/trie.rs

@@ -13,6 +13,7 @@
 use prelude::*;
 
 // FIXME: #3469: need to manually update TrieNode when SHIFT changes
+// FIXME: #5244: need to manually update the TrieNode constructor
 const SHIFT: uint = 4;
 const SIZE: uint = 1 << SHIFT;
 const MASK: uint = SIZE - 1;
@@ -56,7 +57,7 @@ impl<T> Container for TrieMap<T> {
     pure fn is_empty(&self) -> bool { self.len() == 0 }
 }
 
-impl<T: Copy> Mutable for TrieMap<T> {
+impl<T> Mutable for TrieMap<T> {
     /// Clear the map, removing all values.
     #[inline(always)]
     fn clear(&mut self) {
@@ -65,7 +66,7 @@ impl<T: Copy> Mutable for TrieMap<T> {
     }
 }
 
-impl<T: Copy> Map<uint, T> for TrieMap<T> {
+impl<T> Map<uint, T> for TrieMap<T> {
     /// Return true if the map contains a value for the specified key
     #[inline(always)]
     pure fn contains_key(&self, key: &uint) -> bool {
@@ -127,7 +128,7 @@ impl<T: Copy> Map<uint, T> for TrieMap<T> {
     }
 }
 
-impl<T: Copy> TrieMap<T> {
+impl<T> TrieMap<T> {
     #[inline(always)]
     static pure fn new() -> TrieMap<T> {
         TrieMap{root: TrieNode::new(), length: 0}
@@ -209,10 +210,15 @@ struct TrieNode<T> {
     children: [Child<T> * 16] // FIXME: #3469: can't use the SIZE constant yet
 }
 
-impl<T: Copy> TrieNode<T> {
+impl<T> TrieNode<T> {
     #[inline(always)]
     static pure fn new() -> TrieNode<T> {
-        TrieNode{count: 0, children: [Nothing, ..SIZE]}
+        // FIXME: #5244: [Nothing, ..SIZE] should be possible without Copy
+        TrieNode{count: 0,
+                 children: [Nothing, Nothing, Nothing, Nothing,
+                            Nothing, Nothing, Nothing, Nothing,
+                            Nothing, Nothing, Nothing, Nothing,
+                            Nothing, Nothing, Nothing, Nothing]}
     }
 }
 
@@ -260,12 +266,16 @@ pure fn chunk(n: uint, idx: uint) -> uint {
     (n >> (SHIFT * real_idx)) & MASK
 }
 
-fn insert<T: Copy>(count: &mut uint, child: &mut Child<T>, key: uint,
+fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
                    value: T, idx: uint) -> bool {
-    match *child {
+    let mut tmp = Nothing;
+    tmp <-> *child;
+    let mut added = false;
+
+    *child = match tmp {
       External(stored_key, stored_value) => {
           if stored_key == key {
-              false // already in the trie
+              External(stored_key, value)
           } else {
               // conflict - split the node
               let mut new = ~TrieNode::new();
@@ -274,20 +284,24 @@ fn insert<T: Copy>(count: &mut uint, child: &mut Child<T>, key: uint,
                      stored_key, stored_value, idx + 1);
               insert(&mut new.count, &mut new.children[chunk(key, idx)], key,
                      value, idx + 1);
-              *child = Internal(new);
-              true
+              added = true;
+              Internal(new)
           }
       }
-      Internal(ref mut x) => {
-        insert(&mut x.count, &mut x.children[chunk(key, idx)], key, value,
-               idx + 1)
+      Internal(x) => {
+        let mut x = x;
+        added = insert(&mut x.count, &mut x.children[chunk(key, idx)], key,
+                       value, idx + 1);
+        Internal(x)
+
       }
       Nothing => {
         *count += 1;
-        *child = External(key, value);
-        true
+        added = true;
+        External(key, value)
       }
-    }
+    };
+    added
 }
 
 fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,

branches/snap-stage3/src/libstd/workcache.rs

@@ -174,7 +174,7 @@ pub impl Database {
         let k = json_encode(&(fn_name, declared_inputs));
         match self.db_cache.find(&k) {
             None => None,
-            Some(&v) => Some(json_decode(copy v))
+            Some(v) => Some(json_decode(*v))
         }
     }