---

yaml
---
r: 139399
b: refs/heads/try2
c: 09255db
h: refs/heads/master
i:
  139397: 36c481a
  139395: c058f47
  139391: fb42803
v: v3

Author: luqmana

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

branches/try2/RELEASES.txt

@@ -62,8 +62,6 @@ Version 0.6 (March 2013)
       * Pattern matching over vectors improved and expanded
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
-      * Macros leave scope at the end of modules, unless that module is
-        tagged with #[macro_escape]
 
    * Libraries
       * Added big integers to `std::bigint`

branches/try2/configure

@@ -308,6 +308,8 @@ case $CFG_OSTYPE in
 esac
 
 
+if [ -z "$CFG_CPUTYPE" ]
+then
 case $CFG_CPUTYPE in
 
     i386 | i486 | i686 | i786 | x86)
@@ -325,6 +327,7 @@ case $CFG_CPUTYPE in
     *)
         err "unknown CPU type: $CFG_CPUTYPE"
 esac
+fi
 
 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
@@ -572,7 +575,7 @@ fi
 CFG_PREFIX=${CFG_PREFIX%/}
 CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
 CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
-CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
+CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed 's,^[^_]*_,,' | sed 's/\([^=]*\).*/\1/' | xargs)"
 
 # copy host-triples to target-triples so that hosts are a subset of targets
 V_TEMP=""

branches/try2/src/libcore/cmp.rs

@@ -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.
 //
@@ -21,82 +21,86 @@ and `Eq` to overload the `==` and `!=` operators.
 */
 
 /**
-* Trait for values that can be compared for equality and inequality.
+* Trait for values that can be compared for equality
+* and inequality.
 *
-* This trait allows partial equality, where types can be unordered instead of strictly equal or
-* unequal. For example, with the built-in floating-point types `a == b` and `a != b` will both
-* evaluate to false if either `a` or `b` is NaN (cf. IEEE 754-2008 section 5.11).
-*
-* Eventually, this will be implemented by default for types that implement `TotalEq`.
+* Eventually this may be simplified to only require
+* an `eq` method, with the other generated from
+* a default implementation. However it should
+* remain possible to implement `ne` separately, for
+* compatibility with floating-point NaN semantics
+* (cf. IEEE 754-2008 section 5.11).
 */
 #[lang="eq"]
 pub trait Eq {
     fn eq(&self, other: &Self) -> bool;
     fn ne(&self, other: &Self) -> bool;
 }
 
-/// Trait for equality comparisons where `a == b` and `a != b` are strict inverses.
-pub trait TotalEq {
-    fn equals(&self, other: &Self) -> bool;
+#[deriving(Eq)]
+pub enum Ordering { Less, Equal, Greater }
+
+/// Trait for types that form a total order
+pub trait TotalOrd {
+    fn cmp(&self, other: &Self) -> Ordering;
 }
 
-macro_rules! totaleq_impl(
-    ($t:ty) => {
-        impl TotalEq for $t {
-            #[inline(always)]
-            fn equals(&self, other: &$t) -> bool { *self == *other }
-        }
-    }
-)
+#[inline(always)]
+fn icmp<T: Ord>(a: &T, b: &T) -> Ordering {
+    if *a < *b { Less }
+    else if *a > *b { Greater }
+    else { Equal }
+}
 
-totaleq_impl!(bool)
+impl TotalOrd for u8 {
+    #[inline(always)]
+    fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(u8)
-totaleq_impl!(u16)
-totaleq_impl!(u32)
-totaleq_impl!(u64)
+impl TotalOrd for u16 {
+    #[inline(always)]
+    fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(i8)
-totaleq_impl!(i16)
-totaleq_impl!(i32)
-totaleq_impl!(i64)
+impl TotalOrd for u32 {
+    #[inline(always)]
+    fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(int)
-totaleq_impl!(uint)
+impl TotalOrd for u64 {
+    #[inline(always)]
+    fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) }
+}
 
-#[deriving(Eq)]
-pub enum Ordering { Less, Equal, Greater }
+impl TotalOrd for i8 {
+    #[inline(always)]
+    fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) }
+}
 
-/// Trait for types that form a total order
-pub trait TotalOrd: TotalEq {
-    fn cmp(&self, other: &Self) -> Ordering;
+impl TotalOrd for i16 {
+    #[inline(always)]
+    fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) }
 }
 
