---

yaml
---
r: 57197
b: refs/heads/try
c: e1be9ae
h: refs/heads/master
i:
  57195: 4494c52
v: v3

Author: Kimundi

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: 106fd12423491625b78326a2d2055d7e1d43464f
+refs/heads/try: e1be9ae22468e19d66daaebbceeeeaea2e75f903
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/iterator.rs

@@ -312,6 +312,19 @@ impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
     }
 }
 
+pub struct ScanIterator<'self, A, B, T, St> {
+    priv iter: T,
+    priv f: &'self fn(&mut St, A) -> Option<B>,
+    state: St
+}
+
+impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
+    #[inline]
+    fn next(&mut self) -> Option<B> {
+        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+    }
+}
+
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
     state: St
@@ -335,16 +348,25 @@ impl<'self, A, St> Iterator<A> for UnfoldrIterator<'self, A, St> {
     }
 }
 
-pub struct ScanIterator<'self, A, B, T, St> {
-    priv iter: T,
-    priv f: &'self fn(&mut St, A) -> Option<B>,
-    state: St
+/// An infinite iterator starting at `start` and advancing by `step` with each iteration
+pub struct Counter<A> {
+    state: A,
+    step: A
 }
 
-impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for ScanIterator<'self, A, B, T, St> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        self.iter.next().chain(|a| (self.f)(&mut self.state, a))
+pub impl<A> Counter<A> {
+    #[inline(always)]
+    fn new(start: A, step: A) -> Counter<A> {
+        Counter{state: start, step: step}
+    }
+}
+
+impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
+    #[inline(always)]
+    fn next(&mut self) -> Option<A> {
+        let result = self.state.clone();
+        self.state = self.state.add(&self.step); // FIXME: #6050
+        Some(result)
     }
 }
 
