---

yaml
---
r: 46655
b: refs/heads/auto
c: 7921810
h: refs/heads/master
i:
  46653: 63e6e5a
  46651: cb89862
  46647: fb3e47e
  46639: de6f57d
  46623: b1987de
  46591: 98b4d64
v: v3

Author: youknowone

[refs]

@@ -14,4 +14,4 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 36e898962daa596dd757e31aa86676b1b448b273
+refs/heads/auto: 792181084244abc7ab361fd1db809c4217148304

branches/auto/src/libcore/at_vec.rs

@@ -183,7 +183,7 @@ pub mod raw {
     use at_vec::{capacity, rustrt};
     use cast::transmute;
     use libc;
-    use unstable::intrinsics::{move_val_init};
+    use private::intrinsics::{move_val_init};
     use ptr::addr_of;
     use ptr;
     use sys;

branches/auto/src/libcore/comm.rs

@@ -8,17 +8,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// Transitional -- needs snapshot
+#[allow(structural_records)];
+
 use either::{Either, Left, Right};
 use kinds::Owned;
 use option;
 use option::{Option, Some, None, unwrap};
-use unstable;
+use private;
 use vec;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
-// FIXME #5160: Making this public exposes some plumbing from
-// pipes. Needs some refactoring
+// NOTE Making this public exposes some plumbing from pipes. Needs
+// some refactoring
 pub use pipes::Selectable;
 
 /// A trait for things that can send multiple messages.
@@ -242,7 +245,7 @@ impl<T: Owned> Peekable<T> for PortSet<T> {
 }
 
 /// A channel that can be shared between many senders.
-pub type SharedChan<T> = unstable::Exclusive<Chan<T>>;
+pub type SharedChan<T> = private::Exclusive<Chan<T>>;
 
 impl<T: Owned> GenericChan<T> for SharedChan<T> {
     fn send(x: T) {
@@ -268,7 +271,7 @@ impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
 
 /// Converts a `chan` into a `shared_chan`.
 pub fn SharedChan<T:Owned>(c: Chan<T>) -> SharedChan<T> {
-    unstable::exclusive(c)
+    private::exclusive(c)
 }
 
 /// Receive a message from one of two endpoints.

branches/auto/src/libcore/core.rc

@@ -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.
 //
@@ -41,7 +41,7 @@ Implicitly, all crates behave as if they included the following prologue:
        url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
 
 #[comment = "The Rust core library"];
-#[license = "MIT/ASL2"];
+#[license = "MIT"];
 #[crate_type = "lib"];
 
 
@@ -227,13 +227,13 @@ pub const debug : u32 = 4_u32;
 
 // The runtime interface used by the compiler
 #[cfg(notest)] pub mod rt;
-// Private APIs
-pub mod unstable;
-// NOTE: Remove after snapshot
+// The runtime and compiler interface to fmt!
 #[cfg(stage0)]
-pub mod private {
-    pub use super::unstable::extfmt;
-}
+#[path = "private/extfmt.rs"]
+pub mod extfmt;
+// Private APIs
+pub mod private;
+
 
 /* For internal use, not exported */
 

branches/auto/src/libcore/num/f32.rs

@@ -18,7 +18,7 @@ use num::strconv;
 use num;
 use ops;
 use option::Option;
-use unstable::intrinsics::floorf32;
+use private::intrinsics::floorf32;
 use from_str;
 use to_str;
 

branches/auto/src/libcore/num/f64.rs

@@ -19,7 +19,7 @@ use num::strconv;
 use num;
 use ops;
 use option::Option;
-use unstable::intrinsics::floorf64;
+use private::intrinsics::floorf64;
 use to_str;
 use from_str;
 

branches/auto/src/libcore/num/strconv.rs

@@ -478,16 +478,17 @@ pub pure fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+
         }
     }
 
+    // XXX: Bytevector constant from str
     if special {
-        if buf == str::inf_buf || buf == str::positive_inf_buf {
+        if buf == str::to_bytes("inf") || buf == str::to_bytes("+inf") {
             return NumStrConv::inf();
-        } else if buf == str::negative_inf_buf {
+        } else if buf == str::to_bytes("-inf") {
             if negative {
                 return NumStrConv::neg_inf();
             } else {
                 return None;
             }
-        } else if buf == str::nan_buf {
+        } else if buf == str::to_bytes("NaN") {
             return NumStrConv::NaN();
         }
     }

branches/auto/src/libcore/os.rs

@@ -35,6 +35,7 @@ use libc::{mode_t, pid_t, FILE};
 use option;
 use option::{Some, None};
 use prelude::*;
+use private;
 use ptr;
 use str;
 use task;
@@ -144,8 +145,8 @@ This uses a per-runtime lock to serialize access.
 FIXME #4726: It would probably be appropriate to make this a real global
 */
 fn with_env_lock<T>(f: &fn() -> T) -> T {
-    use unstable::global::global_data_clone_create;
-    use unstable::{Exclusive, exclusive};
+    use private::global::global_data_clone_create;
+    use private::{Exclusive, exclusive};
 
     struct SharedValue(());
     type ValueMutex = Exclusive<SharedValue>;

branches/auto/src/libcore/pipes.rs

@@ -82,6 +82,8 @@ bounded and unbounded protocols allows for less code duplication.
 
 */
 
+#[allow(structural_records)]; // Macros -- needs another snapshot
+
 use cmp::Eq;
 use cast::{forget, reinterpret_cast, transmute};
 use cell::Cell;
@@ -91,9 +93,9 @@ use libc;
 use option;
 use option::{None, Option, Some, unwrap};
 use pipes;
-use unstable::intrinsics;
+use private::intrinsics;
 use ptr;
-use unstable;
+use private;
 use task;
 use vec;
 

branches/auto/src/libcore/prelude.rs

@@ -69,7 +69,7 @@ pub use option;
 pub use os;
 pub use path;
 pub use comm;
-pub use unstable;
+pub use private;
 pub use ptr;
 pub use rand;
 pub use result;

branches/auto/src/libcore/unstable.rs renamed to branches/auto/src/libcore/private.rs

@@ -22,19 +22,19 @@ use task;
 use task::{TaskBuilder, atomically};
 use uint;
 
-#[path = "unstable/at_exit.rs"]
+#[path = "private/at_exit.rs"]
 pub mod at_exit;
-#[path = "unstable/global.rs"]
+#[path = "private/global.rs"]
 pub mod global;
-#[path = "unstable/finally.rs"]
+#[path = "private/finally.rs"]
 pub mod finally;
-#[path = "unstable/weak_task.rs"]
+#[path = "private/weak_task.rs"]
 pub mod weak_task;
-#[path = "unstable/exchange_alloc.rs"]
+#[path = "private/exchange_alloc.rs"]
 pub mod exchange_alloc;
-#[path = "unstable/intrinsics.rs"]
+#[path = "private/intrinsics.rs"]
 pub mod intrinsics;
-#[path = "unstable/extfmt.rs"]
+#[path = "private/extfmt.rs"]
 pub mod extfmt;
 
 extern mod rustrt {
@@ -312,7 +312,7 @@ pub mod tests {
     use cell::Cell;
     use comm;
     use option;
-    use super::exclusive;
+    use private::exclusive;
     use result;
     use task;
     use uint;

branches/auto/src/libcore/unstable/at_exit.rs renamed to branches/auto/src/libcore/private/at_exit.rs

@@ -14,7 +14,7 @@ use c_malloc = libc::malloc;
 use c_free = libc::free;
 use managed::raw::{BoxHeaderRepr, BoxRepr};
 use cast::transmute;
-use unstable::intrinsics::{atomic_xadd,atomic_xsub};
+use private::intrinsics::{atomic_xadd,atomic_xsub};
 use ptr::null;
 use intrinsic::TyDesc;
 

branches/auto/src/libcore/unstable/exchange_alloc.rs renamed to branches/auto/src/libcore/private/exchange_alloc.rs

@@ -26,10 +26,33 @@ do || {
 use ops::Drop;
 use task::{spawn, failing};
 
+#[cfg(stage0)]
+pub trait Finally<T> {
+    fn finally(&self, +dtor: &fn()) -> T;
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 pub trait Finally<T> {
     fn finally(&self, dtor: &fn()) -> T;
 }
 
+#[cfg(stage0)]
+impl<T> Finally<T> for &fn() -> T {
+    // FIXME #4518: Should not require a mode here
+    fn finally(&self, +dtor: &fn()) -> T {
+        let _d = Finallyalizer {
+            dtor: dtor
+        };
+
+        (*self)()
+    }
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
 impl<T> Finally<T> for &fn() -> T {
     fn finally(&self, dtor: &fn()) -> T {
         let _d = Finallyalizer {

branches/auto/src/libcore/unstable/extfmt.rs renamed to branches/auto/src/libcore/private/extfmt.rs

@@ -32,11 +32,11 @@ use libc::{c_void, uintptr_t};
 use option::{Option, Some, None};
 use ops::Drop;
 use pipes;
-use unstable::{Exclusive, exclusive};
-use unstable::{SharedMutableState, shared_mutable_state};
-use unstable::{get_shared_immutable_state};
-use unstable::at_exit::at_exit;
-use unstable::intrinsics::atomic_cxchg;
+use private::{Exclusive, exclusive};
+use private::{SharedMutableState, shared_mutable_state};
+use private::{get_shared_immutable_state};
+use private::at_exit::at_exit;
+use private::intrinsics::atomic_cxchg;
 use hashmap::linear::LinearMap;
 use sys::Closure;
 use task::spawn;

branches/auto/src/libcore/unstable/finally.rs renamed to branches/auto/src/libcore/private/finally.rs

@@ -24,9 +24,9 @@ use comm::{Port, Chan, SharedChan, GenericChan, GenericPort};
 use hashmap::linear::LinearMap;
 use ops::Drop;
 use option::{Some, None, swap_unwrap};
-use unstable::at_exit::at_exit;
-use unstable::finally::Finally;
-use unstable::global::global_data_clone_create;
+use private::at_exit::at_exit;
+use private::finally::Finally;
+use private::global::global_data_clone_create;
 use task::rt::{task_id, get_task_id};
 use task::{Task, task, spawn};
 

branches/auto/src/libcore/unstable/global.rs renamed to branches/auto/src/libcore/private/global.rs

@@ -14,7 +14,7 @@ use cast;
 use cmp::{Eq, Ord};
 use libc;
 use libc::{c_void, size_t};
-use unstable::intrinsics::{memmove32,memmove64};
+use private::intrinsics::{memmove32,memmove64};
 use ptr;
 use str;
 use sys;

branches/auto/src/libcore/unstable/intrinsics.rs renamed to branches/auto/src/libcore/private/intrinsics.rs

@@ -15,7 +15,7 @@ use libc::{c_char, c_uchar, c_void, size_t, uintptr_t, c_int};
 use managed::raw::BoxRepr;
 use str;
 use sys;
-use unstable::exchange_alloc;
+use private::exchange_alloc;
 use cast::transmute;
 
 use gc::{cleanup_stack_for_failure, gc, Word};

branches/auto/src/libcore/unstable/weak_task.rs renamed to branches/auto/src/libcore/private/weak_task.rs

@@ -10,6 +10,9 @@
 
 #[doc(hidden)]; // FIXME #3538
 
+#[legacy_modes]; // tjc: remove after snapshot
+#[allow(deprecated_mode)];
+
 use cast::reinterpret_cast;
 use ptr::offset;
 use sys::size_of;

branches/auto/src/libcore/ptr.rs

@@ -1832,13 +1832,6 @@ const tag_five_b: uint = 248u;
 const max_five_b: uint = 67108864u;
 const tag_six_b: uint = 252u;
 
-// Constants used for converting strs to floats
-pub const inf_buf: [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
-pub const positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8,
-                                      'n' as u8, 'f' as u8];
-pub const negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8,
-                                      'n' as u8, 'f' as u8];
-pub const nan_buf: [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
 
 /**
  * Work with the byte buffer of a string.

branches/auto/src/libcore/rt.rs

@@ -79,7 +79,7 @@ use option;
 use comm::{Chan, GenericChan, GenericPort, Port, stream};
 use pipes;
 use prelude::*;
-use unstable;
+use private;
 use ptr;
 use hashmap::linear::LinearSet;
 use task::local_data_priv::{local_get, local_set};
@@ -123,7 +123,7 @@ struct TaskGroupData {
     // tasks in this group.
     mut descendants: TaskSet,
 }
-type TaskGroupArc = unstable::Exclusive<Option<TaskGroupData>>;
+type TaskGroupArc = private::Exclusive<Option<TaskGroupData>>;
 
 type TaskGroupInner = &mut Option<TaskGroupData>;
 
@@ -153,7 +153,7 @@ struct AncestorNode {
     mut ancestors:    AncestorList,
 }
 
-enum AncestorList = Option<unstable::Exclusive<AncestorNode>>;
+enum AncestorList = Option<private::Exclusive<AncestorNode>>;
 
 // Accessors for taskgroup arcs and ancestor arcs that wrap the unsafety.
 #[inline(always)]
@@ -162,7 +162,7 @@ fn access_group<U>(x: &TaskGroupArc, blk: fn(TaskGroupInner) -> U) -> U {
 }
 
 #[inline(always)]
-fn access_ancestors<U>(x: &unstable::Exclusive<AncestorNode>,
+fn access_ancestors<U>(x: &private::Exclusive<AncestorNode>,
                        blk: fn(x: &mut AncestorNode) -> U) -> U {
     unsafe { x.with(blk) }
 }
@@ -458,7 +458,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
                 // Main task, doing first spawn ever. Lazily initialise here.
                 let mut members = new_taskset();
                 taskset_insert(&mut members, spawner);
-                let tasks = unstable::exclusive(Some(TaskGroupData {
+                let tasks = private::exclusive(Some(TaskGroupData {
                     members: members,
                     descendants: new_taskset(),
                 }));
@@ -482,7 +482,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
             (g, a, spawner_group.is_main)
         } else {
             // Child is in a separate group from spawner.
-            let g = unstable::exclusive(Some(TaskGroupData {
+            let g = private::exclusive(Some(TaskGroupData {
                 members:     new_taskset(),
                 descendants: new_taskset(),
             }));
@@ -502,7 +502,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
                     };
                 assert new_generation < uint::max_value;
                 // Build a new node in the ancestor list.
-                AncestorList(Some(unstable::exclusive(AncestorNode {
+                AncestorList(Some(private::exclusive(AncestorNode {
                     generation: new_generation,
                     parent_group: Some(spawner_group.tasks.clone()),
                     ancestors: old_ancestors,