---

yaml
---
r: 166434
b: refs/heads/batch
c: aa37b6d
h: refs/heads/master
v: v3

Author: brianloveswords

[refs]

@@ -29,5 +29,5 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/issue-18208-method-dispatch-2: 9e1eae4fb9b6527315b4441cf8a0f5ca911d1671
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
-refs/heads/batch: 3f66223ca650a9bdfb3b564e85639ebfe03677c8
+refs/heads/batch: aa37b6dcbb68f6629da2ad8feca7e1af616e6675
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970

branches/batch/mk/cfg/x86_64-unknown-dragonfly.mk

@@ -7,9 +7,9 @@ CFG_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-dragonfly=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_x86_64-unknown-dragonfly=$(1)-*.dylib.dSYM
-CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt -m64
+CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt
 CFG_GCCISH_DEF_FLAG_x86_64-unknown-dragonfly := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-no-whole-archive

branches/batch/src/doc/reference.md

@@ -640,7 +640,7 @@ names, and invoked through a consistent syntax: `name!(...)`. Examples include:
 * `stringify!` : pretty-print the Rust expression given as an argument
 * `include!` : include the Rust expression in the given file
 * `include_str!` : include the contents of the given file as a string
-* `include_bytes!` : include the contents of the given file as a binary blob
+* `include_bin!` : include the contents of the given file as a binary blob
 * `error!`, `warn!`, `info!`, `debug!` : provide diagnostic information.
 
 All of the above extensions are expressions with values.

branches/batch/src/etc/snapshot.py

@@ -37,7 +37,6 @@ def scrub(b):
     "macos": ["bin/rustc"],
     "winnt": ["bin/rustc.exe"],
     "freebsd": ["bin/rustc"],
-    "dragonfly": ["bin/rustc"],
     }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll",
@@ -87,8 +86,6 @@ def get_kernel(triple):
         return "macos"
     if os_name == "freebsd":
         return "freebsd"
-    if os_name == "dragonfly":
-        return "dragonfly"
     return "linux"
 
 def get_cpu(triple):

branches/batch/src/libcore/fmt/float.rs

@@ -18,8 +18,8 @@ use char;
 use char::Char;
 use fmt;
 use iter::{range, DoubleEndedIteratorExt};
-use num::{cast, Float, ToPrimitive};
-use num::FpCategory as Fp;
+use num::{Float, FPNaN, FPInfinite, ToPrimitive};
+use num::cast;
 use ops::FnOnce;
 use result::Result::Ok;
 use slice::{mod, SliceExt};
@@ -109,11 +109,11 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     let _1: T = Float::one();
 
     match num.classify() {
-        Fp::Nan => return f("NaN".as_bytes()),
-        Fp::Infinite if num > _0 => {
+        FPNaN => return f("NaN".as_bytes()),
+        FPInfinite if num > _0 => {
             return f("inf".as_bytes());
         }
-        Fp::Infinite if num < _0 => {
+        FPInfinite if num < _0 => {
             return f("-inf".as_bytes());
         }
         _ => {}

branches/batch/src/libcore/iter.rs

@@ -2542,64 +2542,6 @@ impl<A: Int> Iterator<A> for RangeStepInclusive<A> {
     }
 }
 
-
-/// The `Step` trait identifies objects which can be stepped over in both
-/// directions. The `steps_between` function provides a way to
-/// compare two Step objects (it could be provided using `step()` and `Ord`,
-/// but the implementation would be so inefficient as to be useless).
-#[unstable = "Trait is unstable."]
-pub trait Step: Ord {
-    /// Change self to the next object.
-    fn step(&mut self);
-    /// Change self to the previous object.
-    fn step_back(&mut self);
-    /// The steps_between two step objects.
-    /// a should always be less than b, so the result should never be negative.
-    /// Return None if it is not possible to calculate steps_between without
-    /// overflow.
-    fn steps_between(a: &Self, b: &Self) -> Option<uint>;
-}
-
-macro_rules! step_impl {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(a: &$t, b: &$t) -> Option<uint> {
-                debug_assert!(a < b);
-                Some((*a - *b) as uint)
-            }
-        }
-    )*)
-}
-
-macro_rules! step_impl_no_between {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(_a: &$t, _b: &$t) -> Option<uint> {
-                None
-            }
-        }
-    )*)
-}
-
-step_impl!(uint u8 u16 u32 int i8 i16 i32);
-#[cfg(target_word_size = "64")]
-step_impl!(u64 i64);
-#[cfg(target_word_size = "32")]
-step_impl_no_between!(u64 i64);
-
-
 /// An iterator that repeats an element endlessly
 #[deriving(Clone)]
 #[stable]

branches/batch/src/libcore/lib.rs

