---

yaml
---
r: 80425
b: refs/heads/snap-stage3
c: 4c49a3d
h: refs/heads/master
i:
  80423: 7c63e6d
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3e1803f3af1adc1b2e5595650f6920f40bbedc2e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bb4d4d7eb9e7a3abe3dc2fd26ad62408d83ed036
+refs/heads/snap-stage3: 4c49a3d8cd00489e62ab7398d05285361039ef13
 refs/heads/try: 71bebebc37fbb229877da88dde13c2f35913bd77
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial-tasks.md

@@ -47,16 +47,14 @@ concurrency at this writing:
 
 * [`std::task`] - All code relating to tasks and task scheduling,
 * [`std::comm`] - The message passing interface,
-* [`std::pipes`] - The underlying messaging infrastructure,
-* [`extra::comm`] - Additional messaging types based on `std::pipes`,
+* [`extra::comm`] - Additional messaging types based on `std::comm`,
 * [`extra::sync`] - More exotic synchronization tools, including locks,
 * [`extra::arc`] - The Arc (atomically reference counted) type,
   for safely sharing immutable data,
 * [`extra::future`] - A type representing values that may be computed concurrently and retrieved at a later time.
 
 [`std::task`]: std/task.html
 [`std::comm`]: std/comm.html
-[`std::pipes`]: std/pipes.html
 [`extra::comm`]: extra/comm.html
 [`extra::sync`]: extra/sync.html
 [`extra::arc`]: extra/arc.html
@@ -125,7 +123,7 @@ receiving messages. Pipes are low-level communication building-blocks and so
 come in a variety of forms, each one appropriate for a different use case. In
 what follows, we cover the most commonly used varieties.
 
-The simplest way to create a pipe is to use the `pipes::stream`
+The simplest way to create a pipe is to use the `comm::stream`
 function to create a `(Port, Chan)` pair. In Rust parlance, a *channel*
 is a sending endpoint of a pipe, and a *port* is the receiving
 endpoint. Consider the following example of calculating two results

branches/snap-stage3/mk/platform.mk

@@ -47,8 +47,11 @@ else
   CFG_GCCISH_CFLAGS += -O2
 endif
 
+# The soname thing is for supporting a statically linked jemalloc.
+# see https://blog.mozilla.org/jseward/2012/06/05/valgrind-now-supports-jemalloc-builds-directly/
 ifdef CFG_VALGRIND
   CFG_VALGRIND += --error-exitcode=100 \
+                  --soname-synonyms=somalloc=NONE \
                   --quiet \
                   --suppressions=$(CFG_SRC_DIR)src/etc/x86.supp \
                   $(OS_SUPP)

branches/snap-stage3/src/libextra/fileinput.rs

