---

yaml
---
r: 60811
b: refs/heads/auto
c: 3141acf
h: refs/heads/master
i:
  60809: b1f9a60
  60807: cd9cd55
v: v3

Author: Thiez

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 562069c12f4229d57ef31f559a40a64627bde782
+refs/heads/auto: 3141acf674fd34f66141c4659a4a239779bb2802
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libextra/base64.rs

@@ -113,7 +113,7 @@ pub trait FromBase64 {
     fn from_base64(&self) -> ~[u8];
 }
 
-impl<'self> FromBase64 for &'self [u8] {
+impl FromBase64 for ~[u8] {
     /**
      * Convert base64 `u8` vector into u8 byte values.
      * Every 4 encoded characters is converted into 3 octets, modulo padding.
@@ -188,7 +188,7 @@ impl<'self> FromBase64 for &'self [u8] {
     }
 }
 
-impl<'self> FromBase64 for &'self str {
+impl FromBase64 for ~str {
     /**
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
@@ -227,23 +227,23 @@ mod tests {
 
     #[test]
     fn test_to_base64() {
-        assert_eq!("".to_base64(), ~"");
-        assert_eq!("f".to_base64(), ~"Zg==");
-        assert_eq!("fo".to_base64(), ~"Zm8=");
-        assert_eq!("foo".to_base64(), ~"Zm9v");
-        assert_eq!("foob".to_base64(), ~"Zm9vYg==");
-        assert_eq!("fooba".to_base64(), ~"Zm9vYmE=");
-        assert_eq!("foobar".to_base64(), ~"Zm9vYmFy");
+        assert_eq!((~"").to_base64(), ~"");
+        assert!((~"f").to_base64()      == ~"Zg==");
+        assert_eq!((~"fo").to_base64(), ~"Zm8=");
+        assert_eq!((~"foo").to_base64(), ~"Zm9v");
+        assert!((~"foob").to_base64()   == ~"Zm9vYg==");
+        assert_eq!((~"fooba").to_base64(), ~"Zm9vYmE=");
+        assert_eq!((~"foobar").to_base64(), ~"Zm9vYmFy");
     }
 
     #[test]
     fn test_from_base64() {
-        assert_eq!("".from_base64(), str::to_bytes(""));
-        assert_eq!("Zg==".from_base64(), str::to_bytes("f"));
-        assert_eq!("Zm8=".from_base64(), str::to_bytes("fo"));
-        assert_eq!("Zm9v".from_base64(), str::to_bytes("foo"));
-        assert_eq!("Zm9vYg==".from_base64(), str::to_bytes("foob"));
-        assert_eq!("Zm9vYmE=".from_base64(), str::to_bytes("fooba"))
-        assert_eq!("Zm9vYmFy".from_base64(), str::to_bytes("foobar"));
+        assert_eq!((~"").from_base64(), str::to_bytes(""));
+        assert!((~"Zg==").from_base64() == str::to_bytes("f"));
+        assert_eq!((~"Zm8=").from_base64(), str::to_bytes("fo"));
+        assert_eq!((~"Zm9v").from_base64(), str::to_bytes("foo"));
+        assert!((~"Zm9vYg==").from_base64() == str::to_bytes("foob"));
+        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes("fooba"))
+        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes("foobar"));
     }
 }

branches/auto/src/librustc/middle/trans/base.rs

@@ -1506,7 +1506,7 @@ pub fn memzero(cx: block, llptr: ValueRef, llty: TypeRef) {
     let llptr = PointerCast(cx, llptr, T_ptr(T_i8()));
     let llzeroval = C_u8(0);
     let size = IntCast(cx, machine::llsize_of(ccx, llty), ccx.int_type);
-    let align = C_i32(llalign_of_min(ccx, llty) as i32);
+    let align = C_i32(1i32);
     let volatile = C_i1(false);
     Call(cx, llintrinsicfn, [llptr, llzeroval, size, align, volatile]);
 }

branches/auto/src/libstd/num/f32.rs

@@ -86,8 +86,6 @@ delegate!(
     fn erfc(n: c_float) -> c_float = c_float_utils::erfc,
     fn exp_m1(n: c_float) -> c_float = c_float_utils::exp_m1,
     fn abs_sub(a: c_float, b: c_float) -> c_float = c_float_utils::abs_sub,
-    fn fmax(a: c_float, b: c_float) -> c_float = c_float_utils::fmax,
-    fn fmin(a: c_float, b: c_float) -> c_float = c_float_utils::fmin,
     fn next_after(x: c_float, y: c_float) -> c_float = c_float_utils::next_after,
     fn frexp(n: c_float, value: &mut c_int) -> c_float = c_float_utils::frexp,
     fn hypot(x: c_float, y: c_float) -> c_float = c_float_utils::hypot,
@@ -147,6 +145,16 @@ pub fn ge(x: f32, y: f32) -> bool { return x >= y; }
 #[inline(always)]
 pub fn gt(x: f32, y: f32) -> bool { return x > y; }
 
+#[inline(always)]
+pub fn fmax(x: f32, y: f32) -> f32 {
+    if x >= y || y.is_NaN() { x } else { y }
+}
+
+#[inline(always)]
+pub fn fmin(x: f32, y: f32) -> f32 {
+    if x <= y || y.is_NaN() { x } else { y }
+}
+
 
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.

branches/auto/src/libstd/num/f64.rs

@@ -87,8 +87,6 @@ delegate!(
     fn erfc(n: c_double) -> c_double = c_double_utils::erfc,
     fn exp_m1(n: c_double) -> c_double = c_double_utils::exp_m1,
     fn abs_sub(a: c_double, b: c_double) -> c_double = c_double_utils::abs_sub,
-    fn fmax(a: c_double, b: c_double) -> c_double = c_double_utils::fmax,
-    fn fmin(a: c_double, b: c_double) -> c_double = c_double_utils::fmin,
     fn next_after(x: c_double, y: c_double) -> c_double = c_double_utils::next_after,
     fn frexp(n: c_double, value: &mut c_int) -> c_double = c_double_utils::frexp,
     fn hypot(x: c_double, y: c_double) -> c_double = c_double_utils::hypot,
@@ -172,6 +170,15 @@ pub fn ge(x: f64, y: f64) -> bool { return x >= y; }
 #[inline(always)]
 pub fn gt(x: f64, y: f64) -> bool { return x > y; }
 
+#[inline(always)]
+pub fn fmax(x: f64, y: f64) -> f64 {
+    if x >= y || y.is_NaN() { x } else { y }
+}
+
+#[inline(always)]
+pub fn fmin(x: f64, y: f64) -> f64 {
+    if x <= y || y.is_NaN() { x } else { y }
+}
 
 // FIXME (#1999): add is_normal, is_subnormal, and fpclassify
 

branches/auto/src/libstd/vec.rs

@@ -2347,16 +2347,16 @@ impl<T:Eq> OwnedEqVector<T> for ~[T] {
 }
 
 pub trait MutableVector<'self, T> {
-    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T];
+    fn mut_slice(&mut self, start: uint, end: uint) -> &'self mut [T];
 
     unsafe fn unsafe_mut_ref(&self, index: uint) -> *mut T;
     unsafe fn unsafe_set(&self, index: uint, val: T);
 }
 
 impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
     #[inline]
-    fn mut_slice(self, start: uint, end: uint) -> &'self mut [T] {
-        mut_slice(self, start, end)
+    fn mut_slice(&mut self, start: uint, end: uint) -> &'self mut [T] {
+        mut_slice(*self, start, end)
     }
 
     #[inline(always)]