@@ -59,7 +59,7 @@
 #![allow(unknown_features, raw_pointer_deriving)]
 #![feature(globs, intrinsics, lang_items, macro_rules, phase)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
-#![feature(default_type_params, unboxed_closures, associated_types)]
+#![feature(default_type_params, unboxed_closures)]
 #![deny(missing_docs)]
 
 mod macros;

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

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -157,23 +156,23 @@ impl Float for f32 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u32 = 0x7f800000;
         const MAN_MASK: u32 = 0x007fffff;
 
         let bits: u32 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

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

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -165,23 +164,23 @@ impl Float for f64 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u64 = 0x7ff0000000000000;
         const MAN_MASK: u64 = 0x000fffffffffffff;
 
         let bits: u64 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

branches/batch/src/libcore/num/mod.rs

@@ -15,6 +15,8 @@
 #![stable]
 #![allow(missing_docs)]
 
+pub use self::FPCategory::*;
+
 use {int, i8, i16, i32, i64};
 use {uint, u8, u16, u32, u64};
 use {f32, f64};
@@ -1220,17 +1222,17 @@ impl_num_cast! { f64,   to_f64 }
 /// Used for representing the classification of floating point numbers
 #[deriving(Copy, PartialEq, Show)]
 #[unstable = "may be renamed"]
-pub enum FpCategory {
+pub enum FPCategory {
     /// "Not a Number", often obtained by dividing by zero
-    Nan,
+    FPNaN,
     /// Positive or negative infinity
-    Infinite ,
+    FPInfinite ,
     /// Positive or negative zero
-    Zero,
-    /// De-normalized floating point representation (less precise than `Normal`)
-    Subnormal,
+    FPZero,
+    /// De-normalized floating point representation (less precise than `FPNormal`)
+    FPSubnormal,
     /// A regular floating point number
-    Normal,
+    FPNormal,
 }
 
 /// A built-in floating point number.
@@ -1275,7 +1277,7 @@ pub trait Float
     /// Returns true if this number is neither zero, infinite, denormal, or NaN.
     fn is_normal(self) -> bool;
     /// Returns the category that this number falls into.
-    fn classify(self) -> FpCategory;
+    fn classify(self) -> FPCategory;
 
     // FIXME (#5527): These should be associated constants
 

branches/batch/src/libcore/ops.rs

@@ -51,10 +51,7 @@
 //! See the documentation for each trait for a minimum implementation that prints
 //! something to the screen.
 
-use clone::Clone;
-use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
 use kinds::Sized;
-use option::Option::{mod, Some, None};
 
 /// The `Drop` trait is used to run some code when a value goes out of scope. This
 /// is sometimes called a 'destructor'.
@@ -836,79 +833,6 @@ pub trait SliceMut<Sized? Idx, Sized? Result> for Sized? {
     fn slice_or_fail_mut<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
 }
 
-
-/// An unbounded range.
-#[deriving(Copy)]
-#[lang="full_range"]
-pub struct FullRange;
-
-/// A (half-open) range which is bounded at both ends.
-#[deriving(Copy)]
-#[lang="range"]
-pub struct Range<Idx> {
-    /// The lower bound of the range (inclusive).
-    pub start: Idx,
-    /// The upper bound of the range (exclusive).
-    pub end: Idx,
-}
-
-// FIXME(#19391) needs a snapshot
-//impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
-impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
-    #[inline]
-    fn next(&mut self) -> Option<Idx> {
-        if self.start < self.end {
-            let result = self.start.clone();
-            self.start.step();
-            return Some(result);
-        }
-
-        return None;
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if let Some(hint) = Step::steps_between(&self.end, &self.start) {
-            (hint, Some(hint))
-        } else {
-            (0, None)
-        }
-    }
-}
-
-impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
-    #[inline]
-    fn next_back(&mut self) -> Option<Idx> {
-        if self.start < self.end {
-            self.end.step_back();
-            return Some(self.end.clone());
-        }
-
-        return None;
-    }
-}
-
-impl<Idx: Clone + Step> ExactSizeIterator<Idx> for Range<Idx> {}
-
-/// A range which is only bounded below.
-#[deriving(Copy)]
-#[lang="range_from"]
-pub struct RangeFrom<Idx> {
-    /// The lower bound of the range (inclusive).
-    pub start: Idx,
-}
-
-impl<Idx: Clone + Step> Iterator<Idx> for RangeFrom<Idx> {
-    #[inline]
-    fn next(&mut self) -> Option<Idx> {
-        // Deliberately overflow so we loop forever.
-        let result = self.start.clone();
-        self.start.step();
-        return Some(result);
-    }
-}
-
-
 /// The `Deref` trait is used to specify the functionality of dereferencing
 /// operations like `*v`.
 ///