---

yaml
---
r: 152345
b: refs/heads/try2
c: 5ec36c3
h: refs/heads/master
i:
  152343: f4b6fd4
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: a3f9aa9ef8657304006fcbe4759a263720b8592c
+refs/heads/try2: 5ec36c358f74fe83332231e774ea20a21d165120
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rlibc alloc debug
+                 url log regex graphviz core rlibc alloc debug rustrt
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -60,7 +60,9 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core rand libc alloc collections native:rustrt native:backtrace
+DEPS_rustrt := alloc core libc collections native:rustrt_native
+DEPS_std := core libc rand alloc collections rustrt \
+	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support

branches/try2/mk/rt.mk

@@ -35,8 +35,8 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rustrt hoedown uv_support morestack miniz context_switch \
-		rust_test_helpers
+NATIVE_LIBS := rust_builtin hoedown uv_support morestack miniz context_switch \
+		rustrt_native rust_test_helpers
 
 # $(1) is the target triple
 define NATIVE_LIBRARIES
@@ -52,8 +52,9 @@ NATIVE_DEPS_hoedown_$(1) := hoedown/src/autolink.c \
 			hoedown/src/version.c
 NATIVE_DEPS_uv_support_$(1) := rust_uv.c
 NATIVE_DEPS_miniz_$(1) = miniz.c
-NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
-			rust_android_dummy.c \
+NATIVE_DEPS_rust_builtin_$(1) := rust_builtin.c \
+			rust_android_dummy.c
+NATIVE_DEPS_rustrt_native_$(1) := \
 			rust_try.ll \
 			arch/$$(HOST_$(1))/record_sp.S
 NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c

branches/try2/src/libcore/macros.rs

@@ -98,6 +98,20 @@ macro_rules! try(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )
 
