---

yaml
---
r: 104539
b: refs/heads/try
c: 9cc26cf
h: refs/heads/master
i:
  104537: 5455d21
  104535: 70f5b7c
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: fd83b2be2643152ecbba88400985609c4633a184
+refs/heads/try: 9cc26cfdf43adffe51acdc5ef9886cb5e1844d46
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/index.md

@@ -43,7 +43,6 @@ li {list-style-type: none; }
 * [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 * [The `syntax` library, the Rust parser](syntax/index.html)
 * [The `term` terminal-handling library](term/index.html)
-* [The `test` library](test/index.html)
 * [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
 
 # Tooling

branches/try/src/libgreen/sched.rs

@@ -1394,8 +1394,6 @@ mod test {
         });
     }
 
-    // FIXME: #9407: ignore-test
-    #[ignore]
     #[test]
     fn dont_starve_1() {
         let mut pool = SchedPool::new(PoolConfig {

branches/try/src/libstd/rt/crate_map.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use cast;
 use cmp::TotalOrd;
 use container::MutableSet;
 use iter::Iterator;
@@ -36,61 +35,27 @@ pub struct CrateMap<'a> {
     event_loop_factory: Option<fn() -> ~EventLoop>,
 }
 
-// When working on android, apparently weak symbols don't work so well for
-// finding the crate map, and neither does dlopen + dlsym. This is mainly a
-// problem when integrating a shared library with an existing application.
-// Standalone binaries do not appear to have this problem. The reasons are a
-// little mysterious, and more information can be found in #11731.
-//
-// For now we provide a way to tell libstd about the crate map manually that's
-// checked before the normal weak symbol/dlopen paths. In theory this is useful
-// on other platforms where our dlopen/weak linkage strategy mysteriously fails
-// but the crate map can be specified manually.
-static mut MANUALLY_PROVIDED_CRATE_MAP: *CrateMap<'static> =
-                                                    0 as *CrateMap<'static>;
-#[no_mangle]
-#[cfg(not(test))]
-pub extern fn rust_set_crate_map(map: *CrateMap<'static>) {
-    unsafe { MANUALLY_PROVIDED_CRATE_MAP = map; }
-}
-
-fn manual_crate_map() -> Option<&'static CrateMap<'static>> {
-    unsafe {
-        if MANUALLY_PROVIDED_CRATE_MAP.is_null() {
-            None
-        } else {
-            Some(cast::transmute(MANUALLY_PROVIDED_CRATE_MAP))
-        }
-    }
-}
-
 #[cfg(not(windows))]
 pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
     extern {
         #[crate_map]
         static CRATE_MAP: CrateMap<'static>;
     }
 
-    manual_crate_map().or_else(|| {
-        let ptr: (*CrateMap) = &'static CRATE_MAP;
-        if ptr.is_null() {
-            None
-        } else {
-            Some(&'static CRATE_MAP)
-        }
-    })
+    let ptr: (*CrateMap) = &'static CRATE_MAP;
+    if ptr.is_null() {
+        return None;
+    } else {
+        return Some(&'static CRATE_MAP);
+    }
 }
 
 #[cfg(windows)]
 pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
+    use cast::transmute;
     use c_str::ToCStr;
     use unstable::dynamic_lib::dl;
 
-    match manual_crate_map() {
-        Some(cm) => return Some(cm),
-        None => {}
-    }
-
     let sym = unsafe {
         let module = dl::open_internal();
         let rust_crate_map_toplevel = if cfg!(target_arch = "x86") {
@@ -109,7 +74,7 @@ pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
         return None;
     } else {
         unsafe {
-            return Some(cast::transmute(sym));
+            return Some(transmute(sym));
         }
     }
 }

branches/try/src/test/auxiliary/private_variant_1.rs

@@ -10,6 +10,6 @@
 
 mod super_sekrit {
     pub enum sooper_sekrit {
-        pub quux, priv baz
+        quux, priv baz
     }
 }

branches/try/src/test/bench/shootout-fannkuch-redux.rs

@@ -8,11 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-test reading from os::args()[1] - bogus!
-
-use std::from_str::FromStr;
 use std::os;
-use std::vec::MutableVector;
 use std::vec;
 
 fn max(a: i32, b: i32) -> i32 {
@@ -23,7 +19,6 @@ fn max(a: i32, b: i32) -> i32 {
     }
 }
 
-#[inline(never)]
 fn fannkuch_redux(n: i32) -> i32 {
     let mut perm = vec::from_elem(n as uint, 0i32);
     let mut perm1 = vec::from_fn(n as uint, |i| i as i32);
@@ -34,74 +29,70 @@ fn fannkuch_redux(n: i32) -> i32 {
 
     let mut r = n;
     loop {
-        unsafe {
-            while r != 1 {
-                count.unsafe_set((r-1) as uint, r);
-                r -= 1;
-            }
-
-            for (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
-                *perm_i = *perm1_i;
-            }
+        while r != 1 {
+            count[r - 1] = r;
+            r -= 1;
+        }
 
-            let mut flips_count: i32 = 0;
-            let mut k: i32;
-            loop {
-                k = *perm.unsafe_ref(0);
-                if k == 0 {
-                    break;
-                }
+        for (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
+            *perm_i = *perm1_i;
+        }
 
-                let k2 = (k+1) >> 1;
-                for i in range(0i32, k2) {
-                    let (perm_i, perm_k_i) = {
-                        (*perm.unsafe_ref(i as uint),
-                            *perm.unsafe_ref((k-i) as uint))
-                    };
-                    perm.unsafe_set(i as uint, perm_k_i);
-                    perm.unsafe_set((k-i) as uint, perm_i);
-                }
-                flips_count += 1;
+        let mut flips_count: i32 = 0;
+        let mut k: i32;
+        loop {
+            k = perm[0];
+            if k == 0 {
+                break;
             }
 
-            max_flips_count = max(max_flips_count, flips_count);
-            checksum += if perm_count % 2 == 0 {
-                flips_count
-            } else {
-                -flips_count
-            };
+            let k2 = (k+1) >> 1;
+            for i in range(0i32, k2) {
+                perm.swap(i as uint, (k - i) as uint);
+            }
+            flips_count += 1;
+        }
 
-            // Use incremental change to generate another permutation.
-            loop {
-                if r == n {
-                    println!("{}", checksum);
-                    return max_flips_count;
-                }
+        max_flips_count = max(max_flips_count, flips_count);
+        checksum += if perm_count % 2 == 0 {
+            flips_count
+        } else {
+            -flips_count
+        };
 
-                let perm0 = perm1[0];
-                let mut i: i32 = 0;
-                while i < r {
-                    let j = i + 1;
-                    let perm1_j = { *perm1.unsafe_ref(j as uint) };
-                    perm1.unsafe_set(i as uint, perm1_j);
-                    i = j;
-                }
-                perm1.unsafe_set(r as uint, perm0);
+        // Use incremental change to generate another permutation.
+        loop {
+            if r == n {
+                println!("{}", checksum);
+                return max_flips_count;
+            }
 
-                let count_r = { *count.unsafe_ref(r as uint) };
-                count.unsafe_set(r as uint, count_r - 1);
-                if *count.unsafe_ref(r as uint) > 0 {
-                    break;
-                }
-                r += 1;
+            let perm0 = perm1[0];
+            let mut i: i32 = 0;
+            while i < r {
+                let j = i + 1;
+                perm1[i] = perm1[j];
+                i = j;
             }
+            perm1[r] = perm0;
 
-            perm_count += 1;
+            count[r] -= 1;
+            if count[r] > 0 {
+                break;
+            }
+            r += 1;
         }
+
+        perm_count += 1;
     }
 }
 
 fn main() {
-    let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
+    let args = os::args();
+    let n = if args.len() > 1 {
+        from_str::<i32>(args[1]).unwrap()
+    } else {
+        2
+    };
     println!("Pfannkuchen({}) = {}", n as int, fannkuch_redux(n) as int);
 }