---

yaml
---
r: 63631
b: refs/heads/snap-stage3
c: 0a74ffc
h: refs/heads/master
i:
  63629: f78feb2
  63627: b779641
  63623: d8f247f
  63615: d6ba531
v: v3

Author: Tuncer Ayaz

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b94f89fffc0c31a2e9048a824a66ff121c908818
+refs/heads/snap-stage3: 0a74ffcf042cfd6d4b1890e2c2b46e3e0ebaacfd
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/RELEASES.txt

@@ -78,6 +78,7 @@ Version 0.7 (July 2013)
       * extra: `BigInt`, `BigUint` implement numeric and comparison traits.
       * extra: `term` uses terminfo now, is more correct.
       * extra: `arc` functions converted to methods.
+      * extra: Implementation of fixed output size variations of SHA-2.
 
    * Tooling
       * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks.

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Jun 14
+" Last Change:  2013 Jun 14
 
 if version < 600
   syntax clear

branches/snap-stage3/src/libextra/arena.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -39,7 +39,7 @@ use core::prelude::*;
 use list::{MutList, MutCons, MutNil};
 
 use core::at_vec;
-use core::cast::{transmute, transmute_mut_region};
+use core::cast::{transmute, transmute_mut, transmute_mut_region};
 use core::cast;
 use core::libc::size_t;
 use core::ptr;
@@ -74,6 +74,7 @@ struct Chunk {
     is_pod: bool,
 }
 
+#[mutable]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
@@ -269,23 +270,22 @@ impl Arena {
 
     // The external interface
     #[inline]
-    pub fn alloc<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
+    pub fn alloc<'a, T>(&'a self, op: &fn() -> T) -> &'a T {
         unsafe {
             // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            if !intrinsics::needs_drop::<T>() {
-                return this.alloc_pod(op);
+            let this = transmute_mut(self);
+            if intrinsics::needs_drop::<T>() {
+                this.alloc_nonpod(op)
+            } else {
+                this.alloc_pod(op)
             }
-            // XXX: Borrow check
-            let this = transmute_mut_region(self);
-            this.alloc_nonpod(op)
         }
     }
 }
 
 #[test]
 fn test_arena_destructors() {
-    let mut arena = Arena();
+    let arena = Arena();
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it
         // doesn't leak.
@@ -300,7 +300,7 @@ fn test_arena_destructors() {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_arena_destructors_fail() {
-    let mut arena = Arena();
+    let arena = Arena();
     // Put some stuff in the arena.
     for uint::range(0, 10) |i| {
         // Arena allocate something with drop glue to make sure it

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

@@ -666,12 +666,8 @@ impl BitvSet {
     pub fn symmetric_difference_with(&mut self, other: &BitvSet) {
         self.other_op(other, |w1, w2| w1 ^ w2);
     }
-}
-
-impl BaseIter<uint> for BitvSet {
-    fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 
-    fn each(&self, blk: &fn(v: &uint) -> bool) -> bool {
+    pub fn each(&self, blk: &fn(v: &uint) -> bool) -> bool {
         for self.bitv.storage.iter().enumerate().advance |(i, &w)| {
             if !iterate_bits(i * uint::bits, w, |b| blk(&b)) {
                 return false;

branches/snap-stage3/src/libextra/crypto/digest.rs

@@ -0,0 +1,88 @@
+// 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.
+
+use core::prelude::*;
+
+use core::uint;
+use core::vec;
+
+/**
+ * The Digest trait specifies an interface common to digest functions, such as SHA-1 and the SHA-2
+ * family of digest functions.
+ */
+pub trait Digest {
+    /**
+     * Provide message data.
+     *
+     * # Arguments
+     *
+     * * input - A vector of message data
+     */
+    fn input(&mut self, input: &[u8]);
+
+    /**
+     * Retrieve the digest result. This method may be called multiple times.
+     */
+    fn result(&mut self, out: &mut [u8]);
+
+    /**
+     * Reset the digest. This method must be called after result() and before supplying more
+     * data.
+     */
+    fn reset(&mut self);
+
+    /**
+     * Get the output size in bits.
+     */
+    fn output_bits(&self) -> uint;
+}
+
+fn to_hex(rr: &[u8]) -> ~str {
+    let mut s = ~"";
+    for rr.iter().advance() |b| {
+        let hex = uint::to_str_radix(*b as uint, 16u);
+        if hex.len() == 1 {
+            s += "0";
+        }
+        s += hex;
+    }
+    return s;
+}
+
+/// Contains utility methods for Digests.
+/// FIXME: #7339: Convert to default methods when issues with them are resolved.
+pub trait DigestUtil {
+    /**
+     * Convenience functon that feeds a string into a digest
+     *
+     * # Arguments
+     *
+     * * in The string to feed into the digest
+     */
+    fn input_str(&mut self, in: &str);
+
+    /**
+     * Convenience functon that retrieves the result of a digest as a
+     * ~str in hexadecimal format.
+     */
+    fn result_str(&mut self) -> ~str;
+}
+
+impl<D: Digest> DigestUtil for D {
+    fn input_str(&mut self, in: &str) {
+        self.input(in.as_bytes());
+    }
+
+    fn result_str(&mut self) -> ~str {
+        let mut buf = vec::from_elem((self.output_bits()+7)/8, 0u8);
+        self.result(buf);
+        return to_hex(buf);
+    }
+}