---

yaml
---
r: 56979
b: refs/heads/try
c: 19cc352
h: refs/heads/master
i:
  56977: a303674
  56975: 1abd081
v: v3

Author: huonw

[refs]

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

branches/try/.gitignore

@@ -86,3 +86,4 @@ config.stamp
 .DS_Store
 src/etc/dl
 .settings/
+build/

branches/try/doc/tutorial.md

@@ -1669,6 +1669,9 @@ do spawn {
 }
 ~~~~
 
+If you want to see the output of `debug!` statements, you will need to turn on `debug!` logging.
+To enable `debug!` logging, set the RUST_LOG environment variable to `debug` (e.g., with bash, `export RUST_LOG=debug`)
+
 ## For loops
 
 The most common way to express iteration in Rust is with a `for`

branches/try/mk/rt.mk

@@ -76,7 +76,8 @@ RUNTIME_CXXS_$(1) := \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \
               rt/arch/$$(HOST_$(1))/gpr.cpp \
-              rt/rust_android_dummy.cpp
+              rt/rust_android_dummy.cpp \
+              rt/rust_test_helpers.cpp
 
 RUNTIME_CS_$(1) := rt/linenoise/linenoise.c rt/linenoise/utf8.c
 

branches/try/src/etc/x86.supp

@@ -654,3 +654,11 @@
    fun:_ZN5visit30visit_struct_dtor_helper_*
    ...
 }
+
+{
+   llvm-optimization-reads-uninitialized-memory-16
+   Memcheck:Cond
+   fun:_ZN7ast_map6map_fn*
+   fun:_ZN5visit30visit_struct_dtor_helper*
+   ...
+}

branches/try/src/libcore/io.rs

