---

yaml
---
r: 140750
b: refs/heads/try2
c: a9f2132
h: refs/heads/master
v: v3

Author: Thiez

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

branches/try2/doc/rust.md

@@ -1425,8 +1425,6 @@ names are effectively reserved. Some significant attributes include:
 * The `test` attribute, for marking functions as unit tests.
 * The `allow`, `warn`, `forbid`, and `deny` attributes, for controlling lint checks. Lint checks supported
 by the compiler can be found via `rustc -W help`.
-* The `deriving` attribute, for automatically generating
-  implementations of certain traits.
 
 Other attributes may be added or removed during development of the language.
 
@@ -1528,47 +1526,6 @@ A complete list of the built-in language items follows:
 > **Note:** This list is likely to become out of date. We should auto-generate it
 > from `librustc/middle/lang_items.rs`.
 
-### Deriving
-
-The `deriving` attribute allows certain traits to be automatically
-implemented for data structures. For example, the following will
-create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type
-parameter `T` will be given the `Eq` or `Clone` constraints for the
-appropriate `impl`:
-
-~~~
-#[deriving(Eq, Clone)]
-struct Foo<T> {
-    a: int,
-    b: T
-}
-~~~
-
-The generated `impl` for `Eq` is equivalent to
-
-~~~
-# struct Foo<T> { a: int, b: T }
-impl<T: Eq> Eq for Foo<T> {
-    fn eq(&self, other: &Foo<T>) -> bool {
-        self.a == other.a && self.b == other.b
-    }
-
-    fn ne(&self, other: &Foo<T>) -> bool {
-        self.a != other.a || self.b != other.b
-    }
-}
-~~~
-
-Supported traits for `deriving` are:
-
-* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
-* Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone`, to perform deep copies.
-* `IterBytes`, to iterate over the bytes in a data type.
-* `Rand`, to create a random instance of a data type.
-* `ToStr`, to convert to a string. For a type with this instance,
-  `obj.to_str()` has the same output as `fmt!("%?", obj)`.
-
 # Statements and expressions
 
 Rust is _primarily_ an expression language. This means that most forms of

branches/try2/doc/tutorial.md

@@ -2290,27 +2290,6 @@ let nonsense = mycircle.radius() * mycircle.area();
 
 > ***Note:*** Trait inheritance does not actually work with objects yet
 
-## Deriving implementations for traits
-
-A small number of traits in `core` and `std` can have implementations
-that can be automatically derived. These instances are specified by
-placing the `deriving` attribute on a data type declaration. For
-example, the following will mean that `Circle` has an implementation
-for `Eq` and can be used with the equality operators, and that a value
-of type `ABC` can be randomly generated and converted to a string:
-
-~~~
-#[deriving(Eq)]
-struct Circle { radius: float }
-
-#[deriving(Rand, ToStr)]
-enum ABC { A, B, C }
-~~~
-
-The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
-`ToStr`.
-
 # Modules and crates
 
 The Rust namespace is arranged in a hierarchy of modules. Each source

branches/try2/src/driver/driver.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[no_core];
+extern mod core(vers = "0.7-pre");
+
 #[cfg(rustpkg)]
 extern mod this(name = "rustpkg", vers = "0.7-pre");
 

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

@@ -578,7 +578,10 @@ impl Float for f32 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN
     #[inline(always)]
     fn is_normal(&self) -> bool {
-        self.classify() == FPNormal
+        match self.classify() {
+            FPNormal => true,
+            _ => false,
+        }
     }
 
     /// Returns the floating point category of the number. If only one property is going to
@@ -588,14 +591,14 @@ impl Float for f32 {
         static MAN_MASK: u32 = 0x007fffff;
 
         match (
-            unsafe { ::cast::transmute::<f32,u32>(*self) } & MAN_MASK,
             unsafe { ::cast::transmute::<f32,u32>(*self) } & EXP_MASK,
+            unsafe { ::cast::transmute::<f32,u32>(*self) } & MAN_MASK
         ) {
-            (0, 0)        => FPZero,
-            (_, 0)        => FPSubnormal,
-            (0, EXP_MASK) => FPInfinite,
-            (_, EXP_MASK) => FPNaN,
-            _             => FPNormal,
+            (EXP_MASK, 0)        => FPInfinite,
+            (EXP_MASK, _)        => FPNaN,
+            (exp, _) if exp != 0 => FPNormal,
+            _ if self.is_zero()  => FPZero,
+            _                    => FPSubnormal,
         }
     }
 

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

@@ -621,7 +621,10 @@ impl Float for f64 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN
     #[inline(always)]
     fn is_normal(&self) -> bool {
-        self.classify() == FPNormal
+        match self.classify() {
+            FPNormal => true,
+            _ => false,
+        }
     }
 
     /// Returns the floating point category of the number. If only one property is going to
@@ -631,14 +634,14 @@ impl Float for f64 {
         static MAN_MASK: u64 = 0x000fffffffffffff;
 
         match (
-            unsafe { ::cast::transmute::<f64,u64>(*self) } & MAN_MASK,
             unsafe { ::cast::transmute::<f64,u64>(*self) } & EXP_MASK,
+            unsafe { ::cast::transmute::<f64,u64>(*self) } & MAN_MASK
         ) {
-            (0, 0)        => FPZero,
-            (_, 0)        => FPSubnormal,
-            (0, EXP_MASK) => FPInfinite,
-            (_, EXP_MASK) => FPNaN,
-            _             => FPNormal,
+            (EXP_MASK, 0)        => FPInfinite,
+            (EXP_MASK, _)        => FPNaN,
+            (exp, _) if exp != 0 => FPNormal,
+            _ if self.is_zero()  => FPZero,
+            _                    => FPSubnormal,
         }
     }
 

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -19,6 +19,16 @@ pub extern "rust-intrinsic" {
     pub fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
     pub fn atomic_cxchg_acq(dst: &mut int, old: int, src: int) -> int;
     pub fn atomic_cxchg_rel(dst: &mut int, old: int, src: int) -> int;
+    
+    #[cfg(not(stage0))]
+    pub fn atomic_load(src: &int) -> int;
+    #[cfg(not(stage0))]
+    pub fn atomic_load_acq(src: &int) -> int;
+    
+    #[cfg(not(stage0))]
+    pub fn atomic_store(dst: &mut int, val: int);
+    #[cfg(not(stage0))]
+    pub fn atomic_store_rel(dst: &mut int, val: int);
 
     pub fn atomic_xchg(dst: &mut int, src: int) -> int;
     pub fn atomic_xchg_acq(dst: &mut int, src: int) -> int;

branches/try2/src/libcore/util.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.
 //
@@ -132,20 +132,6 @@ impl Drop for NonCopyable {
 
 pub fn NonCopyable() -> NonCopyable { NonCopyable { i: () } }
 
-
-/// A type with no inhabitants
-pub enum Void { }
-
-pub impl Void {
-    /// A utility function for ignoring this uninhabited type
-    fn uninhabited(&self) -> ! {
-        match *self {
-            // Nothing to match on
-        }
-    }
-}
-
-
 /**
 A utility function for indicating unreachable code. It will fail if
 executed. This is occasionally useful to put after loops that never