---

yaml
---
r: 146351
b: refs/heads/try2
c: 96589e7
h: refs/heads/master
i:
  146349: 2d7ce5b
  146347: 0d553eb
  146343: 2c2839d
  146335: ac3e32a
v: v3

Author: telotortium

[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: 04c58c9f81c5d9b6b1847573a41c8b819893a12a
+refs/heads/try2: 96589e7264fae59a04ef47d3e5dc04fdabc9441f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -670,13 +670,6 @@ do
             fi
             ;;
 
-        arm-apple-darwin)
-            if [ $CFG_OSTYPE != apple-darwin ]
-            then
-                err "The iOS target is only supported on Mac OS X"
-            fi
-            ;;
-
         *)
             ;;
     esac

branches/try2/doc/rust.md

@@ -568,7 +568,6 @@ This requirement most often affects name-designator pairs when they occur at the
 * `log_syntax!` : print out the arguments at compile time
 * `trace_macros!` : supply `true` or `false` to enable or disable macro expansion logging
 * `stringify!` : turn the identifier argument into a string literal
-* `concat!` : concatenates a comma-separated list of literals
 * `concat_idents!` : create a new identifier by concatenating the arguments
 
 # Crates and source files

branches/try2/mk/platform.mk

@@ -193,35 +193,6 @@ CFG_LDPATH_i686-unknown-linux-gnu :=
 CFG_RUN_i686-unknown-linux-gnu=$(2)
 CFG_RUN_TARG_i686-unknown-linux-gnu=$(call CFG_RUN_i686-unknown-linux-gnu,,$(2))
 
-# arm-apple-darwin configuration
-ifeq ($(CFG_OSTYPE),apple-darwin)
-CFG_IOS_SDK = $(shell xcrun --show-sdk-path -sdk iphoneos)
-CFG_IOS_FLAGS = -target arm-apple-darwin -isysroot $(CFG_IOS_SDK) -I $(CFG_IOS_SDK)/usr/include -I $(CFG_IOS_SDK)/usr/include/c++/4.2.1 -I /usr/include
-CC_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang)
-CXX_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang++)
-CPP_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang++)
-AR_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos ar)
-CFG_LIB_NAME_arm-apple-darwin = lib$(1).dylib
-CFG_LIB_GLOB_arm-apple-darwin = lib$(1)-*.dylib
-CFG_LIB_DSYM_GLOB_arm-apple-darwin = lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_arm-apple-darwin := -Wall -Werror -g -fPIC $(CFG_IOS_FLAGS)
-CFG_GCCISH_CXXFLAGS_arm-apple-darwin := -fno-rtti $(CFG_IOS_FLAGS)
-CFG_GCCISH_LINK_FLAGS_arm-apple-darwin := -dynamiclib -lpthread -framework CoreServices -Wl,-no_compact_unwind 
-CFG_GCCISH_DEF_FLAG_arm-apple-darwin := -Wl,-exported_symbols_list,
-CFG_GCCISH_PRE_LIB_FLAGS_arm-apple-darwin :=
-CFG_GCCISH_POST_LIB_FLAGS_arm-apple-darwin :=
-CFG_DEF_SUFFIX_arm-apple-darwin := .darwin.def
-CFG_INSTALL_NAME_arm-apple-darwin = -Wl,-install_name,@rpath/$(1)
-CFG_LIBUV_LINK_FLAGS_arm-apple-darwin =
-CFG_EXE_SUFFIX_arm-apple-darwin :=
-CFG_WINDOWSY_arm-apple-darwin :=
-CFG_UNIXY_arm-apple-darwin := 1
-CFG_PATH_MUNGE_arm-apple-darwin := true
-CFG_LDPATH_arm-apple-darwin :=
-CFG_RUN_arm-apple-darwin = $(2)
-CFG_RUN_TARG_arm-apple-darwin = $(call CFG_RUN_arm-apple-darwin,,$(2))
-endif
-
 # x86_64-apple-darwin configuration
 CC_x86_64-apple-darwin=$(CC)
 CXX_x86_64-apple-darwin=$(CXX)

