---

yaml
---
r: 46589
b: refs/heads/auto
c: 1b10170
h: refs/heads/master
i:
  46587: 3dfbbe5
v: v3

Author: brson

[refs]

@@ -14,4 +14,4 @@ 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: 5fc0eccdfa1c81d9759b0592e5b86b0ff7fd4fa8
+refs/heads/auto: 1b1017087be4e842ef0ff43486da8b4e9b085f14

branches/auto/configure

@@ -678,7 +678,7 @@ do
         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
         then
-            LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
+            LLVM_DBG_OPTS=""
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts

branches/auto/doc/tutorial.md

@@ -1126,7 +1126,7 @@ points to.
 
 ~~~
 let managed = @mut 10;
-let mut owned = ~20;
+let owned = ~mut 20;
 
 let mut value = 30;
 let borrowed = &mut value;

branches/auto/src/libcore/at_vec.rs

@@ -168,7 +168,7 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    impl<T:Copy> Add<&[const T],@[T]> for @[T] {
+    pub impl<T:Copy> Add<&[const T],@[T]> for @[T] {
         #[inline(always)]
         pure fn add(&self, rhs: & &self/[const T]) -> @[T] {
             append(*self, (*rhs))

branches/auto/src/libcore/dvec.rs

@@ -133,6 +133,18 @@ impl<A> DVec<A> {
         self.check_out(|v| self.give_back(f(v)))
     }
 
+    /**
+     * Swaps out the current vector and hands it off to a user-provided
+     * function `f`.  The function should transform it however is desired
+     * and return a new vector to replace it with.
+     */
+    #[inline(always)]
+    fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
+        do self.swap |v| {
+            vec::cast_from_mut(f(vec::cast_to_mut(v)))
+        }
+    }
+
     /// Returns the number of elements currently in the dvec
     #[inline(always)]
     pure fn len() -> uint {
@@ -205,7 +217,7 @@ impl<A> DVec<A> {
     }
 
     /// Gives access to the vector as a slice with mutable contents
-    fn borrow_mut<R>(op: &fn(x: &mut [A]) -> R) -> R {
+    fn borrow_mut<R>(op: fn(x: &[mut A]) -> R) -> R {
         do self.check_out |v| {
             let mut v = v;
             let result = op(v);

branches/auto/src/libcore/hash.rs

@@ -186,46 +186,42 @@ fn SipState(key0: u64, key1: u64) -> SipState {
     state
 }
 
-// sadly, these macro definitions can't appear later,
-// because they're needed in the following defs;
-// this design could be improved.
-
-macro_rules! u8to64_le (
-    ($buf:expr, $i:expr) =>
-    ($buf[0+$i] as u64 |
-     $buf[1+$i] as u64 << 8 |
-     $buf[2+$i] as u64 << 16 |
-     $buf[3+$i] as u64 << 24 |
-     $buf[4+$i] as u64 << 32 |
-     $buf[5+$i] as u64 << 40 |
-     $buf[6+$i] as u64 << 48 |
-     $buf[7+$i] as u64 << 56)
-)
-
-macro_rules! rotl (
-    ($x:expr, $b:expr) =>
-    (($x << $b) | ($x >> (64 - $b)))
-)
-
-macro_rules! compress (
-    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
-    ({
-        $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0;
-        $v0 = rotl!($v0, 32);
-        $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2;
-        $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0;
-        $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2;
-        $v2 = rotl!($v2, 32);
-    })
-)
-
 
 impl io::Writer for SipState {
 
     // Methods for io::writer
     #[inline(always)]
     fn write(&self, msg: &[const u8]) {
 
+        macro_rules! u8to64_le (
+            ($buf:expr, $i:expr) =>
+            ($buf[0+$i] as u64 |
+             $buf[1+$i] as u64 << 8 |
+             $buf[2+$i] as u64 << 16 |
+             $buf[3+$i] as u64 << 24 |
+             $buf[4+$i] as u64 << 32 |
+             $buf[5+$i] as u64 << 40 |
+             $buf[6+$i] as u64 << 48 |
+             $buf[7+$i] as u64 << 56)
+        );
+
+        macro_rules! rotl (
+            ($x:expr, $b:expr) =>
+            (($x << $b) | ($x >> (64 - $b)))
+        );
+
+        macro_rules! compress (
+            ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
+            ({
+                $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0;
+                $v0 = rotl!($v0, 32);
+                $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2;
+                $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0;
+                $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2;
+                $v2 = rotl!($v2, 32);
+            })
+        );
+
         let length = msg.len();
         self.length += length;
 

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

@@ -284,7 +284,7 @@ impl num::One for f32 {
     static pure fn one() -> f32 { 1.0 }
 }
 
-impl NumCast for f32 {
+pub impl NumCast for f32 {
     /**
      * Cast `n` to an `f32`
      */

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

@@ -299,7 +299,7 @@ impl cmp::Ord for f64 {
     pure fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
 }
 
-impl NumCast for f64 {
+pub impl NumCast for f64 {
     /**
      * Cast `n` to an `f64`
      */

branches/auto/src/libcore/num/float.rs

@@ -420,7 +420,7 @@ impl num::One for float {
     static pure fn one() -> float { 1.0 }
 }
 
-impl NumCast for float {
+pub impl NumCast for float {
     /**
      * Cast `n` to a `float`
      */

branches/auto/src/libcore/num/int-template/i16.rs

@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u16::bits;
 }
 
-impl NumCast for i16 {
+pub impl NumCast for i16 {
     /**
      * Cast `n` to a `i16`
      */

branches/auto/src/libcore/num/int-template/i32.rs

@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u32::bits;
 }
 
-impl NumCast for i32 {
+pub impl NumCast for i32 {
     /**
      * Cast `n` to a `i32`
      */

branches/auto/src/libcore/num/int-template/i64.rs

@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u64::bits;
 }
 
-impl NumCast for i64 {
+pub impl NumCast for i64 {
     /**
      * Cast `n` to a `i64`
      */

branches/auto/src/libcore/num/int-template/i8.rs

@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u8::bits;
 }
 
-impl NumCast for i8 {
+pub impl NumCast for i8 {
     /**
      * Cast `n` to a `i8`
      */

branches/auto/src/libcore/num/int-template/int.rs

@@ -58,7 +58,7 @@ mod inst {
     }
 }
 
-impl NumCast for int {
+pub impl NumCast for int {
     /**
      * Cast `n` to a `int`
      */

branches/auto/src/libcore/num/uint-template/u16.rs

@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 16;
 }
 
-impl NumCast for u16 {
+pub impl NumCast for u16 {
     /**
      * Cast `n` to a `u16`
      */

branches/auto/src/libcore/num/uint-template/u32.rs

@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 32;
 }
 
-impl NumCast for u32 {
+pub impl NumCast for u32 {
     /**
      * Cast `n` to a `u32`
      */

branches/auto/src/libcore/num/uint-template/u64.rs

@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 64;
 }
 
-impl NumCast for u64 {
+pub impl NumCast for u64 {
     /**
      * Cast `n` to a `u64`
      */

branches/auto/src/libcore/num/uint-template/u8.rs

@@ -26,7 +26,7 @@ mod inst {
     pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
 }
 
-impl NumCast for u8 {
+pub impl NumCast for u8 {
     /**
      * Cast `n` to a `u8`
      */

branches/auto/src/libcore/num/uint-template/uint.rs

@@ -110,7 +110,7 @@ pub mod inst {
         return true;
     }
 
-    impl iter::Times for uint {
+    pub impl iter::Times for uint {
         #[inline(always)]
         /**
         * A convenience form for basic iteration. Given a uint `x`,
@@ -209,7 +209,7 @@ pub mod inst {
     }
 }
 
-impl NumCast for uint {
+pub impl NumCast for uint {
     /**
      * Cast `n` to a `uint`
      */

branches/auto/src/libcore/option.rs

@@ -56,7 +56,7 @@ pub enum Option<T> {
     Some(T),
 }
 
-impl<T:Ord> Ord for Option<T> {
+pub impl<T:Ord> Ord for Option<T> {
     pure fn lt(&self, other: &Option<T>) -> bool {
         match (self, other) {
             (&None, &None) => false,

branches/auto/src/libcore/os.rs

@@ -109,7 +109,7 @@ pub mod win32 {
             let mut done = false;
             while !done {
                 let mut k: DWORD = 0;
-                let mut buf = vec::from_elem(n as uint, 0u16);
+                let buf = vec::cast_to_mut(vec::from_elem(n as uint, 0u16));
                 do vec::as_mut_buf(buf) |b, _sz| {
                     k = f(b, TMPBUF_SZ as DWORD);
                     if k == (0 as DWORD) {

branches/auto/src/libcore/owned.rs

@@ -13,22 +13,22 @@
 use cmp::{Eq, Ord};
 
 #[cfg(notest)]
-impl<T:Eq> Eq for ~T {
+impl<T:Eq> Eq for ~const T {
     #[inline(always)]
-    pure fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) }
+    pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
-    pure fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) }
+    pure fn ne(&self, other: &~const T) -> bool { *(*self) != *(*other) }
 }
 
 #[cfg(notest)]
-impl<T:Ord> Ord for ~T {
+impl<T:Ord> Ord for ~const T {
     #[inline(always)]
-    pure fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) }
+    pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
     #[inline(always)]
-    pure fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) }
+    pure fn le(&self, other: &~const T) -> bool { *(*self) <= *(*other) }
     #[inline(always)]
-    pure fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) }
+    pure fn ge(&self, other: &~const T) -> bool { *(*self) >= *(*other) }
     #[inline(always)]
-    pure fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) }
+    pure fn gt(&self, other: &~const T) -> bool { *(*self) > *(*other) }
 }
 

branches/auto/src/libcore/rt.rs

@@ -11,7 +11,7 @@
 //! Runtime calls emitted by the compiler.
 
 use cast::transmute;
-use libc::{c_char, c_uchar, c_void, size_t, uintptr_t, c_int};
+use libc::{c_char, c_uchar, c_void, size_t, uintptr_t};
 use managed::raw::BoxRepr;
 use str;
 use sys;
@@ -121,21 +121,6 @@ pub unsafe fn strdup_uniq(ptr: *c_uchar, len: uint) -> ~str {
     str::raw::from_buf_len(ptr, len)
 }
 
-#[lang="start"]
-pub fn start(main: *u8, argc: int, argv: *c_char,
-             crate_map: *u8) -> int {
-
-    extern {
-        fn rust_start(main: *c_void, argc: c_int, argv: *c_char,
-                      crate_map: *c_void) -> c_int;
-    }
-
-    unsafe {
-        return rust_start(main as *c_void, argc as c_int, argv,
-                          crate_map as *c_void) as int;
-    }
-}
-
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

branches/auto/src/libcore/str.rs

@@ -590,40 +590,6 @@ pub pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
     result
 }
 
-/// Levenshtein Distance between two strings
-pub fn levdistance(s: &str, t: &str) -> uint {
-
-    let slen = str::len(s);
-    let tlen = str::len(t);
-
-    if slen == 0 { return tlen; }
-    if tlen == 0 { return slen; }
-
-    let mut dcol = vec::from_fn(tlen + 1, |x| x);
-
-    for str::each_chari(s) |i, sc| {
-
-        let mut current = i;
-        dcol[0] = current + 1;
-
-        for str::each_chari(t) |j, tc| {
-
-            let mut next = dcol[j + 1];
-
-            if sc == tc {
-                dcol[j + 1] = current;
-            } else {
-                dcol[j + 1] = ::cmp::min(current, next);
-                dcol[j + 1] = ::cmp::min(dcol[j + 1], dcol[j]) + 1;
-            }
-
-            current = next;
-        }
-    }
-
-    return dcol[tlen];
-}
-
 /**
  * Splits a string into a vector of the substrings separated by LF ('\n')
  */
@@ -2362,7 +2328,7 @@ pub trait OwnedStr {
     fn push_char(&mut self, c: char);
 }
 
-impl OwnedStr for ~str {
+pub impl OwnedStr for ~str {
     fn push_str(&mut self, v: &str) {
         push_str(self, v);
     }