Update for latest master (0.9-pre 90d06ec)

7 files changed, 48 insertions, 48 deletions

diff --git a/hash.rs b/hash.rs
index 139ae4ca..d7b99264 100644
--- a/hash.rs
+++ b/hash.rs
@@ -72,11 +72,11 @@ impl Hasher {
 
     /// Update this hasher with more input bytes
     pub fn update(&self, data: &[u8]) {
-        do data.as_imm_buf |pdata, len| {
+        data.as_imm_buf(|pdata, len| {
             unsafe {
                 libcrypto::EVP_DigestUpdate(self.ctx, pdata, len as c_uint)
             }
-        }
+        });
     }
 
     /**
@@ -85,11 +85,11 @@ impl Hasher {
      */
     pub fn final(&self) -> ~[u8] {
         let mut res = vec::from_elem(self.len, 0u8);
-        do res.as_mut_buf |pres, _len| {
+        res.as_mut_buf(|pres, _len| {
             unsafe {
                 libcrypto::EVP_DigestFinal(self.ctx, pres, ptr::null());
             }
-        }
+        });
         res
     }
 }
diff --git a/hex.rs b/hex.rs
index b479ea18..8a91c071 100644
--- a/hex.rs
+++ b/hex.rs
@@ -23,7 +23,7 @@ pub trait ToHex {
 impl<'self> ToHex for &'self [u8] {
     fn to_hex(&self) -> ~str {
 
-        let chars = "0123456789ABCDEF".iter().collect::<~[char]>();
+        let chars = "0123456789ABCDEF".chars().collect::<~[char]>();
 
         let mut s = ~"";
 
@@ -50,7 +50,7 @@ impl<'self> FromHex for &'self str {
     fn from_hex(&self) -> ~[u8] {
         let mut vec = vec::with_capacity(self.len() / 2);
 
-        for (i,c) in self.iter().enumerate() {
+        for (i,c) in self.chars().enumerate() {
             let nibble =
                 if c >= '0' && c <= '9' { (c as u8) - 0x30 }
                 else if c >= 'a' && c <= 'f' { (c as u8) - (0x61 - 10) }
diff --git a/hmac.rs b/hmac.rs
index 510c8b2d..8e533f53 100644
--- a/hmac.rs
+++ b/hmac.rs
@@ -67,9 +67,9 @@ pub fn HMAC(ht: HashType, key: ~[u8]) -> HMAC {
 impl HMAC {
     pub fn update(&mut self, data: &[u8]) {
         unsafe {
-            do data.as_imm_buf |pdata, len| {
+            data.as_imm_buf(|pdata, len| {
                 HMAC_Update(&mut self.ctx, pdata, len as libc::c_uint)
-            }
+            });
         }
     }
 
@@ -77,10 +77,10 @@ impl HMAC {
         unsafe {
             let mut res = vec::from_elem(self.len, 0u8);
             let mut outlen: libc::c_uint = 0;
-            do res.as_mut_buf |pres, _len| {
+            res.as_mut_buf(|pres, _len| {
                 HMAC_Final(&mut self.ctx, pres, &mut outlen);
                 assert!(self.len == outlen as uint)
-            }
+            });
             res
         }
     }
diff --git a/pkcs5.rs b/pkcs5.rs
index 3c5ba23b..71c7e590 100644
--- a/pkcs5.rs
+++ b/pkcs5.rs
@@ -19,11 +19,11 @@ pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint,
     assert!(iter >= 1u);
     assert!(keylen >= 1u);
 
-    do pass.as_imm_buf |pass_buf, pass_len| {
-        do salt.as_imm_buf |salt_buf, salt_len| {
+    pass.as_imm_buf(|pass_buf, pass_len| {
+        salt.as_imm_buf(|salt_buf, salt_len| {
             let mut out = vec::with_capacity(keylen);
 
-            do out.as_mut_buf |out_buf, _out_len| {
+            out.as_mut_buf(|out_buf, _out_len| {
                 let r = unsafe {
                     libcrypto::PKCS5_PBKDF2_HMAC_SHA1(
                         pass_buf, pass_len as c_int,
@@ -33,13 +33,13 @@ pub fn pbkdf2_hmac_sha1(pass: &str, salt: &[u8], iter: uint,
                 };
 
                 if r != 1 as c_int { fail!(); }
-            }
+            });
 
             unsafe { vec::raw::set_len(&mut out, keylen); }
 
             out
-        }
-    }
+        })
+    })
 }
 
 #[cfg(test)]
diff --git a/pkey.rs b/pkey.rs
index d59e05f1..41996c65 100644
--- a/pkey.rs
+++ b/pkey.rs
@@ -99,9 +99,9 @@ impl PKey {
             if len < 0 as c_int { return ~[]; }
             let mut s = vec::from_elem(len as uint, 0u8);
 
-            let r = do s.as_mut_buf |buf, _| {
+            let r = s.as_mut_buf(|buf, _| {
                 f(self.evp, &buf)
-            };
+            });
 
             s.truncate(r as uint);
             s
@@ -109,13 +109,13 @@ impl PKey {
     }
 
     fn _fromstr(&mut self, s: &[u8], f: extern "C" unsafe fn(c_int, **EVP_PKEY, **u8, c_uint) -> *EVP_PKEY) {
-        do s.as_imm_buf |ps, len| {
+        s.as_imm_buf(|ps, len| {
             let evp = ptr::null();
             unsafe {
                 f(6 as c_int, &evp, &ps, len as c_uint);
             }
             self.evp = evp;
-        }
+        });
     }
 
     pub fn gen(&mut self, keysz: uint) {
@@ -228,8 +228,8 @@ impl PKey {
 
             let mut r = vec::from_elem(len as uint + 1u, 0u8);
 
-            let rv = do r.as_mut_buf |pr, _len| {
-                        do s.as_imm_buf |ps, s_len| {
+            let rv = r.as_mut_buf(|pr, _len| {
+                        s.as_imm_buf(|ps, s_len| {
                             libcrypto::RSA_public_encrypt(
                                 s_len as c_uint,
                                 ps,
@@ -237,8 +237,8 @@ impl PKey {
                                 rsa,
                                 openssl_padding_code(padding)
                             )
-                        }
-                     };
+                        })
+                     });
             if rv < 0 as c_int {
                 ~[]
             } else {
@@ -257,8 +257,8 @@ impl PKey {
 
             let mut r = vec::from_elem(len as uint + 1u, 0u8);
 
-            let rv = do r.as_mut_buf |pr, _len| {
-                        do s.as_imm_buf |ps, s_len| {
+            let rv = r.as_mut_buf(|pr, _len| {
+                        s.as_imm_buf(|ps, s_len| {
                             libcrypto::RSA_private_decrypt(
                                 s_len as c_uint,
                                 ps,
@@ -266,8 +266,8 @@ impl PKey {
                                 rsa,
                                 openssl_padding_code(padding)
                             )
-                        }
-                     };
+                        })
+                     });
 
             if rv < 0 as c_int {
                 ~[]
@@ -307,8 +307,8 @@ impl PKey {
             let mut len = libcrypto::RSA_size(rsa);
             let mut r = vec::from_elem(len as uint + 1u, 0u8);
 
-            let rv = do r.as_mut_buf |pr, _len| {
-                        do s.as_imm_buf |ps, s_len| {
+            let rv = r.as_mut_buf(|pr, _len| {
+                        s.as_imm_buf(|ps, s_len| {
                             libcrypto::RSA_sign(
                                 openssl_hash_nid(hash),
                                 ps,
@@ -316,8 +316,8 @@ impl PKey {
                                 pr,
                                 &mut len,
                                 rsa)
-                        }
-                     };
+                        })
+                     });
 
             if rv < 0 as c_int {
                 ~[]
@@ -332,8 +332,8 @@ impl PKey {
         unsafe {
             let rsa = libcrypto::EVP_PKEY_get1_RSA(self.evp);
 
-            do m.as_imm_buf |pm, m_len| {
-                do s.as_imm_buf |ps, s_len| {
+            m.as_imm_buf(|pm, m_len| {
+                s.as_imm_buf(|ps, s_len| {
                     let rv = libcrypto::RSA_verify(
                         openssl_hash_nid(hash),
                         pm,
@@ -344,8 +344,8 @@ impl PKey {
                     );
 
                     rv == 1 as c_int
-                }
-            }
+                })
+            })
         }
     }
 }
diff --git a/rand.rs b/rand.rs
index 07a39184..f8dd25b4 100644
--- a/rand.rs
+++ b/rand.rs
@@ -13,10 +13,10 @@ mod libcrypto {
 pub fn rand_bytes(len: uint) -> ~[u8] {
     let mut out = vec::with_capacity(len);
 
-    do out.as_mut_buf |out_buf, len| {
+    out.as_mut_buf(|out_buf, len| {
         let r = unsafe { libcrypto::RAND_bytes(out_buf, len as c_int) };
         if r != 1 as c_int { fail!() }
-    }
+    });
 
     unsafe { vec::raw::set_len(&mut out, len); }
 
diff --git a/symm.rs b/symm.rs
index edc408cb..3d31bde0 100644
--- a/symm.rs
+++ b/symm.rs
@@ -115,8 +115,8 @@ impl Crypter {
             };
             assert_eq!(key.len(), self.keylen);
 
-            do key.as_imm_buf |pkey, _len| {
-                do iv.as_imm_buf |piv, _len| {
+            key.as_imm_buf(|pkey, _len| {
+                iv.as_imm_buf(|piv, _len| {
                     libcrypto::EVP_CipherInit(
                         self.ctx,
                         self.evp,
@@ -124,8 +124,8 @@ impl Crypter {
                         piv,
                         mode
                     )
-                }
-            }
+                });
+            });
         }
     }
 
@@ -135,10 +135,10 @@ impl Crypter {
      */
     pub fn update(&self, data: &[u8]) -> ~[u8] {
         unsafe {
-            do data.as_imm_buf |pdata, len| {
+            data.as_imm_buf(|pdata, len| {
                 let mut res = vec::from_elem(len + self.blocksize, 0u8);
 
-                let reslen = do res.as_mut_buf |pres, _len| {
+                let reslen = res.as_mut_buf(|pres, _len| {
                     let mut reslen = (len + self.blocksize) as u32;
 
                     libcrypto::EVP_CipherUpdate(
@@ -150,11 +150,11 @@ impl Crypter {
                     );
 
                     reslen
-                };
+                });
 
                 res.truncate(reslen as uint);
                 res
-            }
+            })
         }
     }
 
@@ -165,11 +165,11 @@ impl Crypter {
         unsafe {
             let mut res = vec::from_elem(self.blocksize, 0u8);
 
-            let reslen = do res.as_mut_buf |pres, _len| {
+            let reslen = res.as_mut_buf(|pres, _len| {
                 let mut reslen = self.blocksize as c_int;
                 libcrypto::EVP_CipherFinal(self.ctx, pres, &mut reslen);
                 reslen
-            };
+            });
 
             res.truncate(reslen as uint);
             res