---

yaml
---
r: 139055
b: refs/heads/try2
c: f54adca
h: refs/heads/master
i:
  139053: 0bdaf7e
  139051: ba3210c
  139047: 04172ad
  139039: 9d52971
v: v3

Author: bors

[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: 246573d5ae1024193914de8c9be9230860781410
+refs/heads/try2: f54adca7c984c75334d9cb73ec85bf3b5c326ed9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -10,7 +10,8 @@ Version 0.6 (March 2013)
       * Remove `static` keyword
       * Static method syntax
       * `as Trait`
-      * `copy` removed?
+      * `copy` removed, replaced with `Clone`?
+      * `std::map` removed, replaced with `core::hashmap`
 
    * Syntax changes
       * The self type parameter in traits is now spelled `Self`
@@ -38,7 +39,8 @@ Version 0.6 (March 2013)
       * Trait implementations no longer support visibility modifiers
 
    * Semantic changes
-      * Linear types move by default, eliminating the `move` keyword
+      * Types with owned pointers or custom destructors move by default,
+        eliminating the `move` keyword
       * All foreign functions are considered unsafe
       * &mut is now unaliasable
       * Writes to borrowed @mut pointers are prevented dynamically
@@ -57,16 +59,19 @@ Version 0.6 (March 2013)
         improve inference and eliminate unsoundness
 
    * Libraries
-      * Lots of effort to organize the container API's around `core::container`
-      * `core::send_map` renamed to `core::hashmap`
       * Added big integers to `std::bigint`
       * Removed `core::oldcomm` module
       * Added pipe-based `core::comm` module
-      * Reimplemented `std::treemap`
       * Numeric traits have been reorganized under `core::num`
-      * `core::dvec` removed. Use `@mut ~[T]` or other language types
       * `vec::slice` finally returns a slice
       * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
+      * Containers reorganized around traits in `core::container`
+      * `core::dvec` removed, `~[T]` is a drop-in replacement
+      * `core::send_map` renamed to `core::hashmap`
+      * `std::treemap` reimplemented as an owned balanced tree
+      * `std::deque` and `std::smallintmap` reimplemented as owned containers
+      * `core::trie` added as a fast ordered map for integer keys
+      * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
 
    * Tools
       * Replaced the 'cargo' package manager with 'rustpkg'

branches/try2/mk/rt.mk

@@ -132,7 +132,7 @@ rt/$(1)/%.o: rt/%.S  $$(MKFILE_DEPS) \
 
 rt/$(1)/arch/$$(HOST_$(1))/libmorestack.a: $$(MORESTACK_OBJ_$(1))
 	@$$(call E, link: $$@)
-	$$(Q)ar rcs $$@ $$<
+	$$(Q)$(AR_$(1)) rcs $$@ $$<
 
 rt/$(1)/$(CFG_RUNTIME_$(1)): $$(RUNTIME_OBJS_$(1)) $$(MKFILE_DEPS) \
                         $$(RUNTIME_DEF_$(1)) \

branches/try2/src/libcore/cleanup.rs

@@ -145,11 +145,7 @@ unsafe fn each_live_alloc(f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
 
 #[cfg(unix)]
 fn debug_mem() -> bool {
-    use os;
-    use libc;
-    do os::as_c_charp("RUST_DEBUG_MEM") |p| {
-        unsafe { libc::getenv(p) != null() }
-    }
+    ::rt::env::get().debug_mem
 }
 
 #[cfg(windows)]

branches/try2/src/libcore/clone.rs

@@ -20,6 +20,11 @@ impl Clone for () {
     fn clone(&self) -> () { () }
 }
 
+impl<T:Clone> Clone for ~T {
+    #[inline(always)]
+    fn clone(&self) -> ~T { ~(**self).clone() }
+}
+
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {

branches/try2/src/libcore/container.rs

@@ -35,6 +35,9 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: &fn(&V) -> bool);
 
+    /// Iterate over the map and mutate the contained values
+    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
+
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V>;
 

branches/try2/src/libcore/core.rc

@@ -56,6 +56,7 @@ Implicitly, all crates behave as if they included the following prologue:
 
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
+#[doc(hidden)]
 pub mod linkhack {
     #[link_args="-lrustrt -lrt"]
     #[link_args = "-lpthread"]
@@ -252,7 +253,7 @@ pub mod rt;
 // A curious inner-module that's not exported that contains the binding
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
-#[doc(hidden)] // FIXME #3538
+#[doc(hidden)]
 pub mod core {
     #[cfg(stage0)]
     pub const error : u32 = 1_u32;

branches/try2/src/libcore/hashmap.rs

@@ -325,6 +325,19 @@ pub mod linear {
             self.each(|&(_, v)| blk(v))
         }
 
+        /// Iterate over the map and mutate the contained values
+        fn mutate_values(&mut self, blk: &fn(&'self K,
+                              &'self mut V) -> bool) {
+            for uint::range(0, self.buckets.len()) |i| {
+                match self.buckets[i] {
+                  Some(Bucket{key: ref key, value: ref mut value, _}) => {
+                    if !blk(key, value) { return }
+                  }
+                  None => ()
+                }
+            }
+        }
+
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
             match self.bucket_for_key(k) {

branches/try2/src/libcore/iter.rs

@@ -31,6 +31,10 @@ pub trait ReverseIter<A>: BaseIter<A> {
     pure fn each_reverse(&self, blk: &fn(&A) -> bool);
 }
 
+pub trait MutableIter<A>: BaseIter<A> {
+    fn each_mut(&mut self, blk: &fn(&mut A) -> bool);
+}
+
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: &fn(&A) -> bool) -> bool;

branches/try2/src/libcore/option.rs

@@ -46,7 +46,7 @@ use ops::Add;
 use kinds::Copy;
 use util;
 use num::Zero;
-use iter::BaseIter;
+use iter::{BaseIter, MutableIter};
 
 #[cfg(test)] use ptr;
 #[cfg(test)] use str;
@@ -323,6 +323,13 @@ impl<T> BaseIter<T> for Option<T> {
     }
 }
 
+impl<T> MutableIter<T> for Option<T> {
+    #[inline(always)]
+    fn each_mut(&mut self, f: &fn(&'self mut T) -> bool) {
+        match *self { None => (), Some(ref mut t) => { f(t); } }
+    }
+}
+
 pub impl<T> Option<T> {
     /// Returns true if the option equals `none`
     #[inline(always)]

branches/try2/src/libcore/prelude.rs

@@ -27,8 +27,9 @@ pub use clone::Clone;
 pub use cmp::{Eq, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
-pub use iter::{BaseIter, ReverseIter, ExtendedIter, EqIter, CopyableIter};
-pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
+pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
+pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
+pub use iter::Times;
 pub use num::NumCast;
 pub use path::GenericPath;
 pub use path::Path;
@@ -43,6 +44,10 @@ pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
 
+/* Reexported runtime types */
+pub use comm::{stream, Port, Chan, GenericChan, GenericSmartChan, GenericPort, Peekable};
+pub use task::spawn;
+
 /* Reexported modules */
 
 pub use at_vec;

branches/try2/src/libcore/rt/env.rs

@@ -0,0 +1,47 @@
+// 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.
+
+//! Runtime environment settings
+
+use libc::{size_t, c_char, c_int};
+
+pub struct Environment {
+    /// The number of threads to use by default
+    num_sched_threads: size_t,
+    /// The minimum size of a stack segment
+    min_stack_size: size_t,
+    /// The maximum amount of total stack per task before aborting
+    max_stack_size: size_t,
+    /// The default logging configuration
+    logspec: *c_char,
+    /// Record and report detailed information about memory leaks
+    detailed_leaks: bool,
+    /// Seed the random number generator
+    rust_seed: *c_char,
+    /// Poison allocations on free
+    poison_on_free: bool,
+    /// The argc value passed to main
+    argc: c_int,
+    /// The argv value passed to main
+    argv: **c_char,
+    /// Print GC debugging info
+    debug_mem: bool
+}
+
+/// Get the global environment settings
+/// # Safety Note
+/// This will abort the process if run outside of task context
+pub fn get() -> &Environment {
+    unsafe { rust_get_rt_env() }
+}
+
+extern {
+    fn rust_get_rt_env() -> &Environment;
+}

branches/try2/src/libcore/rt/mod.rs

@@ -45,3 +45,4 @@ mod work_queue;
 mod stack;
 mod context;
 mod thread;
+pub mod env;

branches/try2/src/libcore/rt/thread_local_storage.rs

@@ -40,6 +40,7 @@ type pthread_key_t = c_ulong;
 
 #[cfg(target_os="linux")]
 #[cfg(target_os="freebsd")]
+#[cfg(target_os="android")]
 #[allow(non_camel_case_types)] // foreign type
 type pthread_key_t = c_uint;
 

branches/try2/src/libcore/str.rs

@@ -20,6 +20,7 @@
 use at_vec;
 use cast;
 use char;
+use clone::Clone;
 use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
@@ -2273,6 +2274,7 @@ pub trait StrSlice {
     pure fn to_owned(&self) -> ~str;
     pure fn to_managed(&self) -> @str;
     pure fn char_at(&self, i: uint) -> char;
+    fn to_bytes(&self) -> ~[u8];
 }
 
 /// Extension methods for strings
@@ -2416,6 +2418,8 @@ impl StrSlice for &self/str {
 
     #[inline]
     pure fn char_at(&self, i: uint) -> char { char_at(*self, i) }
+
+    fn to_bytes(&self) -> ~[u8] { to_bytes(*self) }
 }
 
 pub trait OwnedStr {
@@ -2433,6 +2437,13 @@ impl OwnedStr for ~str {
     }
 }
 
+impl Clone for ~str {
+    #[inline(always)]
+    fn clone(&self) -> ~str {
+        self.to_str()  // hilarious
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use char;