branches/try2/src/etc/ziggurat_tables.py

@@ -19,7 +19,7 @@
 import random
 
 # The order should match the return value of `tables`
-TABLE_NAMES = ['X', 'F']
+TABLE_NAMES = ['X', 'F', 'F_DIFF']
 
 # The actual length of the table is 1 more, to stop
 # index-out-of-bounds errors. This should match the bitwise operation
@@ -43,10 +43,13 @@ def tables(r, v, f, f_inv):
 
     # cache the f's
     fvec = [0]*(TABLE_LEN+1)
+    fdiff = [0]*(TABLE_LEN+1)
     for i in range(TABLE_LEN+1):
         fvec[i] = f(xvec[i])
+        if i > 0:
+            fdiff[i] = fvec[i] - fvec[i-1]
 
-    return xvec, fvec
+    return xvec, fvec, fdiff
 
 # Distributions
 # N(0, 1)

branches/try2/src/librustc/front/feature_gate.rs

@@ -140,12 +140,12 @@ impl Visitor<()> for Context {
 
             },
             ast::ty_box(_) => {
-                self.gate_feature("managed_boxes", t.span,
-                                  "The managed box syntax will be replaced \
-                                  by a library type, and a garbage \
-                                  collector is not yet implemented. \
-                                  Consider using the `std::rc::Rc` type \
-                                  for reference counted pointers.");
+                self.gate_feature("managed_boxes", t.span, "The managed box syntax may be replaced \
+                                                            by a library type, and a garbage \
+                                                            collector is not yet implemented. \
+                                                            Consider using the `std::rc` module \
+                                                            as it performs much better as a \
+                                                            reference counting implementation.");
             }
             _ => {}
         }

branches/try2/src/librustc/middle/trans/base.rs

@@ -182,8 +182,6 @@ pub fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv, ty: Type)
     };
 
     lib::llvm::SetFunctionCallConv(llfn, cc);
-    // Function addresses in Rust are never significant, allowing functions to be merged.
-    lib::llvm::SetUnnamedAddr(llfn, true);
     return llfn;
 }
 

branches/try2/src/librustc/util/ppaux.rs

@@ -308,11 +308,10 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                       ident: Option<ast::Ident>,
                       sig: &ty::FnSig)
                       -> ~str {
-        let mut s = if abis.is_rust() {
-            ~""
-        } else {
-            format!("extern {} ", abis.to_str())
-        };
+        let mut s = ~"extern ";
+
+        s.push_str(abis.to_str());
+        s.push_char(' ');
 
         match purity {
             ast::impure_fn => {}
@@ -332,16 +331,16 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
           _ => { }
         }
 
-        push_sig_to_str(cx, &mut s, '(', ')', sig);
+        push_sig_to_str(cx, &mut s, sig);
 
         return s;
     }