@@ -176,7 +176,7 @@ pub trait ReaderUtil {
     fn read_bytes(&self, len: uint) -> ~[u8];
 
     /**
-    * Reads up until a specific character or EOF.
+    * Reads up until a specific byte is seen or EOF.
     *
     * The `include` parameter specifies if the character should be included
     * in the returned string.
@@ -185,7 +185,7 @@ pub trait ReaderUtil {
     *
     * None right now.
     */
-    fn read_until(&self, c: char, include: bool) -> ~str;
+    fn read_until(&self, c: u8, include: bool) -> ~str;
 
     /**
     * Reads up until the first '\n' or EOF.
@@ -577,7 +577,7 @@ impl<T:Reader> ReaderUtil for T {
         bytes
     }
 
-    fn read_until(&self, c: char, include: bool) -> ~str {
+    fn read_until(&self, c: u8, include: bool) -> ~str {
         let mut bytes = ~[];
         loop {
             let ch = self.read_byte();
@@ -593,7 +593,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_line(&self) -> ~str {
-        self.read_until('\n', false)
+        self.read_until('\n' as u8, false)
     }
 
     fn read_chars(&self, n: uint) -> ~[char] {
@@ -667,7 +667,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_c_str(&self) -> ~str {
-        self.read_until(0 as char, false)
+        self.read_until(0u8, false)
     }
 
     fn read_whole_stream(&self) -> ~[u8] {
@@ -693,7 +693,7 @@ impl<T:Reader> ReaderUtil for T {
             // include the \n, so that we can distinguish an entirely empty
             // line read after "...\n", and the trailing empty line in
             // "...\n\n".
-            let mut line = self.read_until('\n', true);
+            let mut line = self.read_until('\n' as u8, true);
 
             // blank line at the end of the reader is ignored
             if self.eof() && line.is_empty() { break; }

branches/try/src/libcore/iterator.rs

@@ -22,6 +22,7 @@ pub trait IteratorUtil<A> {
     // FIXME: #5898: should be called map
     fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, Self>;
     fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> FilterIterator<'r, A, Self>;
+    fn enumerate(self) -> EnumerateIterator<Self>;
     fn advance(&mut self, f: &fn(A) -> bool);
 }
 
@@ -42,6 +43,11 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
         FilterIterator{iter: self, predicate: predicate}
     }
 
+    #[inline(always)]
+    fn enumerate(self) -> EnumerateIterator<T> {
+        EnumerateIterator{iter: self, count: 0}
+    }
+
     /// A shim implementing the `for` loop iteration protocol for iterator objects
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) {
@@ -104,3 +110,22 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for MapIterator<'self, A, B, T> {
         }
     }
 }
+
+pub struct EnumerateIterator<T> {
+    priv iter: T,
+    priv count: uint
+}
+
+impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<T> {
+    #[inline]
+    fn next(&mut self) -> Option<(uint, A)> {
+        match self.iter.next() {
+            Some(a) => {
+                let ret = Some((self.count, a));
+                self.count += 1;
+                ret
+            }
+            _ => None
+        }
+    }
+}

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

@@ -288,32 +288,26 @@ impl num::One for f32 {
 
 #[cfg(notest)]
 impl ops::Add<f32,f32> for f32 {
-    #[inline(always)]
     fn add(&self, other: &f32) -> f32 { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<f32,f32> for f32 {
-    #[inline(always)]
     fn sub(&self, other: &f32) -> f32 { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<f32,f32> for f32 {
-    #[inline(always)]
     fn mul(&self, other: &f32) -> f32 { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<f32,f32> for f32 {
-    #[inline(always)]
     fn div(&self, other: &f32) -> f32 { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<f32,f32> for f32 {
-    #[inline(always)]
     fn modulo(&self, other: &f32) -> f32 { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<f32> for f32 {
-    #[inline(always)]
     fn neg(&self) -> f32 { -*self }
 }
 

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

@@ -310,32 +310,26 @@ impl num::One for f64 {
 
 #[cfg(notest)]
 impl ops::Add<f64,f64> for f64 {
-    #[inline(always)]
     fn add(&self, other: &f64) -> f64 { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<f64,f64> for f64 {
-    #[inline(always)]
     fn sub(&self, other: &f64) -> f64 { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<f64,f64> for f64 {
-    #[inline(always)]
     fn mul(&self, other: &f64) -> f64 { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<f64,f64> for f64 {
-    #[inline(always)]
     fn div(&self, other: &f64) -> f64 { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<f64,f64> for f64 {
-    #[inline(always)]
     fn modulo(&self, other: &f64) -> f64 { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<f64> for f64 {
-    #[inline(always)]
     fn neg(&self) -> f64 { -*self }
 }
 

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

@@ -387,21 +387,15 @@ pub fn tan(x: float) -> float {
 
 #[cfg(notest)]
 impl Eq for float {
-    #[inline(always)]
     fn eq(&self, other: &float) -> bool { (*self) == (*other) }
-    #[inline(always)]
     fn ne(&self, other: &float) -> bool { (*self) != (*other) }
 }
 
 #[cfg(notest)]
 impl Ord for float {
-    #[inline(always)]
     fn lt(&self, other: &float) -> bool { (*self) < (*other) }
-    #[inline(always)]
     fn le(&self, other: &float) -> bool { (*self) <= (*other) }
-    #[inline(always)]
     fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
-    #[inline(always)]
     fn gt(&self, other: &float) -> bool { (*self) > (*other) }
 }
 
@@ -450,32 +444,26 @@ impl num::Round for float {
 
 #[cfg(notest)]
 impl ops::Add<float,float> for float {
-    #[inline(always)]
     fn add(&self, other: &float) -> float { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<float,float> for float {
-    #[inline(always)]
     fn sub(&self, other: &float) -> float { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<float,float> for float {
-    #[inline(always)]
     fn mul(&self, other: &float) -> float { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<float,float> for float {
-    #[inline(always)]
     fn div(&self, other: &float) -> float { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<float,float> for float {
-    #[inline(always)]
     fn modulo(&self, other: &float) -> float { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<float> for float {
-    #[inline(always)]
     fn neg(&self) -> float { -*self }
 }
 

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

@@ -177,66 +177,29 @@ impl num::One for T {
 
 #[cfg(notest)]
 impl ops::Add<T,T> for T {
-    #[inline(always)]
     fn add(&self, other: &T) -> T { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<T,T> for T {
-    #[inline(always)]
     fn sub(&self, other: &T) -> T { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<T,T> for T {
-    #[inline(always)]
     fn mul(&self, other: &T) -> T { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<T,T> for T {
-    #[inline(always)]
     fn div(&self, other: &T) -> T { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<T,T> for T {
-    #[inline(always)]
     fn modulo(&self, other: &T) -> T { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<T> for T {
-    #[inline(always)]
     fn neg(&self) -> T { -*self }
 }
 
-#[cfg(notest)]
-impl ops::BitOr<T,T> for T {
-    #[inline(always)]
-    fn bitor(&self, other: &T) -> T { *self | *other }
-}
-#[cfg(notest)]
-impl ops::BitAnd<T,T> for T {
-    #[inline(always)]
-    fn bitand(&self, other: &T) -> T { *self & *other }
-}
-#[cfg(notest)]
-impl ops::BitXor<T,T> for T {
-    #[inline(always)]
-    fn bitxor(&self, other: &T) -> T { *self ^ *other }
-}
-#[cfg(notest)]
-impl ops::Shl<T,T> for T {
-    #[inline(always)]
-    fn shl(&self, other: &T) -> T { *self << *other }
-}
-#[cfg(notest)]
-impl ops::Shr<T,T> for T {
-    #[inline(always)]
-    fn shr(&self, other: &T) -> T { *self >> *other }
-}
-#[cfg(notest)]
-impl ops::Not<T> for T {
-    #[inline(always)]
-    fn not(&self) -> T { !*self }
-}
-
 // String conversion functions and impl str -> num
 
 /// Parse a string as a number in base 10.
@@ -320,16 +283,6 @@ mod tests {
     use super::inst::T;
     use prelude::*;
 
-    #[test]
-    fn test_bitwise_ops() {
-        assert!(0b1110 as T == (0b1100 as T).bitor(&(0b1010 as T)));
-        assert!(0b1000 as T == (0b1100 as T).bitand(&(0b1010 as T)));
-        assert!(0b0110 as T == (0b1100 as T).bitxor(&(0b1010 as T)));
-        assert!(0b1110 as T == (0b0111 as T).shl(&(1 as T)));
-        assert!(0b0111 as T == (0b1110 as T).shr(&(1 as T)));
-        assert!(-(0b11 as T) - (1 as T) == (0b11 as T).not());
-    }
-
     #[test]
     fn test_from_str() {
         assert!(from_str(~"0") == Some(0 as T));