---

yaml
---
r: 113260
b: refs/heads/snap-stage3
c: e454851
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: abdacecdf86b4b5a4f432560445a24e1c5f4751b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6aefce6f16d4ecddbc225c23a5ebeb481c19ea2c
+refs/heads/snap-stage3: e45485181338137136ea2816d78ed108440f7d50
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/rust.md

@@ -208,7 +208,7 @@ The keywords are the following strings:
 
 ~~~~ {.notrust .keyword}
 as
-break
+box break
 crate
 else enum extern
 false fn for

branches/snap-stage3/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -38,6 +38,7 @@
 		<keyword>as</keyword>
 		<keyword>assert</keyword>
 		<keyword>break</keyword>
+		<keyword>box</keyword>
 		<keyword>const</keyword>
 		<keyword>continue</keyword>
 		<keyword>crate</keyword>

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

@@ -18,6 +18,7 @@
 	<list name="keywords">
 		<item> as </item>
 		<item> break </item>
+		<item> box </item>
 		<item> continue </item>
 		<item> crate </item>
 		<item> do </item>

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

@@ -18,7 +18,7 @@ syn keyword   rustOperator    as
 
 syn match     rustAssert      "\<assert\(\w\)*!" contained
 syn match     rustFail        "\<fail\(\w\)*!" contained
-syn keyword   rustKeyword     break continue
+syn keyword   rustKeyword     break box continue
 syn keyword   rustKeyword     extern nextgroup=rustExternCrate,rustObsoleteExternMod skipwhite
 syn keyword   rustKeyword     for in if impl let
 syn keyword   rustKeyword     loop once priv pub

branches/snap-stage3/src/libcollections/hashmap.rs

