---

yaml
---
r: 94959
b: refs/heads/dist-snap
c: 57757a8
h: refs/heads/master
i:
  94957: 64ec78d
  94955: 31a7e2e
  94951: 97f7999
  94943: d2bb6f6
v: v3

Author: blake2-ppc

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 47f2e80b65bf814953c0ceda3b48e46802883f4b
+refs/heads/dist-snap: 57757a8051101eb64eb7a330d7c673422e06a57b
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/bitv.rs

@@ -523,7 +523,7 @@ impl Bitv {
  * with the most significant bits of each byte coming first. Each
  * bit becomes true if equal to 1 or false if equal to 0.
  */
-pub fn from_bytes(bytes: &[u8]) -> Bitv {
+pub fn from_utf8(bytes: &[u8]) -> Bitv {
     from_fn(bytes.len() * 8, |i| {
         let b = bytes[i / 8] as uint;
         let offset = i % 8;
@@ -1275,8 +1275,8 @@ mod tests {
     }
 
     #[test]
-    fn test_from_bytes() {
-        let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
+    fn test_from_utf8() {
+        let bitv = from_utf8([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + "00000000" + "11111111";
         assert_eq!(bitv.to_str(), str);
     }
@@ -1302,7 +1302,7 @@ mod tests {
     #[test]
     fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        assert_eq!(from_bytes([0b00100110]).to_bools(), bools);
+        assert_eq!(from_utf8([0b00100110]).to_bools(), bools);
     }
 
     #[test]

branches/dist-snap/src/libextra/crypto/md5.rs

@@ -156,7 +156,7 @@ static C4: [u32, ..16] = [
 
 
 /// The MD5 Digest algorithm
-pub struct Md5 {
+struct Md5 {
     priv length_bytes: u64,
     priv buffer: FixedBuffer64,
     priv state: Md5State,

branches/dist-snap/src/libextra/crypto/sha2.rs

@@ -230,8 +230,7 @@ impl Engine512 {
 }
 
 
-/// The SHA-512 hash algorithm
-pub struct Sha512 {
+struct Sha512 {
     priv engine: Engine512
 }
 
@@ -283,8 +282,7 @@ static H512: [u64, ..8] = [
 ];
 
 
-/// The SHA-384 hash algorithm
-pub struct Sha384 {
+struct Sha384 {
     priv engine: Engine512
 }
 
@@ -334,8 +332,7 @@ static H384: [u64, ..8] = [
 ];
 
 
-/// The SHA-512 hash algorithm with digest truncated to 256 bits
-pub struct Sha512Trunc256 {
+struct Sha512Trunc256 {
     priv engine: Engine512
 }
 
@@ -383,8 +380,7 @@ static H512_TRUNC_256: [u64, ..8] = [
 ];
 
 
-/// The SHA-512 hash algorithm with digest truncated to 224 bits
-pub struct Sha512Trunc224 {
+struct Sha512Trunc224 {
     priv engine: Engine512
 }
 
@@ -639,8 +635,7 @@ impl Engine256 {
 }
 
 
-/// The SHA-256 hash algorithm
-pub struct Sha256 {
+struct Sha256 {
     priv engine: Engine256
 }
 
@@ -692,8 +687,7 @@ static H256: [u32, ..8] = [
 ];
 
 
-/// The SHA-224 hash algorithm
-pub struct Sha224 {
+struct Sha224 {
     priv engine: Engine256
 }
 

branches/dist-snap/src/libextra/ringbuf.rs

@@ -143,6 +143,19 @@ impl<T> RingBuf<T> {
         }
     }
 
+    /// Swap elements at indices `i` and `j`
+    ///
+    /// `i` and `j` may be equal.
+    ///
+    /// Fails if there is no element with the given index
+    pub fn swap(&mut self, i: uint, j: uint) {
+        assert!(i < self.len());
+        assert!(j < self.len());
+        let ri = self.raw_index(i);
+        let rj = self.raw_index(j);
+        self.elts.swap(ri, rj);
+    }
+
     /// Return index in underlying vec for a given logical element index
     fn raw_index(&self, idx: uint) -> uint {
         raw_index(self.lo, self.elts.len(), idx)
@@ -604,6 +617,14 @@ mod tests {
         assert_eq!(d.elts.capacity(), 64);
     }
 
+    #[test]
+    fn test_swap() {
+        let mut d: RingBuf<int> = range(0, 5).collect();
+        d.pop_front();
+        d.swap(0, 3);
+        assert_eq!(d.iter().map(|&x|x).collect::<~[int]>(), ~[4, 2, 3, 1]);
+    }
+
     #[test]
     fn test_iter() {
         let mut d = RingBuf::new();

branches/dist-snap/src/libextra/url.rs

@@ -21,7 +21,7 @@ use std::to_bytes;
 use std::uint;
 
 #[deriving(Clone, Eq)]
-pub struct Url {
+struct Url {
     scheme: ~str,
     user: Option<UserInfo>,
     host: ~str,
@@ -32,7 +32,7 @@ pub struct Url {
 }
 
 #[deriving(Clone, Eq)]
-pub struct UserInfo {
+struct UserInfo {
     user: ~str,
     pass: Option<~str>
 }

branches/dist-snap/src/librustc/middle/typeck/check/method.rs

@@ -372,7 +372,7 @@ impl<'self> LookupContext<'self> {
     // to a trait and its supertraits.
     fn get_method_index(&self,
                         trait_ref: @TraitRef,
-                        subtrait: @TraitRef,
+                        subtrait_id: ast::DefId,
                         n_method: uint) -> uint {
         let tcx = self.tcx();
 
@@ -382,14 +382,15 @@ impl<'self> LookupContext<'self> {
         // we find the trait the method came from, counting up the
         // methods from them.
         let mut method_count = 0;
-        do ty::each_bound_trait_and_supertraits(tcx, &[subtrait])
+        do ty::each_bound_trait_and_supertraits(tcx, &[trait_ref])
             |bound_ref| {
-            if bound_ref.def_id == trait_ref.def_id { false }
+            if bound_ref.def_id == subtrait_id { false }
                 else {
                 method_count += ty::trait_methods(tcx, bound_ref.def_id).len();
                 true
             }
         };
+
         return method_count + n_method;
     }
 
@@ -417,9 +418,9 @@ impl<'self> LookupContext<'self> {
         let trait_ref = @TraitRef { def_id: did, substs: rcvr_substs.clone() };
 
         do self.push_inherent_candidates_from_bounds_inner(&[trait_ref])
-            |new_trait_ref, m, method_num, _bound_num| {
+            |trait_ref, m, method_num, _bound_num| {
             let vtable_index =
-                self.get_method_index(new_trait_ref, trait_ref, method_num);
+                self.get_method_index(trait_ref, trait_ref.def_id, method_num);
             // We need to fix up the transformed self type.
             let transformed_self_ty =
                 self.construct_transformed_self_ty_for_object(

branches/dist-snap/src/libstd/libc.rs

@@ -3224,14 +3224,14 @@ pub mod funcs {
         #[nolink]
         #[abi = "cdecl"]
         pub mod glob {
+            use libc::types::common::c95::{c_void};
             use libc::types::os::arch::c95::{c_char, c_int};
             use libc::types::os::common::posix01::{glob_t};
-            use option::Option;
 
             extern {
                 pub fn glob(pattern: *c_char,
                             flags: c_int,
-                            errfunc: Option<extern "C" fn(epath: *c_char, errno: int) -> int>,
+                            errfunc: *c_void, // XXX callback
                             pglob: *mut glob_t);
                 pub fn globfree(pglob: *mut glob_t);
             }

branches/dist-snap/src/libstd/rt/comm.rs

@@ -118,17 +118,6 @@ impl<T> ChanOne<T> {
             rtassert!(!rt::in_sched_context());
         }
 
-        // In order to prevent starvation of other tasks in situations
-        // where a task sends repeatedly without ever receiving, we
-        // occassionally yield instead of doing a send immediately.
-        // Only doing this if we're doing a rescheduling send,
-        // otherwise the caller is expecting not to context switch.
-        if do_resched {
-            // XXX: This TLS hit should be combined with other uses of the scheduler below
-            let sched: ~Scheduler = Local::take();
-            sched.maybe_yield();
-        }
-
         let mut this = self;
         let mut recvr_active = true;
         let packet = this.packet();

branches/dist-snap/src/libstd/rt/io/mem.rs

@@ -128,7 +128,7 @@ impl Decorator<~[u8]> for MemReader {
 
 
 /// Writes to a fixed-size byte slice
-pub struct BufWriter<'self> {
+struct BufWriter<'self> {
     buf: &'self mut [u8],
     pos: uint
 }
@@ -156,7 +156,7 @@ impl<'self> Seek for BufWriter<'self> {
 
 
 /// Reads from a fixed-size byte slice
-pub struct BufReader<'self> {
+struct BufReader<'self> {
     buf: &'self [u8],
     pos: uint
 }

branches/dist-snap/src/libstd/rt/local_ptr.rs

@@ -129,16 +129,12 @@ pub unsafe fn unsafe_borrow<T>() -> *mut T {
 }
 
 pub unsafe fn try_unsafe_borrow<T>() -> Option<*mut T> {
-    match maybe_tls_key() {
-        Some(key) => {
-            let void_ptr = tls::get(key);
-            if void_ptr.is_null() {
-                None
-            } else {
-                Some(void_ptr as *mut T)
-            }
-        }
-        None => None
+    let key = tls_key();
+    let void_ptr = tls::get(key);
+    if void_ptr.is_null() {
+        None
+    } else {
+        Some(void_ptr as *mut T)
     }
 }