@@ -353,6 +375,13 @@ mod tests {
     use super::*;
     use prelude::*;
 
+    #[test]
+    fn test_counter_to_vec() {
+        let mut it = Counter::new(0, 5).take(10);
+        let xs = iter::iter_to_vec(|f| it.advance(f));
+        assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
+    }
+
     #[test]
     fn test_iterator_chain() {
         let xs = [0u, 1, 2, 3, 4, 5];

branches/try/src/libcore/sys.rs

@@ -165,7 +165,42 @@ pub fn log_str<T>(t: &T) -> ~str {
     }
 }
 
-/** Initiate task failure */
+/// Trait for initiating task failure.
+pub trait FailWithCause {
+    /// Fail the current task, taking ownership of `cause`
+    fn fail_with(cause: Self, file: &'static str, line: uint) -> !;
+}
+
+impl FailWithCause for ~str {
+    fn fail_with(cause: ~str, file: &'static str, line: uint) -> ! {
+        do str::as_buf(cause) |msg_buf, _msg_len| {
+            do str::as_buf(file) |file_buf, _file_len| {
+                unsafe {
+                    let msg_buf = cast::transmute(msg_buf);
+                    let file_buf = cast::transmute(file_buf);
+                    begin_unwind_(msg_buf, file_buf, line as libc::size_t)
+                }
+            }
+        }
+    }
+}
+
+impl FailWithCause for &'static str {
+    fn fail_with(cause: &'static str, file: &'static str, line: uint) -> ! {
+        do str::as_buf(cause) |msg_buf, _msg_len| {
+            do str::as_buf(file) |file_buf, _file_len| {
+                unsafe {
+                    let msg_buf = cast::transmute(msg_buf);
+                    let file_buf = cast::transmute(file_buf);
+                    begin_unwind_(msg_buf, file_buf, line as libc::size_t)
+                }
+            }
+        }
+    }
+}
+
+// NOTE: remove function after snapshot
+#[cfg(stage0)]
 pub fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! {
     do str::as_buf(msg) |msg_buf, _msg_len| {
         do str::as_buf(file) |file_buf, _file_len| {
@@ -187,6 +222,8 @@ pub fn begin_unwind_(msg: *c_char, file: *c_char, line: size_t) -> ! {
     }
 }
 
+// NOTE: remove function after snapshot
+#[cfg(stage0)]
 pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! {
     let (msg, file) = (msg.to_owned(), file.to_owned());
     begin_unwind(~"assertion failed: " + msg, file, line)
@@ -297,6 +334,14 @@ mod tests {
             assert!(new_f(20) == 30);
         }
     }
+
+    #[test]
+    #[should_fail]
+    fn fail_static() { FailWithCause::fail_with("cause", file!(), line!())  }
+
+    #[test]
+    #[should_fail]
+    fn fail_owned() { FailWithCause::fail_with(~"cause", file!(), line!())  }
 }
 
 // Local Variables:

branches/try/src/libsyntax/ext/auto_encode.rs

@@ -1101,7 +1101,7 @@ fn mk_enum_deser_body(
     };
 
     let quoted_expr = copy quote_expr!(
-      ::core::sys::begin_unwind(~"explicit failure", ~"empty", 1);
+      ::core::sys::FailWithCause::fail_with("explicit failure", "empty", 1);
     ).node;
 
     let impossible_case = ast::arm {

branches/try/src/libsyntax/ext/build.rs

@@ -474,11 +474,12 @@ pub fn mk_unreachable(cx: @ext_ctxt, span: span) -> @ast::expr {
         ~[
             cx.ident_of(~"core"),
             cx.ident_of(~"sys"),
-            cx.ident_of(~"begin_unwind"),
+            cx.ident_of(~"FailWithCause"),
+            cx.ident_of(~"fail_with"),
         ],
         ~[
-            mk_uniq_str(cx, span, ~"internal error: entered unreachable code"),
-            mk_uniq_str(cx, span, loc.file.name),
+            mk_base_str(cx, span, ~"internal error: entered unreachable code"),
+            mk_base_str(cx, span, loc.file.name),
             mk_uint(cx, span, loc.line),
         ]
     )

branches/try/src/libsyntax/ext/expand.rs

@@ -415,6 +415,7 @@ pub fn core_macros() -> ~str {
             __log(1u32, fmt!( $($arg),+ ))
         )
     )
+
     macro_rules! warn (
         ($arg:expr) => (
             __log(2u32, fmt!( \"%?\", $arg ))
@@ -423,6 +424,7 @@ pub fn core_macros() -> ~str {
             __log(2u32, fmt!( $($arg),+ ))
         )
     )
+
     macro_rules! info (
         ($arg:expr) => (
             __log(3u32, fmt!( \"%?\", $arg ))
@@ -431,6 +433,7 @@ pub fn core_macros() -> ~str {
             __log(3u32, fmt!( $($arg),+ ))
         )
     )
+
     macro_rules! debug (
         ($arg:expr) => (
             __log(4u32, fmt!( \"%?\", $arg ))
@@ -441,35 +444,48 @@ pub fn core_macros() -> ~str {
     )
 
     macro_rules! fail(
-        ($msg: expr) => (
-            ::core::sys::begin_unwind($msg, file!().to_owned(), line!())
-        );
         () => (
-            fail!(~\"explicit failure\")
+            fail!(\"explicit failure\")
+        );
+        ($msg:expr) => (
+            ::core::sys::FailWithCause::fail_with($msg, file!(), line!())
+        );
+        ($( $arg:expr ),+) => (
+            ::core::sys::FailWithCause::fail_with(fmt!( $($arg),+ ), file!(), line!())
         )
     )
 
     macro_rules! assert(
         ($cond:expr) => {
             if !$cond {
-                ::core::sys::fail_assert(stringify!($cond), file!(), line!())
+                ::core::sys::FailWithCause::fail_with(
+                    ~\"assertion failed: \" + stringify!($cond), file!(), line!())
             }
         };
         ($cond:expr, $msg:expr) => {
             if !$cond {
-                ::core::sys::fail_assert($msg, file!(), line!())
+                ::core::sys::FailWithCause::fail_with($msg, file!(), line!())
+            }
+        };
+        ($cond:expr, $( $arg:expr ),+) => {
+            if !$cond {
+                ::core::sys::FailWithCause::fail_with(fmt!( $($arg),+ ), file!(), line!())
             }
         }
     )
 
     macro_rules! assert_eq (
-        ($given:expr , $expected:expr) =>
-        ({let given_val = $given;
-          let expected_val = $expected;
-          // check both directions of equality....
-          if !((given_val == expected_val) && (expected_val == given_val)) {
-            fail!(fmt!(\"expected: %?, given: %?\",expected_val,given_val));
-        }}))
+        ($given:expr , $expected:expr) => (
+            {
+                let given_val = $given;
+                let expected_val = $expected;
+                // check both directions of equality....
+                if !((given_val == expected_val) && (expected_val == given_val)) {
+                    fail!(fmt!(\"left: %? != right: %?\", given_val, expected_val));
+                }
+            }
+        )
+    )
 
     macro_rules! condition (
 

branches/try/src/libsyntax/ext/tt/transcribe.rs

@@ -22,8 +22,6 @@ use core::hashmap::HashMap;
 use core::option;
 use core::vec;
 
-/* FIXME #2811: figure out how to have a uniquely linked stack, and change to
-   `~` */
 ///an unzipping of `token_tree`s
 struct TtFrame {
     forest: @mut ~[ast::token_tree],

branches/try/src/rt/isaac/randport.cpp

@@ -6,7 +6,6 @@ rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain
   970719: use context, not global variables, for internal state
   980324: make a portable version
   010626: Note this is public domain
-  100725: Mask on use of >32 bits, not on assignment: from Paul Eggert
 ------------------------------------------------------------------------------
 */
 #ifndef STANDARD
@@ -28,37 +27,37 @@ rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain
 
 void     isaac(randctx *ctx)
 {
-   ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
    mm=ctx->randmem; r=ctx->randrsl;
-   a = ctx->randa; b = ctx->randb + (++ctx->randc);
+   a = ctx->randa; b = (ctx->randb + (++ctx->randc)) & 0xffffffff;
    for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
    {
       rngstep( a<<13, a, b, mm, m, m2, r, x);
-      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
       rngstep( a<<2 , a, b, mm, m, m2, r, x);
-      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
    }
    for (m2 = mm; m2<mend; )
    {
       rngstep( a<<13, a, b, mm, m, m2, r, x);
-      rngstep( (a & 0xffffffff) >>6 , a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
       rngstep( a<<2 , a, b, mm, m, m2, r, x);
-      rngstep( (a & 0xffffffff) >>16, a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
    }
    ctx->randb = b; ctx->randa = a;
 }
 
 
 #define mix(a,b,c,d,e,f,g,h) \
 { \
-   a^=b<<11;              d+=a; b+=c; \
-   b^=(c&0xffffffff)>>2;  e+=b; c+=d; \
-   c^=d<<8;               f+=c; d+=e; \
-   d^=(e&0xffffffff)>>16; g+=d; e+=f; \
-   e^=f<<10;              h+=e; f+=g; \
-   f^=(g&0xffffffff)>>4;  a+=f; g+=h; \
-   g^=h<<8;               b+=g; h+=a; \
-   h^=(a&0xffffffff)>>9;  c+=h; a+=b; \
+   a^=b<<11; d+=a; b+=c; \
+   b^=c>>2;  e+=b; c+=d; \
+   c^=d<<8;  f+=c; d+=e; \
+   d^=e>>16; g+=d; e+=f; \
+   e^=f<<10; h+=e; f+=g; \
+   f^=g>>4;  a+=f; g+=h; \
+   g^=h<<8;  b+=g; h+=a; \
+   h^=a>>9;  c+=h; a+=b; \
 }
 
 /* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
@@ -82,21 +81,17 @@ void randinit(randctx *ctx, word flag)
      /* initialize using the contents of r[] as the seed */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=r[i  ]; b+=r[i+1];
-       c+=r[i+2]; d+=r[i+3];
-       e+=r[i+4]; f+=r[i+5];
-       g+=r[i+6]; h+=r[i+7];
+       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
        mix(a,b,c,d,e,f,g,h);
        m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
        m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
      }
      /* do a second pass to make all of the seed affect all of m */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=m[i  ]; b+=m[i+1];
-       c+=m[i+2]; d+=m[i+3];
-       e+=m[i+4]; f+=m[i+5];
-       g+=m[i+6]; h+=m[i+7];
+       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
        mix(a,b,c,d,e,f,g,h);
        m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
        m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;

branches/try/src/test/compile-fail/die-not-static.rs

@@ -0,0 +1,7 @@
+// error-pattern:illegal borrow: borrowed value does not live long enough
+
+fn main() {
+    let v = ~"test";
+    let sslice = str::slice(v, 0, v.len());
+    fail!(sslice);
+}

branches/try/src/test/compile-fail/die-not-unique.rs

@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:mismatched types
+// error-pattern:failed to find an implementation of trait core::sys::FailWithCause for int
 
 fn main() { fail!(5); }

branches/try/src/test/compile-fail/fail-expr.rs

@@ -8,5 +8,5 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:expected `~str` but found `~[int]`
+// error-pattern:failed to find an implementation of trait core::sys::FailWithCause for ~[int]
 fn main() { fail!(~[0i]); }

branches/try/src/test/compile-fail/fail-type-err.rs

@@ -1,4 +1,4 @@
-// error-pattern:expected: 15, given: 14
+// error-pattern:left: 14 != right: 15
 
 #[deriving(Eq)]
 struct Point { x : int }