@@ -1617,8 +1617,7 @@ mod test_map {
     use std::cmp::Equiv;
     use std::hash::Hash;
     use std::iter::{Iterator,range_inclusive,range_step_inclusive};
-    use std::local_data;
-    use std::vec;
+    use std::cell::RefCell;
 
     struct KindaIntLike(int);
 
@@ -1657,7 +1656,7 @@ mod test_map {
         assert_eq!(*m.find(&2).unwrap(), 4);
     }
 
-    local_data_key!(drop_vector: vec::Vec<int>)
+    local_data_key!(drop_vector: RefCell<Vec<int>>)
 
     #[deriving(Hash, Eq, TotalEq)]
     struct Dropable {
@@ -1667,75 +1666,72 @@ mod test_map {
 
     impl Dropable {
         fn new(k: uint) -> Dropable {
-            local_data::get_mut(drop_vector,
-                |v| { v.unwrap().as_mut_slice()[k] += 1; });
+            let v = drop_vector.get().unwrap();
+            v.borrow_mut().as_mut_slice()[k] += 1;
 
             Dropable { k: k }
         }
     }
 
     impl Drop for Dropable {
         fn drop(&mut self) {
-            local_data::get_mut(drop_vector, |v|
-                { v.unwrap().as_mut_slice()[self.k] -= 1; });
+            let v = drop_vector.get().unwrap();
+            v.borrow_mut().as_mut_slice()[self.k] -= 1;
         }
     }
 
     #[test]
     fn test_drops() {
-        local_data::set(drop_vector, vec::Vec::from_elem(200, 0));
+        drop_vector.replace(Some(RefCell::new(Vec::from_elem(200, 0))));
 
         {
             let mut m = HashMap::new();
 
-            local_data::get(drop_vector, |v| {
-                for i in range(0u, 200) {
-                    assert_eq!(v.unwrap().as_slice()[i], 0);
-                }
-            });
+            let v = drop_vector.get().unwrap();
+            for i in range(0u, 200) {
+                assert_eq!(v.borrow().as_slice()[i], 0);
+            }
+            drop(v);
 
             for i in range(0u, 100) {
                 let d1 = Dropable::new(i);
                 let d2 = Dropable::new(i+100);
                 m.insert(d1, d2);
             }
 
-            local_data::get(drop_vector, |v| {
-                for i in range(0u, 200) {
-                    assert_eq!(v.unwrap().as_slice()[i], 1);
-                }
-            });
+            let v = drop_vector.get().unwrap();
+            for i in range(0u, 200) {
+                assert_eq!(v.borrow().as_slice()[i], 1);
+            }
+            drop(v);
 
             for i in range(0u, 50) {
                 let k = Dropable::new(i);
                 let v = m.pop(&k);
 
                 assert!(v.is_some());
 
-                local_data::get(drop_vector, |v| {
-                    assert_eq!(v.unwrap().as_slice()[i], 1);
-                    assert_eq!(v.unwrap().as_slice()[i+100], 1);
-                });
+                let v = drop_vector.get().unwrap();
+                assert_eq!(v.borrow().as_slice()[i], 1);
+                assert_eq!(v.borrow().as_slice()[i+100], 1);
             }
 
-            local_data::get(drop_vector, |v| {
-                for i in range(0u, 50) {
-                    assert_eq!(v.unwrap().as_slice()[i], 0);
-                    assert_eq!(v.unwrap().as_slice()[i+100], 0);
-                }
+            let v = drop_vector.get().unwrap();
+            for i in range(0u, 50) {
+                assert_eq!(v.borrow().as_slice()[i], 0);
+                assert_eq!(v.borrow().as_slice()[i+100], 0);
+            }
 
-                for i in range(50u, 100) {
-                    assert_eq!(v.unwrap().as_slice()[i], 1);
-                    assert_eq!(v.unwrap().as_slice()[i+100], 1);
-                }
-            });
+            for i in range(50u, 100) {
+                assert_eq!(v.borrow().as_slice()[i], 1);
+                assert_eq!(v.borrow().as_slice()[i+100], 1);
+            }
         }
 
-        local_data::get(drop_vector, |v| {
-            for i in range(0u, 200) {
-                assert_eq!(v.unwrap().as_slice()[i], 0);
-            }
-        });
+        let v = drop_vector.get().unwrap();
+        for i in range(0u, 200) {
+            assert_eq!(v.borrow().as_slice()[i], 0);
+        }
     }
 
     #[test]

branches/snap-stage3/src/libgraphviz/lib.rs

@@ -54,11 +54,9 @@ type Nd = int;
 type Ed = (int,int);
 struct Edges(Vec<Ed>);
 
-pub fn main() {
-    use std::io::File;
+pub fn render_to<W:Writer>(output: &mut W) {
     let edges = Edges(vec!((0,1), (0,2), (1,3), (2,3), (3,4), (4,4)));
-    let mut f = File::create(&Path::new("example1.dot"));
-    dot::render(&edges, &mut f).unwrap()
+    dot::render(&edges, output).unwrap()
 }
 
 impl<'a> dot::Labeller<'a, Nd, Ed> for Edges {
@@ -91,6 +89,17 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed> for Edges {
 
     fn target(&self, e: &Ed) -> Nd { let &(_,t) = e; t }
 }
+
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+```
+
+```no_run
+# pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
+pub fn main() {
+    use std::io::File;
+    let mut f = File::create(&Path::new("example1.dot"));
+    render_to(&mut f)
+}
 ```
 
 Output from first example (in `example1.dot`):
@@ -140,19 +149,17 @@ entity `&sube`).
 ```rust
 use dot = graphviz;
 use std::str;
-use std::io::File;
 
 type Nd = uint;
 type Ed<'a> = &'a (uint, uint);
 struct Graph { nodes: Vec<&'static str>, edges: Vec<(uint,uint)> }
 
-pub fn main() {
+pub fn render_to<W:Writer>(output: &mut W) {
     let nodes = vec!("{x,y}","{x}","{y}","{}");
     let edges = vec!((0,1), (0,2), (1,3), (2,3));
     let graph = Graph { nodes: nodes, edges: edges };
 
-    let mut f = File::create(&Path::new("example2.dot"));
-    dot::render(&graph, &mut f).unwrap()
+    dot::render(&graph, output).unwrap()
 }
 
 impl<'a> dot::Labeller<'a, Nd, Ed<'a>> for Graph {
@@ -174,6 +181,17 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed<'a>> for Graph {
     fn source(&self, e: &Ed) -> Nd { let & &(s,_) = e; s }
     fn target(&self, e: &Ed) -> Nd { let & &(_,t) = e; t }
 }
+
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+```
+
+```no_run
+# pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
+pub fn main() {
+    use std::io::File;
+    let mut f = File::create(&Path::new("example2.dot"));
+    render_to(&mut f)
+}
 ```
 
 The third example is similar to the second, except now each node and
@@ -187,19 +205,17 @@ Hasse-diagram for the subsets of the set `{x, y}`.
 ```rust
 use dot = graphviz;
 use std::str;
-use std::io::File;
 
 type Nd<'a> = (uint, &'a str);
 type Ed<'a> = (Nd<'a>, Nd<'a>);
 struct Graph { nodes: Vec<&'static str>, edges: Vec<(uint,uint)> }
 
-pub fn main() {
+pub fn render_to<W:Writer>(output: &mut W) {
     let nodes = vec!("{x,y}","{x}","{y}","{}");
     let edges = vec!((0,1), (0,2), (1,3), (2,3));
     let graph = Graph { nodes: nodes, edges: edges };
 
-    let mut f = File::create(&Path::new("example3.dot"));
-    dot::render(&graph, &mut f).unwrap()
+    dot::render(&graph, output).unwrap()
 }
 
 impl<'a> dot::Labeller<'a, Nd<'a>, Ed<'a>> for Graph {
@@ -229,6 +245,17 @@ impl<'a> dot::GraphWalk<'a, Nd<'a>, Ed<'a>> for Graph {
     fn source(&self, e: &Ed<'a>) -> Nd<'a> { let &(s,_) = e; s }
     fn target(&self, e: &Ed<'a>) -> Nd<'a> { let &(_,t) = e; t }
 }
+
+# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+```
+
+```no_run
+# pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
+pub fn main() {
+    use std::io::File;
+    let mut f = File::create(&Path::new("example3.dot"));
+    render_to(&mut f)
+}
 ```
 
 # References

branches/snap-stage3/src/liblog/lib.rs

@@ -122,7 +122,6 @@ use std::cast;
 use std::fmt;
 use std::io::LineBufferedWriter;
 use std::io;
-use std::local_data;
 use std::os;
 use std::rt;
 use std::slice;
@@ -228,7 +227,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
     // Completely remove the local logger from TLS in case anyone attempts to
     // frob the slot while we're doing the logging. This will destroy any logger
     // set during logging.
-    let mut logger = local_data::pop(local_logger).unwrap_or_else(|| {
+    let mut logger = local_logger.replace(None).unwrap_or_else(|| {
         box DefaultLogger { handle: io::stderr() } as Box<Logger:Send>
     });
     logger.log(&LogRecord {
@@ -238,7 +237,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: &fmt::Arguments) {
         module_path: loc.module_path,
         line: loc.line,
     });
-    local_data::set(local_logger, logger);
+    local_logger.replace(Some(logger));
 }
 
 /// Getter for the global log level. This is a function so that it can be called
@@ -250,9 +249,7 @@ pub fn log_level() -> u32 { unsafe { LOG_LEVEL } }
 /// Replaces the task-local logger with the specified logger, returning the old
 /// logger.
 pub fn set_logger(logger: Box<Logger:Send>) -> Option<Box<Logger:Send>> {
-    let prev = local_data::pop(local_logger);
-    local_data::set(local_logger, logger);
-    return prev;
+    local_logger.replace(Some(logger))
 }
 
 /// A LogRecord is created by the logging macros, and passed as the only

branches/snap-stage3/src/libnative/io/c_unix.rs

@@ -27,6 +27,13 @@ pub static FIOCLEX: libc::c_ulong = 0x20006601;
 #[cfg(target_os = "android")]
 pub static FIOCLEX: libc::c_ulong = 0x5451;
 
+#[cfg(target_os = "macos")]
+#[cfg(target_os = "freebsd")]
+pub static MSG_DONTWAIT: libc::c_int = 0x80;
+#[cfg(target_os = "linux")]
+#[cfg(target_os = "android")]
+pub static MSG_DONTWAIT: libc::c_int = 0x40;
+
 extern {
     pub fn gettimeofday(timeval: *mut libc::timeval,
                         tzp: *libc::c_void) -> libc::c_int;

branches/snap-stage3/src/libnative/io/c_win32.rs

@@ -18,6 +18,7 @@ pub static WSADESCRIPTION_LEN: uint = 256;
 pub static WSASYS_STATUS_LEN: uint = 128;
 pub static FIONBIO: libc::c_long = 0x8004667e;
 static FD_SETSIZE: uint = 64;
+pub static MSG_DONTWAIT: libc::c_int = 0;
 
 pub struct WSADATA {
     pub wVersion: libc::WORD,

branches/snap-stage3/src/libnative/io/file_unix.rs

@@ -189,6 +189,9 @@ impl rtio::RtioPipe for FileDesc {
     fn close_write(&mut self) -> Result<(), IoError> {
         Err(io::standard_error(io::InvalidInput))
     }
+    fn set_timeout(&mut self, _t: Option<u64>) {}
+    fn set_read_timeout(&mut self, _t: Option<u64>) {}
+    fn set_write_timeout(&mut self, _t: Option<u64>) {}
 }
 
 impl rtio::RtioTTY for FileDesc {

branches/snap-stage3/src/libnative/io/file_win32.rs

@@ -221,6 +221,9 @@ impl rtio::RtioPipe for FileDesc {
     fn close_write(&mut self) -> IoResult<()> {
         Err(io::standard_error(io::InvalidInput))
     }
+    fn set_timeout(&mut self, _t: Option<u64>) {}
+    fn set_read_timeout(&mut self, _t: Option<u64>) {}
+    fn set_write_timeout(&mut self, _t: Option<u64>) {}
 }
 
 impl rtio::RtioTTY for FileDesc {