---

yaml
---
r: 234775
b: refs/heads/tmp
c: 85b8b44
h: refs/heads/master
i:
  234773: 1f56749
  234771: e1db17d
  234767: 48ea36d
v: v3

Author: apasel422

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 0418a43fa3ce430d18e87c66afb2185395f354d6
+refs/heads/tmp: 85b8b447fa3c6fc4aa2e7d957ac15357d0cb3861
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/mk/platform.mk

@@ -208,14 +208,6 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On OpenBSD, we need to pass the path of libstdc++.so to the linker
-  # (use path of libstdc++.a which is a known name for the same path)
-  ifeq ($(OSTYPE_$(1)),unknown-openbsd)
-    RUSTC_FLAGS_$(1)=-L "$$(dir $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-        -print-file-name=lib$(CFG_STDCPP_NAME).a))" \
-        $(RUSTC_FLAGS_$(1))
-  endif
-
   # On Bitrig, we need the relocation model to be PIC for everything
   ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
     LLVM_MC_RELOCATION_MODEL="pic"

branches/tmp/src/doc/trpl/error-handling.md

@@ -154,7 +154,7 @@ fn find(haystack: &str, needle: char) -> Option<usize> {
 }
 ```
 
-Notice that when this function finds a matching character, it doesn't just
+Notice that when this function finds a matching character, it doen't just
 return the `offset`. Instead, it returns `Some(offset)`. `Some` is a variant or
 a *value constructor* for the `Option` type. You can think of it as a function
 with the type `fn<T>(value: T) -> Option<T>`. Correspondingly, `None` is also a
@@ -840,7 +840,7 @@ example, the very last call to `map` multiplies the `Ok(...)` value (which is
 an `i32`) by `2`. If an error had occurred before that point, this operation
 would have been skipped because of how `map` is defined.
 
-`map_err` is the trick that makes all of this work. `map_err` is just like
+`map_err` is the trick the makes all of this work. `map_err` is just like
 `map`, except it applies a function to the `Err(...)` value of a `Result`. In
 this case, we want to convert all of our errors to one type: `String`. Since
 both `io::Error` and `num::ParseIntError` implement `ToString`, we can call the

branches/tmp/src/libcore/num/dec2flt/algorithm.rs

@@ -10,13 +10,13 @@
 
 //! The various algorithms from the paper.
 
+use num::flt2dec::strategy::grisu::Fp;
 use prelude::v1::*;
 use cmp::min;
 use cmp::Ordering::{Less, Equal, Greater};
-use num::diy_float::Fp;
-use num::dec2flt::table;
-use num::dec2flt::rawfp::{self, Unpacked, RawFloat, fp_to_float, next_float, prev_float};
-use num::dec2flt::num::{self, Big};
+use super::table;
+use super::rawfp::{self, Unpacked, RawFloat, fp_to_float, next_float, prev_float};
+use super::num::{self, Big};
 
 /// Number of significand bits in Fp
 const P: u32 = 64;

branches/tmp/src/libcore/num/dec2flt/mod.rs

@@ -86,6 +86,9 @@
 //! "such that the exponent +/- the number of decimal digits fits into a 64 bit integer".
 //! Larger exponents are accepted, but we don't do arithmetic with them, they are immediately
 //! turned into {positive,negative} {zero,infinity}.
+//!
+//! FIXME: this uses several things from core::num::flt2dec, which is nonsense. Those things
+//! should be moved into core::num::<something else>.
 
 #![doc(hidden)]
 #![unstable(feature = "dec2flt",

branches/tmp/src/libcore/num/dec2flt/num.rs

@@ -14,8 +14,9 @@
 
 use prelude::v1::*;
 use cmp::Ordering::{self, Less, Equal, Greater};
+use num::flt2dec::bignum::Big32x40;
 
-pub use num::bignum::Big32x40 as Big;
+pub type Big = Big32x40;
 
 /// Test whether truncating all bits less significant than `ones_place` introduces
 /// a relative error less, equal, or greater than 0.5 ULP.

branches/tmp/src/libcore/num/dec2flt/rawfp.rs

@@ -33,10 +33,10 @@ use cmp::Ordering::{Less, Equal, Greater};
 use ops::{Mul, Div, Neg};
 use fmt::{Debug, LowerExp};
 use mem::transmute;
-use num::diy_float::Fp;
+use num::flt2dec::strategy::grisu::Fp;
 use num::FpCategory::{Infinite, Zero, Subnormal, Normal, Nan};
 use num::Float;
-use num::dec2flt::num::{self, Big};
+use super::num::{self, Big};
 
 #[derive(Copy, Clone, Debug)]
 pub struct Unpacked {

branches/tmp/src/libcore/num/diy_float.rs

@@ -19,12 +19,6 @@
 //! inputs, but we don't do so to avoid the code bloat. Each bignum is still
 //! tracked for the actual usages, so it normally doesn't matter.
 
-// This module is only for dec2flt and flt2dec, and only public because of libcoretest.
-// It is not intended to ever be stabilized.
-#![doc(hidden)]
-#![unstable(feature = "core_private_bignum",
-            reason = "internal routines only exposed for testing",
-            issue = "0")]
 #![macro_use]
 
 use prelude::v1::*;
@@ -200,7 +194,7 @@ macro_rules! define_bignum {
             /// Adds `other` to itself and returns its own mutable reference.
             pub fn add<'a>(&'a mut self, other: &$name) -> &'a mut $name {
                 use cmp;
-                use num::bignum::FullOps;
+                use num::flt2dec::bignum::FullOps;
 
                 let mut sz = cmp::max(self.size, other.size);
                 let mut carry = false;
@@ -218,7 +212,7 @@ macro_rules! define_bignum {
             }
 
             pub fn add_small(&mut self, other: $ty) -> &mut $name {
-                use num::bignum::FullOps;
+                use num::flt2dec::bignum::FullOps;
 
                 let (mut carry, v) = self.base[0].full_add(other, false);
                 self.base[0] = v;
@@ -238,7 +232,7 @@ macro_rules! define_bignum {
             /// Subtracts `other` from itself and returns its own mutable reference.
             pub fn sub<'a>(&'a mut self, other: &$name) -> &'a mut $name {
                 use cmp;
-                use num::bignum::FullOps;
+                use num::flt2dec::bignum::FullOps;
 
                 let sz = cmp::max(self.size, other.size);
                 let mut noborrow = true;
@@ -255,7 +249,7 @@ macro_rules! define_bignum {
             /// Multiplies itself by a digit-sized `other` and returns its own
             /// mutable reference.
             pub fn mul_small(&mut self, other: $ty) -> &mut $name {
-                use num::bignum::FullOps;
+                use num::flt2dec::bignum::FullOps;
 
                 let mut sz = self.size;
                 let mut carry = 0;
@@ -316,7 +310,7 @@ macro_rules! define_bignum {
             /// Multiplies itself by `5^e` and returns its own mutable reference.
             pub fn mul_pow5(&mut self, mut e: usize) -> &mut $name {
                 use mem;
-                use num::bignum::SMALL_POW5;
+                use num::flt2dec::bignum::SMALL_POW5;
 
                 // There are exactly n trailing zeros on 2^n, and the only relevant digit sizes
                 // are consecutive powers of two, so this is well suited index for the table.
@@ -347,7 +341,7 @@ macro_rules! define_bignum {
             pub fn mul_digits<'a>(&'a mut self, other: &[$ty]) -> &'a mut $name {
                 // the internal routine. works best when aa.len() <= bb.len().
                 fn mul_inner(ret: &mut [$ty; $n], aa: &[$ty], bb: &[$ty]) -> usize {
-                    use num::bignum::FullOps;
+                    use num::flt2dec::bignum::FullOps;
 
                     let mut retsz = 0;
                     for (i, &a) in aa.iter().enumerate() {
@@ -384,7 +378,7 @@ macro_rules! define_bignum {
             /// Divides itself by a digit-sized `other` and returns its own
             /// mutable reference *and* the remainder.
             pub fn div_rem_small(&mut self, other: $ty) -> (&mut $name, $ty) {
-                use num::bignum::FullOps;
+                use num::flt2dec::bignum::FullOps;
 
                 assert!(other > 0);
 

branches/tmp/src/libcore/num/bignum.rs renamed to branches/tmp/src/libcore/num/flt2dec/bignum.rs

@@ -136,6 +136,7 @@ use slice::bytes;
 pub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded};
 
 pub mod estimator;
+pub mod bignum;
 pub mod decoder;
 
 /// Digit-generation algorithms.

branches/tmp/src/libcore/num/flt2dec/mod.rs

@@ -21,8 +21,8 @@ use cmp::Ordering;
 
 use num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up};
 use num::flt2dec::estimator::estimate_scaling_factor;
-use num::bignum::Digit32 as Digit;
-use num::bignum::Big32x40 as Big;
+use num::flt2dec::bignum::Digit32 as Digit;
+use num::flt2dec::bignum::Big32x40 as Big;
 
 static POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000,
                              1000000, 10000000, 100000000, 1000000000];

branches/tmp/src/libcore/num/flt2dec/strategy/dragon.rs

@@ -18,9 +18,60 @@ Rust adaptation of Grisu3 algorithm described in [1]. It uses about
 
 use prelude::v1::*;
 
-use num::diy_float::Fp;
 use num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up};
 
+/// A custom 64-bit floating point type, representing `f * 2^e`.
+#[derive(Copy, Clone, Debug)]
+#[doc(hidden)]
+pub struct Fp {
+    /// The integer mantissa.
+    pub f: u64,
+    /// The exponent in base 2.
+    pub e: i16,
+}
+
+impl Fp {
+    /// Returns a correctly rounded product of itself and `other`.
+    pub fn mul(&self, other: &Fp) -> Fp {
+        const MASK: u64 = 0xffffffff;
+        let a = self.f >> 32;
+        let b = self.f & MASK;
+        let c = other.f >> 32;
+        let d = other.f & MASK;
+        let ac = a * c;
+        let bc = b * c;
+        let ad = a * d;
+        let bd = b * d;
+        let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+        let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+        let e = self.e + other.e + 64;
+        Fp { f: f, e: e }
+    }
+
+    /// Normalizes itself so that the resulting mantissa is at least `2^63`.
+    pub fn normalize(&self) -> Fp {
+        let mut f = self.f;
+        let mut e = self.e;
+        if f >> (64 - 32) == 0 { f <<= 32; e -= 32; }
+        if f >> (64 - 16) == 0 { f <<= 16; e -= 16; }
+        if f >> (64 -  8) == 0 { f <<=  8; e -=  8; }
+        if f >> (64 -  4) == 0 { f <<=  4; e -=  4; }
+        if f >> (64 -  2) == 0 { f <<=  2; e -=  2; }
+        if f >> (64 -  1) == 0 { f <<=  1; e -=  1; }
+        debug_assert!(f >= (1 >> 63));
+        Fp { f: f, e: e }
+    }
+
+    /// Normalizes itself to have the shared exponent.
+    /// It can only decrease the exponent (and thus increase the mantissa).
+    pub fn normalize_to(&self, e: i16) -> Fp {
+        let edelta = self.e - e;
+        assert!(edelta >= 0);
+        let edelta = edelta as usize;
+        assert_eq!(self.f << edelta >> edelta, self.f);
+        Fp { f: self.f << edelta, e: e }
+    }
+}
 
 // see the comments in `format_shortest_opt` for the rationale.
 #[doc(hidden)] pub const ALPHA: i16 = -60;

branches/tmp/src/libcore/num/flt2dec/strategy/grisu.rs

@@ -43,12 +43,8 @@ use slice::SliceExt;
 pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")] pub T);
 
 pub mod wrapping;
-
-// All these modules are technically private and only exposed for libcoretest:
 pub mod flt2dec;
 pub mod dec2flt;
-pub mod bignum;
-pub mod diy_float;
 
 /// Types that have a "zero" value.
 ///

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

@@ -15,8 +15,6 @@
 #![feature(const_fn)]
 #![feature(core)]
 #![feature(core_float)]
-#![feature(core_private_bignum)]
-#![feature(core_private_diy_float)]
 #![feature(dec2flt)]
 #![feature(decode_utf16)]
 #![feature(fixed_size_array)]

branches/tmp/src/libcoretest/lib.rs

@@ -9,14 +9,14 @@
 // except according to those terms.
 
 use std::f64;
-use core::num::diy_float::Fp;
+use core::num::flt2dec::strategy::grisu::Fp;
 use core::num::dec2flt::rawfp::{fp_to_float, prev_float, next_float, round_normal};
 
 #[test]
 fn fp_to_float_half_to_even() {
     fn is_normalized(sig: u64) -> bool {
-        // intentionally written without {min,max}_sig() as a sanity check
-        sig >> 52 == 1 && sig >> 53 == 0
+            // intentionally written without {min,max}_sig() as a sanity check
+            sig >> 52 == 1 && sig >> 53 == 0
     }
 
     fn conv(sig: u64) -> u64 {

branches/tmp/src/libcoretest/num/dec2flt/rawfp.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::prelude::v1::*;
-use core::num::bignum::tests::Big8x3 as Big;
+use core::num::flt2dec::bignum::tests::Big8x3 as Big;
 
 #[test]
 #[should_panic]

branches/tmp/src/libcoretest/num/bignum.rs renamed to branches/tmp/src/libcoretest/num/flt2dec/bignum.rs

@@ -23,6 +23,7 @@ use core::num::flt2dec::{to_shortest_str, to_shortest_exp_str,
 pub use test::Bencher;
 
 mod estimator;
+mod bignum;
 mod strategy {
     mod dragon;
     mod grisu;

branches/tmp/src/libcoretest/num/flt2dec/mod.rs

@@ -12,7 +12,7 @@ use std::prelude::v1::*;
 use std::{i16, f64};
 use super::super::*;
 use core::num::flt2dec::*;
-use core::num::bignum::Big32x40 as Big;
+use core::num::flt2dec::bignum::Big32x40 as Big;
 use core::num::flt2dec::strategy::dragon::*;
 
 #[test]

branches/tmp/src/libcoretest/num/flt2dec/strategy/dragon.rs

@@ -31,7 +31,6 @@ mod u64;
 
 mod flt2dec;
 mod dec2flt;
-mod bignum;
 
 /// Helper function for testing numeric operations
 pub fn test_num<T>(ten: T, two: T) where