@@ -433,7 +433,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_make_path_option_vec() {
         let strs = [~"some/path",
                     ~"some/other/path"];
@@ -448,7 +447,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_fileinput_read_byte() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -479,7 +477,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_fileinput_read() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -500,7 +497,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec() {
         let mut all_lines = ~[];
         let filenames = make_path_option_vec(vec::from_fn(
@@ -524,7 +520,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec_state() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -547,7 +542,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_empty_files() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -572,7 +566,6 @@ mod test {
     }
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_no_trailing_newline() {
         let f1 =
             Some(Path("tmp/lib-fileinput-test-no-trailing-newline-1.tmp"));
@@ -598,7 +591,6 @@ mod test {
 
 
     #[test]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_next_file() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -630,7 +622,6 @@ mod test {
 
     #[test]
     #[should_fail]
-    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec_missing_file() {
         do input_vec(make_path_option_vec([~"this/file/doesnt/exist"], true)) |line| {
             println(line);

branches/snap-stage3/src/libextra/json.rs

@@ -135,21 +135,18 @@ impl serialize::Encoder for Encoder {
                          _id: uint,
                          cnt: uint,
                          f: &fn(&mut Encoder)) {
-        // enums are encoded as strings or objects
+        // enums are encoded as strings or vectors:
         // Bunny => "Bunny"
-        // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
+        // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
+
         if cnt == 0 {
             self.wr.write_str(escape_str(name));
         } else {
-            self.wr.write_char('{');
-            self.wr.write_str("\"variant\"");
-            self.wr.write_char(':');
+            self.wr.write_char('[');
             self.wr.write_str(escape_str(name));
             self.wr.write_char(',');
-            self.wr.write_str("\"fields\"");
-            self.wr.write_str(":[");
             f(self);
-            self.wr.write_str("]}");
+            self.wr.write_char(']');
         }
     }
 
@@ -950,20 +947,14 @@ impl serialize::Decoder for Decoder {
         debug!("read_enum_variant(names=%?)", names);
         let name = match self.stack.pop() {
             String(s) => s,
-            Object(o) => {
-                let n = match o.find(&~"variant").expect("invalidly encoded json") {
-                    &String(ref s) => s.clone(),
-                    _ => fail!("invalidly encoded json"),
-                };
-                match o.find(&~"fields").expect("invalidly encoded json") {
-                    &List(ref l) => {
-                        for field in l.rev_iter() {
-                            self.stack.push(field.clone());
-                        }
-                    },
-                    _ => fail!("invalidly encoded json")
+            List(list) => {
+                for v in list.move_rev_iter() {
+                    self.stack.push(v);
+                }
+                match self.stack.pop() {
+                    String(s) => s,
+                    value => fail!("invalid variant name: %?", value),
                 }
-                n
             }
             ref json => fail!("invalid variant: %?", *json),
         };
@@ -1526,7 +1517,7 @@ mod tests {
                 let mut encoder = Encoder(wr);
                 animal.encode(&mut encoder);
             },
-            ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
+            ~"[\"Frog\",\"Henry\",349]"
         );
         assert_eq!(
             do io::with_str_writer |wr| {
@@ -1930,14 +1921,14 @@ mod tests {
         assert_eq!(value, Dog);
 
         let mut decoder =
-            Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap());
+            Decoder(from_str("[\"Frog\",\"Henry\",349]").unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Frog(~"Henry", 349));
     }
 
     #[test]
     fn test_decode_map() {
-        let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
+        let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}";
         let mut decoder = Decoder(from_str(s).unwrap());
         let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
 

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

@@ -496,16 +496,23 @@ fn test() {
     use std::io::WriterUtil;
     use std::{os, run};
 
-    let pth = Path("foo.c");
+    // Create a path to a new file 'filename' in the directory in which
+    // this test is running.
+    fn make_path(filename: ~str) -> Path {
+        let pth = os::self_exe_path().expect("workcache::test failed").pop().push(filename);
+        if os::path_exists(&pth) {
+            os::remove_file(&pth);
+        }
+        return pth;
+    }
+
+    let pth = make_path(~"foo.c");
     {
         let r = io::file_writer(&pth, [io::Create]);
         r.unwrap().write_str("int main() { return 0; }");
     }
 
-    let db_path = os::self_exe_path().expect("workcache::test failed").pop().push("db.json");
-    if os::path_exists(&db_path) {
-        os::remove_file(&db_path);
-    }
+    let db_path = make_path(~"db.json");
 
     let cx = Context::new(RWArc::new(Database::new(db_path)),
                           RWArc::new(Logger::new()),
@@ -514,17 +521,19 @@ fn test() {
     let s = do cx.with_prep("test1") |prep| {
 
         let subcx = cx.clone();
+        let pth = pth.clone();
 
         prep.declare_input("file", pth.to_str(), digest_file(&pth));
         do prep.exec |_exe| {
-            let out = Path("foo.o");
-            run::process_status("gcc", [~"foo.c", ~"-o", out.to_str()]);
+            let out = make_path(~"foo.o");
+            run::process_status("gcc", [pth.to_str(), ~"-o", out.to_str()]);
 
             let _proof_of_concept = subcx.prep("subfn");
             // Could run sub-rules inside here.
 
             out.to_str()
         }
     };
+
     io::println(s);
 }

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

@@ -13,7 +13,8 @@
 use option::*;
 use os;
 use rt;
-use rt::logging::{Logger, StdErrLogger, OwnedString};
+use rt::logging::{Logger, StdErrLogger};
+use send_str::SendStrOwned;
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -56,12 +57,12 @@ fn newsched_log_str(msg: ~str) {
         match optional_task {
             Some(local) => {
                 // Use the available logger
-                (*local).logger.log(OwnedString(msg));
+                (*local).logger.log(SendStrOwned(msg));
             }
             None => {
                 // There is no logger anywhere, just write to stderr
                 let mut logger = StdErrLogger;
-                logger.log(OwnedString(msg));
+                logger.log(SendStrOwned(msg));
             }
         }
     }

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

@@ -1135,18 +1135,19 @@ pub fn last_os_error() -> ~str {
         #[fixed_stack_segment]; #[inline(never)];
 
         use libc::types::os::arch::extra::DWORD;
-        use libc::types::os::arch::extra::LPSTR;
+        use libc::types::os::arch::extra::LPWSTR;
         use libc::types::os::arch::extra::LPVOID;
+        use libc::types::os::arch::extra::WCHAR;
 
         #[cfg(target_arch = "x86")]
         #[link_name = "kernel32"]
         #[abi = "stdcall"]
         extern "stdcall" {
-            fn FormatMessageA(flags: DWORD,
+            fn FormatMessageW(flags: DWORD,
                               lpSrc: LPVOID,
                               msgId: DWORD,
                               langId: DWORD,
-                              buf: LPSTR,
+                              buf: LPWSTR,
                               nsize: DWORD,
                               args: *c_void)
                               -> DWORD;
@@ -1155,11 +1156,11 @@ pub fn last_os_error() -> ~str {
         #[cfg(target_arch = "x86_64")]
         #[link_name = "kernel32"]
         extern {
-            fn FormatMessageA(flags: DWORD,
+            fn FormatMessageW(flags: DWORD,
                               lpSrc: LPVOID,
                               msgId: DWORD,
                               langId: DWORD,
-                              buf: LPSTR,
+                              buf: LPWSTR,
                               nsize: DWORD,
                               args: *c_void)
                               -> DWORD;
@@ -1173,11 +1174,11 @@ pub fn last_os_error() -> ~str {
         let langId = 0x0800 as DWORD;
         let err = errno() as DWORD;
 
-        let mut buf = [0 as c_char, ..TMPBUF_SZ];
+        let mut buf = [0 as WCHAR, ..TMPBUF_SZ];
 
         unsafe {
             do buf.as_mut_buf |buf, len| {
-                let res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
+                let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
                                          FORMAT_MESSAGE_IGNORE_INSERTS,
                                          ptr::mut_null(),
                                          err,
@@ -1190,9 +1191,7 @@ pub fn last_os_error() -> ~str {
                 }
             }
 
-            do buf.as_imm_buf |buf, _len| {
-                str::raw::from_c_str(buf)
-            }
+            str::from_utf16(buf)
         }
     }
 

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

@@ -66,6 +66,7 @@ pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::RawPtr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, ToBytesConsume};
+pub use send_str::{SendStr, SendStrOwned, SendStrStatic, IntoSendStr};
 pub use str::{Str, StrVector, StrSlice, OwnedStr};
 pub use from_str::FromStr;
 pub use to_bytes::IterBytes;

branches/snap-stage3/src/libstd/rt/io/file.rs

@@ -168,7 +168,6 @@ fn file_test_smoke_test_impl() {
 }
 
 #[test]
-#[ignore(cfg(windows))] // FIXME #8810
 fn file_test_io_smoke_test() {
     file_test_smoke_test_impl();
 }
@@ -236,7 +235,6 @@ fn file_test_io_non_positional_read_impl() {
 }
 
 #[test]
-#[ignore(cfg(windows))] // FIXME #8810
 fn file_test_io_non_positional_read() {
     file_test_io_non_positional_read_impl();
 }
@@ -268,8 +266,8 @@ fn file_test_io_seeking_impl() {
         assert!(tell_pos_post_read == message.len() as u64);
     }
 }
+
 #[test]
-#[ignore(cfg(windows))] // FIXME #8810
 fn file_test_io_seek_and_tell_smoke_test() {
     file_test_io_seeking_impl();
 }
@@ -300,8 +298,8 @@ fn file_test_io_seek_and_write_impl() {
         assert!(read_str == final_msg.to_owned());
     }
 }
+
 #[test]
-#[ignore(cfg(windows))] // FIXME #8810
 fn file_test_io_seek_and_write() {
     file_test_io_seek_and_write_impl();
 }
@@ -340,8 +338,8 @@ fn file_test_io_seek_shakedown_impl() {
         unlink(filename);
     }
 }
+
 #[test]
-#[ignore(cfg(windows))] // FIXME #8810
 fn file_test_io_seek_shakedown() {
     file_test_io_seek_shakedown_impl();
 }