-macro_rules! totalord_impl(
-    ($t:ty) => {
-        impl TotalOrd for $t {
-            #[inline(always)]
-            fn cmp(&self, other: &$t) -> Ordering {
-                if *self < *other { Less }
-                else if *self > *other { Greater }
-                else { Equal }
-            }
-        }
-    }
-)
+impl TotalOrd for i32 {
+    #[inline(always)]
+    fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(u8)
-totalord_impl!(u16)
-totalord_impl!(u32)
-totalord_impl!(u64)
+impl TotalOrd for i64 {
+    #[inline(always)]
+    fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(i8)
-totalord_impl!(i16)
-totalord_impl!(i32)
-totalord_impl!(i64)
+impl TotalOrd for int {
+    #[inline(always)]
+    fn cmp(&self, other: &int) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(int)
-totalord_impl!(uint)
+impl TotalOrd for uint {
+    #[inline(always)]
+    fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) }
+}
 
 /**
 * Trait for values that can be compared for a sort-order.
@@ -167,17 +171,11 @@ pub fn max<T:Ord>(v1: T, v2: T) -> T {
 #[cfg(test)]
 mod test {
     #[test]
-    fn test_int_totalord() {
+    fn test_int() {
         assert_eq!(5.cmp(&10), Less);
         assert_eq!(10.cmp(&5), Greater);
         assert_eq!(5.cmp(&5), Equal);
         assert_eq!((-5).cmp(&12), Less);
         assert_eq!(12.cmp(-5), Greater);
     }
-
-    #[test]
-    fn test_int_totaleq() {
-        fail_unless!(5.equals(&5));
-        fail_unless!(!2.equals(&17));
-    }
 }

branches/try2/src/libcore/hashmap.rs

@@ -8,10 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! An unordered map and set type implemented as hash tables
-//!
-//! The tables use a keyed hash with new random keys generated for each container, so the ordering
-//! of a set of keys in a hash table is randomized.
+//! Sendable hash maps.
 
 /// Open addressing with linear probing.
 pub mod linear {

branches/try2/src/libcore/nil.rs

@@ -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.
 //
@@ -15,7 +15,7 @@ Functions for the unit type.
 */
 
 #[cfg(notest)]
-use prelude::*;
+use cmp::{Eq, Ord, TotalOrd, Ordering, Equal};
 
 #[cfg(notest)]
 impl Eq for () {
@@ -42,9 +42,3 @@ impl TotalOrd for () {
     #[inline(always)]
     fn cmp(&self, _other: &()) -> Ordering { Equal }
 }
-
-#[cfg(notest)]
-impl TotalEq for () {
-    #[inline(always)]
-    fn equals(&self, _other: &()) -> bool { true }
-}

branches/try2/src/libcore/ops.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Traits for the built-in operators
+// Core operators
 
 #[lang="drop"]
 pub trait Drop {

branches/try2/src/libcore/prelude.rs

@@ -24,7 +24,7 @@ pub use result::{Result, Ok, Err};
 /* Reexported types and traits */
 
 pub use clone::Clone;
-pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+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, MutableIter, ExtendedIter, EqIter};

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

@@ -126,7 +126,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp:
 type Registers = [uint, ..22];
 
 #[cfg(target_arch = "x86_64")]
-fn new_regs() -> ~Registers { ~([0, .. 22]) }
+fn new_regs() -> ~Registers { ~[0, .. 22] }
 
 #[cfg(target_arch = "x86_64")]
 fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {

branches/try2/src/libcore/stackwalk.rs

@@ -80,7 +80,7 @@ fn breakpoint() {
     }
 }
 
-fn frame_address(f: &fn(x: *u8)) {
+fn frame_address(f: &fn(++x: *u8)) {
     unsafe {
         rusti::frame_address(f)
     }
@@ -95,7 +95,7 @@ pub mod rustrt {
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     pub extern {
-        pub fn frame_address(f: &once fn(x: *u8));
+        pub fn frame_address(f: &once fn(++x: *u8));
     }
 }
 

branches/try2/src/libcore/str.rs

@@ -21,7 +21,7 @@ use at_vec;
 use cast;
 use char;
 use clone::Clone;
-use cmp::{Equiv, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
 use ptr;
@@ -930,30 +930,6 @@ impl Eq for @str {
     fn ne(&self, other: &@str) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(notest)]
-impl<'self> TotalEq for &'self str {
-    #[inline(always)]
-    fn equals(&self, other: & &'self str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
-#[cfg(notest)]
-impl TotalEq for ~str {
-    #[inline(always)]
-    fn equals(&self, other: &~str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
-#[cfg(notest)]
-impl TotalEq for @str {
-    #[inline(always)]
-    fn equals(&self, other: &@str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
 #[cfg(notest)]
 impl Ord for ~str {
     #[inline(always)]