---

yaml
---
r: 147415
b: refs/heads/try2
c: 7a1e486
h: refs/heads/master
i:
  147413: a995921
  147411: cd66a27
  147407: a13c583
v: v3

Author: sfackler

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

branches/try2/Makefile.in

@@ -657,6 +657,11 @@ ifneq ($(strip $(findstring snap,$(MAKECMDGOALS))   \
   include $(CFG_SRC_DIR)mk/snap.mk
 endif
 
+ifneq ($(findstring reformat,$(MAKECMDGOALS)),)
+  CFG_INFO := $(info cfg: including reformat rules)
+  include $(CFG_SRC_DIR)mk/pp.mk
+endif
+
 ifneq ($(strip $(findstring check,$(MAKECMDGOALS)) \
                $(findstring test,$(MAKECMDGOALS))  \
                $(findstring perf,$(MAKECMDGOALS))  \

branches/try2/mk/clean.mk

@@ -63,7 +63,6 @@ clean-generic-$(2)-$(1):
          -name '*.[odasS]' -o \
          -name '*.so' -o      \
          -name '*.dylib' -o   \
-         -name '*.lib' -o     \
          -name '*.dll' -o     \
          -name '*.def' -o     \
          -name '*.bc'         \

branches/try2/mk/pp.mk

@@ -0,0 +1,39 @@
+# Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+# Create a way to reformat just some files
+ifdef PPFILES
+  PP_INPUTS_FILTERED := $(wildcard $(PPFILES))
+else
+  PP_INPUTS = $(wildcard $(addprefix $(S)src/libstd/,*.rs */*.rs)) \
+              $(wildcard $(addprefix $(S)src/libextra/,*.rs */*.rs)) \
+              $(wildcard $(addprefix $(S)src/rustc/,*.rs */*.rs */*/*.rs)) \
+              $(wildcard $(S)src/test/*/*.rs    \
+                         $(S)src/test/*/*/*.rs) \
+              $(wildcard $(S)src/rustpkg/*.rs) \
+              $(wildcard $(S)src/rust/*.rs)
+
+  PP_INPUTS_FILTERED = $(shell echo $(PP_INPUTS) | xargs grep -L \
+                       "no-reformat\|xfail-pretty\|xfail-test")
+endif
+
+reformat: $(SREQ1$(CFG_BUILD))
+	@$(call E, reformat [stage1]: $@)
+	for i in $(PP_INPUTS_FILTERED);  \
+    do $(call CFG_RUN_TARG_$(CFG_BUILD),1,$(CFG_BUILD)/stage1/rustc$(X_$(CFG_BUILD))) \
+       --pretty normal $$i >$$i.tmp; \
+    if [ $$? -ne 0 ]; \
+        then echo failed to print $$i; rm $$i.tmp; \
+        else if cmp --silent $$i.tmp $$i; \
+            then echo no changes to $$i; rm $$i.tmp; \
+            else echo reformated $$i; mv $$i.tmp $$i; \
+        fi; \
+    fi; \
+    done

branches/try2/mk/tests.mk

@@ -908,8 +908,6 @@ define DEF_RMAKE_FOR_T_H
 # $(2) target triple
 # $(3) host triple
 
-
-ifeq ($(2)$(3),$$(CFG_BUILD)$$(CFG_BUILD))
 check-stage$(1)-T-$(2)-H-$(3)-rmake-exec: \
 		$$(call TEST_OK_FILE,$(1),$(2),$(3),rmake)
 
@@ -929,13 +927,6 @@ $(3)/test/run-make/%-$(1)-T-$(2)-H-$(3).ok: \
 	    "$$(CC_$(3)) $$(CFG_GCCISH_CFLAGS_$(3))" \
 	    $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3))
 	@touch $$@
-else
-# FIXME #11094 - The above rule doesn't work right for multiple targets
-check-stage$(1)-T-$(2)-H-$(3)-rmake-exec:
-	@true
-
-endif
-
 
 endef
 

branches/try2/src/libextra/arc.rs

@@ -226,7 +226,7 @@ impl<T:Send> MutexArc<T> {
         // not already unsafe. See borrow_rwlock, far below.
         (&(*state).lock).lock(|| {
             check_poison(true, (*state).failed);
-            let _z = PoisonOnFail(&mut (*state).failed);
+            let _z = PoisonOnFail::new(&mut (*state).failed);
             blk(&mut (*state).data)
         })
     }
@@ -239,7 +239,7 @@ impl<T:Send> MutexArc<T> {
         let state = self.x.get();
         (&(*state).lock).lock_cond(|cond| {
             check_poison(true, (*state).failed);
-            let _z = PoisonOnFail(&mut (*state).failed);
+            let _z = PoisonOnFail::new(&mut (*state).failed);
             blk(&mut (*state).data,
                 &Condvar {is_mutex: true,
                           failed: &mut (*state).failed,
@@ -311,24 +311,28 @@ fn check_poison(is_mutex: bool, failed: bool) {
 
 #[doc(hidden)]
 struct PoisonOnFail {
-    failed: *mut bool,
+    flag: *mut bool,
+    failed: bool,
 }
 
 impl Drop for PoisonOnFail {
     fn drop(&mut self) {
         unsafe {
             /* assert!(!*self.failed);
                -- might be false in case of cond.wait() */
-            if task::failing() {
-                *self.failed = true;
+            if !self.failed && task::failing() {
+                *self.flag = true;
             }
         }
     }
 }
 
-fn PoisonOnFail<'r>(failed: &'r mut bool) -> PoisonOnFail {
-    PoisonOnFail {
-        failed: failed
+impl PoisonOnFail {
+    fn new<'a>(flag: &'a mut bool) -> PoisonOnFail {
+        PoisonOnFail {
+            flag: flag,
+            failed: task::failing()
+        }
     }
 }
 
@@ -392,7 +396,7 @@ impl<T:Freeze + Send> RWArc<T> {
             let state = self.x.get();
             (*borrow_rwlock(state)).write(|| {
                 check_poison(false, (*state).failed);
-                let _z = PoisonOnFail(&mut (*state).failed);
+                let _z = PoisonOnFail::new(&mut (*state).failed);
                 blk(&mut (*state).data)
             })
         }
@@ -407,7 +411,7 @@ impl<T:Freeze + Send> RWArc<T> {
             let state = self.x.get();
             (*borrow_rwlock(state)).write_cond(|cond| {
                 check_poison(false, (*state).failed);
-                let _z = PoisonOnFail(&mut (*state).failed);
+                let _z = PoisonOnFail::new(&mut (*state).failed);
                 blk(&mut (*state).data,
                     &Condvar {is_mutex: false,
                               failed: &mut (*state).failed,
@@ -463,7 +467,7 @@ impl<T:Freeze + Send> RWArc<T> {
                 blk(RWWriteMode {
                     data: &mut (*state).data,
                     token: write_mode,
-                    poison: PoisonOnFail(&mut (*state).failed)
+                    poison: PoisonOnFail::new(&mut (*state).failed)
                 })
             })
         }
@@ -563,7 +567,7 @@ impl<'a, T:Freeze + Send> RWWriteMode<'a, T> {
                     unsafe {
                         let cvar = Condvar {
                             is_mutex: false,
-                            failed: &mut *poison.failed,
+                            failed: &mut *poison.flag,
                             cond: cond
                         };
                         blk(data, &cvar)
@@ -714,6 +718,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_mutex_arc_access_in_unwind() {
+        let arc = MutexArc::new(1i);
+        let arc2 = arc.clone();
+        task::try::<()>(proc() {
+            struct Unwinder {
+                i: MutexArc<int>
+            }
+            impl Drop for Unwinder {
+                fn drop(&mut self) {
+                    self.i.access(|num| *num += 1);
+                }
+            }
+            let _u = Unwinder { i: arc2 };
+            fail!();
+        });
+        assert_eq!(2, arc.access(|n| *n));
+    }
+
     #[test] #[should_fail]
     fn test_rw_arc_poison_wr() {
         let arc = RWArc::new(1);
@@ -840,6 +863,26 @@ mod tests {
             assert_eq!(*num, 10);
         })
     }
+
+    #[test]
+    fn test_rw_arc_access_in_unwind() {
+        let arc = RWArc::new(1i);
+        let arc2 = arc.clone();
+        task::try::<()>(proc() {
+            struct Unwinder {
+                i: RWArc<int>
+            }
+            impl Drop for Unwinder {
+                fn drop(&mut self) {
+                    self.i.write(|num| *num += 1);
+                }
+            }
+            let _u = Unwinder { i: arc2 };
+            fail!();
+        });
+        assert_eq!(2, arc.read(|n| *n));
+    }
+
     #[test]
     fn test_rw_downgrade() {
         // (1) A downgrader gets in write mode and does cond.wait.

branches/try2/src/libextra/glob.rs

@@ -28,6 +28,8 @@ use std::io;
 use std::io::fs;
 use std::path::is_sep;
 
+use sort;
+
 /**
  * An iterator that yields Paths from the filesystem that match a particular
  * pattern - see the `glob` function for more details.
@@ -147,8 +149,9 @@ impl Iterator<Path> for GlobIterator {
 
 fn list_dir_sorted(path: &Path) -> ~[Path] {
     match io::result(|| fs::readdir(path)) {
-        Ok(mut children) => {
-            children.sort_by(|p1, p2| p2.filename().cmp(&p1.filename()));
+        Ok(children) => {
+            let mut children = children;
+            sort::quick_sort(children, |p1, p2| p2.filename() <= p1.filename());
             children
         }
         Err(..) => ~[]
@@ -768,3 +771,4 @@ mod test {
         assert!(Pattern::new("a/b").matches_path(&Path::new("a/b")));
     }
 }
+

branches/try2/src/libextra/lib.rs

@@ -61,6 +61,8 @@ pub mod ringbuf;
 pub mod priority_queue;
 pub mod smallintmap;
 
+pub mod sort;
+
 pub mod dlist;
 pub mod treemap;
 pub mod btree;

branches/try2/src/libextra/priority_queue.rs

@@ -213,6 +213,7 @@ impl<T: Ord> Extendable<T> for PriorityQueue<T> {
 
 #[cfg(test)]
 mod tests {
+    use sort::merge_sort;
     use priority_queue::PriorityQueue;
 
     #[test]
@@ -230,8 +231,7 @@ mod tests {
     #[test]
     fn test_top_and_pop() {
         let data = ~[2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-        let mut sorted = data.clone();
-        sorted.sort();
+        let mut sorted = merge_sort(data, |x, y| x.le(y));
         let mut heap = PriorityQueue::from_vec(data);
         while !heap.is_empty() {
             assert_eq!(heap.top(), sorted.last());
@@ -311,14 +311,11 @@ mod tests {
         assert_eq!(heap.len(), 5);
     }
 
-    fn check_to_vec(mut data: ~[int]) {
+    fn check_to_vec(data: ~[int]) {
         let heap = PriorityQueue::from_vec(data.clone());
-        let mut v = heap.clone().to_vec();
-        v.sort();
-        data.sort();
-
-        assert_eq!(v, data);
-        assert_eq!(heap.to_sorted_vec(), data);
+        assert_eq!(merge_sort(heap.clone().to_vec(), |x, y| x.le(y)),
+                   merge_sort(data, |x, y| x.le(y)));
+        assert_eq!(heap.to_sorted_vec(), merge_sort(data, |x, y| x.le(y)));
     }
 
     #[test]