+/// Writing a formatted string into a writer
+#[macro_export]
+macro_rules! write(
+    ($dst:expr, $($arg:tt)*) => (format_args_method!($dst, write_fmt, $($arg)*))
+)
+
+/// Writing a formatted string plus a newline into a writer
+#[macro_export]
+macro_rules! writeln(
+    ($dst:expr, $fmt:expr $($arg:tt)*) => (
+        write!($dst, concat!($fmt, "\n") $($arg)*)
+    )
+)
+
 #[cfg(test)]
 macro_rules! vec( ($($e:expr),*) => ({
     let mut _v = ::std::vec::Vec::new();

branches/try2/src/libstd/rt/args.rs renamed to branches/try2/src/librustrt/args.rs

@@ -18,10 +18,9 @@
 //! discover the command line arguments.
 //!
 //! FIXME #7756: Would be nice for this to not exist.
-//! FIXME #7756: This has a lot of C glue for lack of globals.
 
-use option::Option;
-use vec::Vec;
+use core::prelude::*;
+use collections::vec::Vec;
 
 /// One-time global initialization.
 pub unsafe fn init(argc: int, argv: **u8) { imp::init(argc, argv) }
@@ -44,14 +43,14 @@ pub fn clone() -> Option<Vec<Vec<u8>>> { imp::clone() }
 #[cfg(target_os = "android")]
 #[cfg(target_os = "freebsd")]
 mod imp {
-    use clone::Clone;
-    use iter::Iterator;
-    use option::{Option, Some, None};
-    use owned::Box;
-    use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
-    use mem;
-    use vec::Vec;
-    use ptr::RawPtr;
+    use core::prelude::*;
+
+    use alloc::owned::Box;
+    use collections::vec::Vec;
+    use core::mem;
+    use core::slice;
+
+    use mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
     static mut global_args_ptr: uint = 0;
     static mut lock: StaticNativeMutex = NATIVE_MUTEX_INIT;
@@ -100,24 +99,23 @@ mod imp {
         unsafe { mem::transmute(&global_args_ptr) }
     }
 
-    // Copied from `os`.
     unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> Vec<Vec<u8>> {
-        use c_str::CString;
-        use ptr::RawPtr;
-        use libc;
-        use vec::Vec;
-
         Vec::from_fn(argc as uint, |i| {
-            let cs = CString::new(*(argv as **libc::c_char).offset(i as int), false);
-            Vec::from_slice(cs.as_bytes_no_nul())
+            let base = *argv.offset(i as int);
+            let mut len = 0;
+            while *base.offset(len) != 0 { len += 1; }
+            slice::raw::buf_as_slice(base, len as uint, |slice| {
+                Vec::from_slice(slice)
+            })
         })
     }
 
     #[cfg(test)]
     mod tests {
-        use prelude::*;
+        use std::prelude::*;
+        use std::finally::Finally;
+
         use super::*;
-        use finally::Finally;
 
         #[test]
         fn smoke_test() {
@@ -149,8 +147,8 @@ mod imp {
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "win32")]
 mod imp {
-    use option::Option;
-    use vec::Vec;
+    use core::prelude::*;
+    use collections::vec::Vec;
 
     pub unsafe fn init(_argc: int, _argv: **u8) {
     }

branches/try2/src/librustrt/at_exit_imp.rs

@@ -0,0 +1,63 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation of running at_exit routines
+//!
+//! Documentation can be found on the `rt::at_exit` function.
+
+use core::prelude::*;
+
+use alloc::owned::Box;
+use collections::vec::Vec;
+use core::atomics;
+use core::mem;
+
+use exclusive::Exclusive;
+
+type Queue = Exclusive<Vec<proc():Send>>;
+
+static mut QUEUE: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
+static mut RUNNING: atomics::AtomicBool = atomics::INIT_ATOMIC_BOOL;
+
+pub fn init() {
+    let state: Box<Queue> = box Exclusive::new(Vec::new());
+    unsafe {
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        rtassert!(QUEUE.swap(mem::transmute(state), atomics::SeqCst) == 0);
+    }
+}
+
+pub fn push(f: proc():Send) {
+    unsafe {
+        // Note that the check against 0 for the queue pointer is not atomic at
+        // all with respect to `run`, meaning that this could theoretically be a
+        // use-after-free. There's not much we can do to protect against that,
+        // however. Let's just assume a well-behaved runtime and go from there!
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        let queue = QUEUE.load(atomics::SeqCst);
+        rtassert!(queue != 0);
+        (*(queue as *Queue)).lock().push(f);
+    }
+}
+
+pub fn run() {
+    let cur = unsafe {
+        rtassert!(!RUNNING.load(atomics::SeqCst));
+        let queue = QUEUE.swap(0, atomics::SeqCst);
+        rtassert!(queue != 0);
+
+        let queue: Box<Queue> = mem::transmute(queue);
+        mem::replace(&mut *queue.lock(), Vec::new())
+    };
+
+    for to_run in cur.move_iter() {
+        to_run();
+    }
+}

branches/try2/src/libstd/rt/bookkeeping.rs renamed to branches/try2/src/librustrt/bookkeeping.rs

@@ -18,11 +18,9 @@
 //! each respective runtime to make sure that they call increment() and
 //! decrement() manually.
 
-#![experimental] // this is a massive code smell
-#![doc(hidden)]
+use core::atomics;
 
-use sync::atomics;
-use unstable::mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
+use mutex::{StaticNativeMutex, NATIVE_MUTEX_INIT};
 
 static mut TASK_COUNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
 static mut TASK_LOCK: StaticNativeMutex = NATIVE_MUTEX_INIT;

branches/try2/src/libstd/c_str.rs renamed to branches/try2/src/librustrt/c_str.rs

@@ -65,24 +65,17 @@ fn main() {
 
 */
 
-use clone::Clone;
-use cmp::PartialEq;
-use container::Container;
-use iter::{Iterator, range};
-use kinds::marker;
+use core::prelude::*;
+
+use alloc::libc_heap::malloc_raw;
+use collections::string::String;
+use core::kinds::marker;
+use core::mem;
+use core::ptr;
+use core::raw::Slice;
+use core::slice;
+use core::str;
 use libc;
-use mem;
-use ops::Drop;
-use option::{Option, Some, None};
-use ptr::RawPtr;
-use ptr;
-use raw::Slice;
-use rt::libc_heap::malloc_raw;
-use slice::{ImmutableVector, MutableVector};
-use slice;
-use str::StrSlice;
-use str;
-use string::String;
 
 /// The representation of a C String.
 ///
@@ -454,11 +447,12 @@ pub unsafe fn from_c_multistring(buf: *libc::c_char,
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use super::*;
+    use std::prelude::*;
+    use std::ptr;
+    use std::task;
     use libc;
-    use ptr;
-    use str::StrSlice;
+
+    use super::*;
 
     #[test]
     fn test_str_multistring_parsing() {
@@ -574,7 +568,6 @@ mod tests {
 
     #[test]
     fn test_to_c_str_fail() {
-        use task;
         assert!(task::try(proc() { "he\x00llo".to_c_str() }).is_err());
     }
 
@@ -700,10 +693,9 @@ mod tests {
 
 #[cfg(test)]
 mod bench {
-    extern crate test;
-    use self::test::Bencher;
+    use test::Bencher;
     use libc;
-    use prelude::*;
+    use std::prelude::*;
 
     #[inline]
     fn check(s: &str, c_str: *libc::c_char) {