---

yaml
---
r: 130179
b: refs/heads/master
c: 7f676b8
h: refs/heads/master
i:
  130177: 91aeb58
  130175: b06730f
v: v3

Author: Keegan McAllister

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6d8b5c9f7d1347b715242a837fba87a01ae61d7e
+refs/heads/master: 7f676b86994edcd6adf27018a5d18e957c9390ab
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
 refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0

trunk/src/libcollections/bitv.rs

@@ -95,6 +95,20 @@ fn match_words <'a,'b>(a: &'a Bitv, b: &'b Bitv) -> (MatchWords<'a>, MatchWords<
 static TRUE: bool = true;
 static FALSE: bool = false;
 
+#[deriving(Clone)]
+struct SmallBitv {
+    /// only the lowest nbits of this value are used. the rest is undefined.
+    bits: uint
+}
+
+#[deriving(Clone)]
+struct BigBitv {
+    storage: Vec<uint>
+}
+
+#[deriving(Clone)]
+enum BitvVariant { Big(BigBitv), Small(SmallBitv) }
+
 /// The bitvector type.
 ///
 /// # Example
@@ -1639,7 +1653,6 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
 #[cfg(test)]
 mod tests {
     use std::prelude::*;
-    use std::iter::range_step;
     use std::uint;
     use std::rand;
     use std::rand::Rng;
@@ -2033,14 +2046,12 @@ mod tests {
 
     #[test]
     fn test_bitv_iterator() {
-        let bools = vec![true, false, true, true];
+        let bools = [true, false, true, true];
         let bitv: Bitv = bools.iter().map(|n| *n).collect();
 
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools)
-
-        let long = Vec::from_fn(10000, |i| i % 2 == 0);
-        let bitv: Bitv = long.iter().map(|n| *n).collect();
-        assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
+        for (act, &ex) in bitv.iter().zip(bools.iter()) {
+            assert_eq!(ex, act);
+        }
     }
 
     #[test]
@@ -2050,12 +2061,6 @@ mod tests {
 
         let idxs: Vec<uint> = bitv.iter().collect();
         assert_eq!(idxs, vec!(0, 2, 3));
-
-        let long: BitvSet = range(0u, 10000).map(|n| n % 2 == 0).collect();
-        let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
-
-        let idxs: Vec<uint> = long.iter().collect();
-        assert_eq!(idxs, real);
     }
 
     #[test]
@@ -2569,7 +2574,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_fixed(b: &mut Bencher) {
+    fn bench_bitv_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
         b.iter(|| {
@@ -2581,19 +2586,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitv_set_big_variable(b: &mut Bencher) {
-        let mut r = rng();
-        let mut bitv = Bitv::with_capacity(BENCH_BITS, false);
-        b.iter(|| {
-            for i in range(0u, 100) {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
-            }
-            &bitv
-        })
-    }
-
-    #[bench]
-    fn bench_bitv_set_small(b: &mut Bencher) {
+    fn bench_bitv_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = Bitv::with_capacity(uint::BITS, false);
         b.iter(|| {
@@ -2605,7 +2598,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_small(b: &mut Bencher) {
+    fn bench_bitv_set_small(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
@@ -2617,7 +2610,7 @@ mod tests {
     }
 
     #[bench]
-    fn bench_bitvset_big(b: &mut Bencher) {
+    fn bench_bitv_set_big(b: &mut Bencher) {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {

trunk/src/liblibc/lib.rs

@@ -4542,7 +4542,7 @@ pub mod funcs {
                 pub fn glob(pattern: *const c_char,
                             flags: c_int,
                             errfunc: ::Nullable<extern "C" fn(epath: *const c_char,
-                                                              errno: c_int) -> int>,
+                                                              errno: c_int) -> c_int>,
                             pglob: *mut glob_t);
                 pub fn globfree(pglob: *mut glob_t);
             }

trunk/src/libnative/io/file_unix.rs

@@ -154,7 +154,7 @@ impl rtio::RtioFileStream for FileDesc {
 
     fn fstat(&mut self) -> IoResult<rtio::FileStat> {
         let mut stat: libc::stat = unsafe { mem::zeroed() };
-        match unsafe { libc::fstat(self.fd(), &mut stat) } {
+        match retry(|| unsafe { libc::fstat(self.fd(), &mut stat) }) {
             0 => Ok(mkstat(&stat)),
             _ => Err(super::last_error()),
         }
@@ -346,7 +346,9 @@ pub fn open(path: &CString, fm: rtio::FileMode, fa: rtio::FileAccess)
 }
 
 pub fn mkdir(p: &CString, mode: uint) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::mkdir(p.as_ptr(), mode as libc::mode_t) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::mkdir(p.as_ptr(), mode as libc::mode_t)
+    }))
 }
 
 pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
@@ -391,11 +393,13 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
 }
 
 pub fn unlink(p: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::unlink(p.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe { libc::unlink(p.as_ptr()) }))
 }
 
 pub fn rename(old: &CString, new: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::rename(old.as_ptr(), new.as_ptr())
+    }))
 }
 
 pub fn chmod(p: &CString, mode: uint) -> IoResult<()> {
@@ -405,7 +409,9 @@ pub fn chmod(p: &CString, mode: uint) -> IoResult<()> {
 }
 
 pub fn rmdir(p: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::rmdir(p.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::rmdir(p.as_ptr())
+    }))
 }
 
 pub fn chown(p: &CString, uid: int, gid: int) -> IoResult<()> {
@@ -422,10 +428,10 @@ pub fn readlink(p: &CString) -> IoResult<CString> {
         len = 1024; // FIXME: read PATH_MAX from C ffi?
     }
     let mut buf: Vec<u8> = Vec::with_capacity(len as uint);
-    match unsafe {
+    match retry(|| unsafe {
         libc::readlink(p, buf.as_ptr() as *mut libc::c_char,
                        len as libc::size_t) as libc::c_int
-    } {
+    }) {
         -1 => Err(super::last_error()),
         n => {
             assert!(n > 0);
@@ -436,11 +442,15 @@ pub fn readlink(p: &CString) -> IoResult<CString> {
 }
 
 pub fn symlink(src: &CString, dst: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::symlink(src.as_ptr(), dst.as_ptr())
+    }))
 }
 
 pub fn link(src: &CString, dst: &CString) -> IoResult<()> {
-    super::mkerr_libc(unsafe { libc::link(src.as_ptr(), dst.as_ptr()) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::link(src.as_ptr(), dst.as_ptr())
+    }))
 }
 
 fn mkstat(stat: &libc::stat) -> rtio::FileStat {
@@ -479,15 +489,15 @@ fn mkstat(stat: &libc::stat) -> rtio::FileStat {
 
 pub fn stat(p: &CString) -> IoResult<rtio::FileStat> {
     let mut stat: libc::stat = unsafe { mem::zeroed() };
-    match unsafe { libc::stat(p.as_ptr(), &mut stat) } {
+    match retry(|| unsafe { libc::stat(p.as_ptr(), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),
     }
 }
 
 pub fn lstat(p: &CString) -> IoResult<rtio::FileStat> {
     let mut stat: libc::stat = unsafe { mem::zeroed() };
-    match unsafe { libc::lstat(p.as_ptr(), &mut stat) } {
+    match retry(|| unsafe { libc::lstat(p.as_ptr(), &mut stat) }) {
         0 => Ok(mkstat(&stat)),
         _ => Err(super::last_error()),
     }
@@ -498,7 +508,9 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
         actime: (atime / 1000) as libc::time_t,
         modtime: (mtime / 1000) as libc::time_t,
     };
-    super::mkerr_libc(unsafe { libc::utime(p.as_ptr(), &buf) })
+    super::mkerr_libc(retry(|| unsafe {
+        libc::utime(p.as_ptr(), &buf)
+    }))
 }
 
 #[cfg(test)]

trunk/src/librustc/middle/check_match.rs

@@ -28,7 +28,8 @@ use syntax::codemap::{Span, Spanned, DUMMY_SP};
 use syntax::fold::{Folder, noop_fold_pat};
 use syntax::print::pprust::pat_to_string;
 use syntax::parse::token;
-use syntax::visit::{mod, Visitor, FnKind};
+use syntax::visit;
+use syntax::visit::{Visitor, FnKind};
 use util::ppaux::ty_to_string;
 
 struct Matrix(Vec<Vec<Gc<Pat>>>);
@@ -102,9 +103,7 @@ pub enum Constructor {
     /// Ranges of literal values (2..5).
     ConstantRange(const_val, const_val),
     /// Array patterns of length n.
-    Slice(uint),
-    /// Array patterns with a subslice.
-    SliceWithSubslice(uint, uint)
+    Slice(uint)
 }
 
 #[deriving(Clone, PartialEq)]
@@ -271,6 +270,13 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) {
     }
 }
 
+fn raw_pat(p: Gc<Pat>) -> Gc<Pat> {
+    match p.node {
+        PatIdent(_, _, Some(s)) => { raw_pat(s) }
+        _ => { p }
+    }
+}
+
 fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
     match is_useful(cx, matrix, [wild()], ConstructWitness) {
         UsefulWithWitness(pats) => {
@@ -815,14 +821,6 @@ pub fn specialize(cx: &MatchCheckCtxt, r: &[Gc<Pat>],
                     pats.push_all(after.as_slice());
                     Some(pats)
                 },
-                SliceWithSubslice(prefix, suffix)
-                    if before.len() == prefix
-                        && after.len() == suffix
-                        && slice.is_some() => {
-                    let mut pats = before.clone();
-                    pats.push_all(after.as_slice());
-                    Some(pats)
-                }
                 _ => None
             }
         }

trunk/src/librustc/middle/pat_util.rs

@@ -119,13 +119,6 @@ pub fn wild() -> Gc<Pat> {
     box (GC) Pat { id: 0, node: PatWild(PatWildSingle), span: DUMMY_SP }
 }
 
-pub fn raw_pat(p: Gc<Pat>) -> Gc<Pat> {
-    match p.node {
-        PatIdent(_, _, Some(s)) => { raw_pat(s) }
-        _ => { p }
-    }
-}
-
 pub fn def_to_path(tcx: &ty::ctxt, id: DefId) -> Path {
     ty::with_path(tcx, id, |mut path| Path {
         global: false,