-    fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str {
+    fn closure_to_str(cx: ctxt, cty: &ty::ClosureTy) -> ~str
+    {
         let is_proc =
             (cty.sigil, cty.onceness) == (ast::OwnedSigil, ast::Once);
-        let is_borrowed_closure = cty.sigil == ast::BorrowedSigil;
 
-        let mut s = if is_proc || is_borrowed_closure {
+        let mut s = if is_proc {
             ~""
         } else {
             cty.sigil.to_str()
@@ -375,42 +374,23 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
                 }
             };
 
-            if !is_borrowed_closure {
-                s.push_str("fn");
-            }
+            s.push_str("fn");
         }
 
-        if !is_borrowed_closure {
-            // Print bounds before `fn` if this is not a borrowed closure.
-            if !cty.bounds.is_empty() {
-                s.push_str(":");
-                s.push_str(cty.bounds.repr(cx));
-            }
-
-            push_sig_to_str(cx, &mut s, '(', ')', &cty.sig);
-        } else {
-            // Print bounds after the signature if this is a borrowed closure.
-            push_sig_to_str(cx, &mut s, '|', '|', &cty.sig);
-
-            if is_borrowed_closure {
-                if !cty.bounds.is_empty() {
-                    s.push_str(":");
-                    s.push_str(cty.bounds.repr(cx));
-                }
-            }
+        if !cty.bounds.is_empty() {
+            s.push_str(":");
         }
+        s.push_str(cty.bounds.repr(cx));
+
+        push_sig_to_str(cx, &mut s, &cty.sig);
 
         return s;
     }
-    fn push_sig_to_str(cx: ctxt,
-                       s: &mut ~str,
-                       bra: char,
-                       ket: char,
-                       sig: &ty::FnSig) {
-        s.push_char(bra);
+    fn push_sig_to_str(cx: ctxt, s: &mut ~str, sig: &ty::FnSig) {
+        s.push_char('(');
         let strs = sig.inputs.map(|a| fn_input_to_str(cx, *a));
         s.push_str(strs.connect(", "));
-        s.push_char(ket);
+        s.push_char(')');
         if ty::get(sig.output).sty != ty_nil {
             s.push_str(" -> ");
             if ty::type_is_bot(sig.output) {

branches/try2/src/libstd/rand/distributions.rs

@@ -207,6 +207,7 @@ fn ziggurat<R:Rng>(rng: &mut R,
                    symmetric: bool,
                    X: ziggurat_tables::ZigTable,
                    F: ziggurat_tables::ZigTable,
+                   F_DIFF: ziggurat_tables::ZigTable,
                    pdf: &'static fn(f64) -> f64,
                    zero_case: &'static fn(&mut R, f64) -> f64) -> f64 {
     static SCALE: f64 = (1u64 << 53) as f64;
@@ -236,7 +237,7 @@ fn ziggurat<R:Rng>(rng: &mut R,
             return zero_case(rng, u);
         }
         // algebraically equivalent to f1 + DRanU()*(f0 - f1) < 1
-        if F[i + 1] + (F[i] - F[i + 1]) * rng.gen() < pdf(x) {
+        if F[i + 1] + F_DIFF[i + 1] * rng.gen() < pdf(x) {
             return x;
         }
     }
@@ -287,7 +288,7 @@ impl Rand for StandardNormal {
             rng,
             true, // this is symmetric
             &ziggurat_tables::ZIG_NORM_X,
-            &ziggurat_tables::ZIG_NORM_F,
+            &ziggurat_tables::ZIG_NORM_F, &ziggurat_tables::ZIG_NORM_F_DIFF,
             pdf, zero_case))
     }
 }
@@ -365,7 +366,7 @@ impl Rand for Exp1 {
 
         Exp1(ziggurat(rng, false,
                       &ziggurat_tables::ZIG_EXP_X,
-                      &ziggurat_tables::ZIG_EXP_F,
+                      &ziggurat_tables::ZIG_EXP_F, &ziggurat_tables::ZIG_EXP_F_DIFF,
                       pdf, zero_case))
     }
 }

branches/try2/src/libstd/rand/reseeding.rs

@@ -72,7 +72,7 @@ impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr> {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.reseed_if_necessary();
         self.bytes_generated += dest.len();
-        self.fill_bytes(dest)
+        self.rng.fill_bytes(dest)
     }
 }
 
@@ -201,4 +201,24 @@ mod test {
         let string2 = r.gen_ascii_str(100);
         assert_eq!(string1, string2);
     }
+
+    static fill_bytes_v_len: uint = 13579;
+    #[test]
+    fn test_rng_fill_bytes() {
+        use rand::task_rng;
+        let mut v = ~[0u8, .. fill_bytes_v_len];
+        task_rng().fill_bytes(v);
+
+        // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
+        // recursed.
+        assert_eq!(v.len(), fill_bytes_v_len);
+
+        // To test that `fill_bytes` actually did something, check that the
+        // average of `v` is not 0.
+        let mut sum = 0.0;
+        for &x in v.iter() {
+            sum += x as f64;
+        }
+        assert!(sum / v.len() as f64 != 0.0);
+    }
 }