---

yaml
---
r: 22140
b: refs/heads/snap-stage3
c: b3f418c
h: refs/heads/master
v: v3

Author: z0w0

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e430a699f2c60890d9b86069fd0c68a70ece7120
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bc9efaad9c978f71bd7ac2c91efbc957e25d43fb
+refs/heads/snap-stage3: b3f418c10ed88163f6d1c6774b51eb69def521f8
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/AUTHORS.txt

@@ -17,7 +17,6 @@ Ben Striegel <[email protected]>
 Benjamin Herr <[email protected]>
 Benjamin Jackman <[email protected]>
 Benjamin Kircher <[email protected]>
-Benjamin Peterson <[email protected]>
 Brendan Eich <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>

branches/snap-stage3/doc/tutorial.md

@@ -616,7 +616,7 @@ literals and most enum variants.
 
 `while` produces a loop that runs as long as its given condition
 (which must have type `bool`) evaluates to true. Inside a loop, the
-keyword `break` can be used to abort the loop, and `loop` can be used
+keyword `break` can be used to abort the loop, and `again` can be used
 to abort the current iteration and continue with the next.
 
 ~~~~
@@ -1564,7 +1564,7 @@ Empty argument lists can be omitted from `do` expressions.
 
 Most iteration in Rust is done with `for` loops. Like `do`,
 `for` is a nice syntax for doing control flow with closures.
-Additionally, within a `for` loop, `break`, `loop`, and `return`
+Additionally, within a `for` loop, `break`, `again`, and `return`
 work just as they do with `while` and `loop`.
 
 Consider again our `each` function, this time improved to
@@ -1599,7 +1599,7 @@ With `for`, functions like `each` can be treated more
 like builtin looping structures. When calling `each`
 in a `for` loop, instead of returning `false` to break
 out of the loop, you just write `break`. To skip ahead
-to the next iteration, write `loop`.
+to the next iteration, write `again`.
 
 ~~~~
 # use each = vec::each;

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -58,7 +58,7 @@ fn parse_config(args: ~[~str]) -> config {
              } else { option::None },
          logfile: option::map(&getopts::opt_maybe_str(matches,
                                                      ~"logfile"),
-                              |s| Path(*s)),
+                              |s| Path(s)),
          runtool: getopts::opt_maybe_str(matches, ~"runtool"),
          rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
          jit: getopts::opt_present(matches, ~"jit"),

branches/snap-stage3/src/compiletest/header.rs

@@ -41,11 +41,11 @@ fn load_props(testfile: &Path) -> test_props {
         }
 
         do parse_aux_build(ln).iter |ab| {
-            aux_builds.push(*ab);
+            aux_builds.push(ab);
         }
 
         do parse_exec_env(ln).iter |ee| {
-            exec_env.push(*ee);
+            exec_env.push(ee);
         }
     };
     return {
@@ -103,7 +103,7 @@ fn parse_compile_flags(line: ~str) -> Option<~str> {
 fn parse_exec_env(line: ~str) -> Option<(~str, ~str)> {
     do parse_name_value_directive(line, ~"exec-env").map |nv| {
         // nv is either FOO or FOO=BAR
-        let strs = str::splitn_char(*nv, '=', 1u);
+        let strs = str::splitn_char(nv, '=', 1u);
         match strs.len() {
           1u => (strs[0], ~""),
           2u => (strs[0], strs[1]),

branches/snap-stage3/src/libcore/cast.rs

@@ -2,6 +2,7 @@
 
 #[abi = "rust-intrinsic"]
 extern mod rusti {
+    #[legacy_exports];
     fn forget<T>(-x: T);
     fn reinterpret_cast<T, U>(e: T) -> U;
 }

branches/snap-stage3/src/libcore/char.rs

@@ -39,6 +39,14 @@ use cmp::Eq;
     Cn  Unassigned  a reserved unassigned code point or a noncharacter
 */
 
+export is_alphabetic,
+       is_XID_start, is_XID_continue,
+       is_lowercase, is_uppercase,
+       is_whitespace, is_alphanumeric,
+       is_ascii, is_digit,
+       to_digit, cmp,
+       escape_default, escape_unicode;
+
 pub use is_alphabetic = unicode::derived_property::Alphabetic;
 pub use is_XID_start = unicode::derived_property::XID_Start;
 pub use is_XID_continue = unicode::derived_property::XID_Continue;
@@ -48,15 +56,15 @@ pub use is_XID_continue = unicode::derived_property::XID_Continue;
  * Indicates whether a character is in lower case, defined
  * in terms of the Unicode General Category 'Ll'
  */
-pub pure fn is_lowercase(c: char) -> bool {
+pure fn is_lowercase(c: char) -> bool {
     return unicode::general_category::Ll(c);
 }
 
 /**
  * Indicates whether a character is in upper case, defined
  * in terms of the Unicode General Category 'Lu'.
  */
-pub pure fn is_uppercase(c: char) -> bool {
+pure fn is_uppercase(c: char) -> bool {
     return unicode::general_category::Lu(c);
 }
 
@@ -65,7 +73,7 @@ pub pure fn is_uppercase(c: char) -> bool {
  * terms of the Unicode General Categories 'Zs', 'Zl', 'Zp'
  * additional 'Cc'-category control codes in the range [0x09, 0x0d]
  */
-pub pure fn is_whitespace(c: char) -> bool {
+pure fn is_whitespace(c: char) -> bool {
     return ('\x09' <= c && c <= '\x0d')
         || unicode::general_category::Zs(c)
         || unicode::general_category::Zl(c)
@@ -77,20 +85,20 @@ pub pure fn is_whitespace(c: char) -> bool {
  * defined in terms of the Unicode General Categories 'Nd', 'Nl', 'No'
  * and the Derived Core Property 'Alphabetic'.
  */
-pub pure fn is_alphanumeric(c: char) -> bool {
+pure fn is_alphanumeric(c: char) -> bool {
     return unicode::derived_property::Alphabetic(c) ||
         unicode::general_category::Nd(c) ||
         unicode::general_category::Nl(c) ||
         unicode::general_category::No(c);
 }
 
 /// Indicates whether the character is an ASCII character
-pub pure fn is_ascii(c: char) -> bool {
+pure fn is_ascii(c: char) -> bool {
    c - ('\x7F' & c) == '\x00'
 }
 
 /// Indicates whether the character is numeric (Nd, Nl, or No)
-pub pure fn is_digit(c: char) -> bool {
+pure fn is_digit(c: char) -> bool {
     return unicode::general_category::Nd(c) ||
         unicode::general_category::Nl(c) ||
         unicode::general_category::No(c);
@@ -106,7 +114,7 @@ pub pure fn is_digit(c: char) -> bool {
  * 'b' or 'B', 11, etc. Returns none if the char does not
  * refer to a digit in the given radix.
  */
-pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
+pure fn to_digit(c: char, radix: uint) -> Option<uint> {
     let val = match c {
       '0' .. '9' => c as uint - ('0' as uint),
       'a' .. 'z' => c as uint + 10u - ('a' as uint),
@@ -126,7 +134,7 @@ pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
  *   - chars in [0x100,0xffff] get 4-digit escapes: `\\uNNNN`
  *   - chars above 0x10000 get 8-digit escapes: `\\UNNNNNNNN`
  */
-pub fn escape_unicode(c: char) -> ~str {
+fn escape_unicode(c: char) -> ~str {
     let s = u32::to_str(c as u32, 16u);
     let (c, pad) = (if c <= '\xff' { ('x', 2u) }
                     else if c <= '\uffff' { ('u', 4u) }
@@ -151,7 +159,7 @@ pub fn escape_unicode(c: char) -> ~str {
  *   - Any other chars in the range [0x20,0x7e] are not escaped.
  *   - Any other chars are given hex unicode escapes; see `escape_unicode`.
  */
-pub fn escape_default(c: char) -> ~str {
+fn escape_default(c: char) -> ~str {
     match c {
       '\t' => ~"\\t",
       '\r' => ~"\\r",
@@ -171,7 +179,7 @@ pub fn escape_default(c: char) -> ~str {
  *
  * -1 if a < b, 0 if a == b, +1 if a > b
  */
-pub pure fn cmp(a: char, b: char) -> int {
+pure fn cmp(a: char, b: char) -> int {
     return  if b > a { -1 }
     else if b < a { 1 }
     else { 0 }

branches/snap-stage3/src/libcore/core.rc

@@ -37,7 +37,6 @@ Implicitly, all crates behave as if they included the following prologue:
 #[no_core];
 
 #[legacy_modes];
-#[legacy_exports];
 
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
@@ -196,8 +195,11 @@ mod u64 {
 }
 
 
+#[legacy_exports]
 mod box;
+#[legacy_exports]
 mod char;
+#[legacy_exports]
 mod float;
 #[legacy_exports]
 mod f32;
@@ -305,17 +307,29 @@ mod pipes;
 mod gc;
 #[legacy_exports]
 mod io;
+#[legacy_exports]
 mod libc;
+#[legacy_exports]
 mod os;
+#[legacy_exports]
 mod path;
+#[legacy_exports]
 mod rand;
+#[legacy_exports]
 mod run;
+#[legacy_exports]
 mod sys;
+#[legacy_exports]
 mod cast;
+#[legacy_exports]
 mod mutable;
+#[legacy_exports]
 mod flate;
+#[legacy_exports]
 mod repr;
+#[legacy_exports]
 mod cleanup;
+#[legacy_exports]
 mod reflect;
 
 // Modules supporting compiler-generated code
@@ -331,7 +345,9 @@ mod rt;
 
 // For internal use, not exported
 
+#[legacy_exports]
 mod unicode;
+#[legacy_exports]
 mod private;
 mod cmath;
 mod stackwalk;

branches/snap-stage3/src/libcore/core.rs

@@ -2,6 +2,8 @@
 
 // Export various ubiquitous types, constructors, methods.
 
+#[legacy_exports];
+
 use option::{Some, None};
 use Option = option::Option;
 use result::{Result, Ok, Err};

branches/snap-stage3/src/libcore/dlist.rs

@@ -275,13 +275,13 @@ impl<T> DList<T> {
     /// Remove a node from the head of the list. O(1).
     fn pop_n() -> Option<DListNode<T>> {
         let hd = self.peek_n();
-        hd.map(|nobe| self.unlink(*nobe));
+        hd.map(|nobe| self.unlink(nobe));
         hd
     }
     /// Remove a node from the tail of the list. O(1).
     fn pop_tail_n() -> Option<DListNode<T>> {
         let tl = self.peek_tail_n();
-        tl.map(|nobe| self.unlink(*nobe));
+        tl.map(|nobe| self.unlink(nobe));
         tl
     }
     /// Get the node at the list's head. O(1).

branches/snap-stage3/src/libcore/flate.rs

@@ -11,6 +11,8 @@ Simple compression
 use libc::{c_void, size_t, c_int};
 
 extern mod rustrt {
+    #[legacy_exports];
+
     fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
                                   src_buf_len: size_t,
                                   pout_len: *size_t,
@@ -27,7 +29,7 @@ const lz_fast : c_int = 0x1;   // LZ with only one probe
 const lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
 const lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
 
-pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
+fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
@@ -45,7 +47,7 @@ pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     }
 }
 
-pub fn inflate_bytes(bytes: &[const u8]) -> ~[u8] {
+fn inflate_bytes(bytes: &[const u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;

branches/snap-stage3/src/libcore/float.rs

@@ -7,10 +7,26 @@
 // Even though this module exports everything defined in it,
 // because it contains re-exports, we also have to explicitly
 // export locally defined things. That's a bit annoying.
-
+export to_str_common, to_str_exact, to_str, from_str;
+export add, sub, mul, div, rem, lt, le, eq, ne, ge, gt;
+export is_positive, is_negative, is_nonpositive, is_nonnegative;
+export is_zero, is_infinite, is_finite;
+export NaN, is_NaN, infinity, neg_infinity;
+export consts;
+export logarithm;
+export acos, asin, atan, atan2, cbrt, ceil, copysign, cos, cosh, floor;
+export erf, erfc, exp, expm1, exp2, abs, abs_sub;
+export mul_add, fmax, fmin, nextafter, frexp, hypot, ldexp;
+export lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix;
+export modf, pow, round, sin, sinh, sqrt, tan, tanh, tgamma, trunc;
+export signbit;
+export pow_with_uint;
+
+export num;
 
 // export when m_float == c_double
 
+export j0, j1, jn, y0, y1, yn;
 
 // PORT this must match in width according to architecture
 
@@ -28,11 +44,11 @@ use f64::{j0, j1, jn, y0, y1, yn};
 use cmp::{Eq, Ord};
 use num::from_int;
 
-pub const NaN: float = 0.0/0.0;
+const NaN: float = 0.0/0.0;
 
-pub const infinity: float = 1.0/0.0;
+const infinity: float = 1.0/0.0;
 
-pub const neg_infinity: float = -1.0/0.0;
+const neg_infinity: float = -1.0/0.0;
 
 /* Module: consts */
 pub mod consts {
@@ -91,7 +107,7 @@ pub mod consts {
  * * digits - The number of significant digits
  * * exact - Whether to enforce the exact number of significant digits
  */
-pub fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
+fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
     if is_NaN(num) { return ~"NaN"; }
     if num == infinity { return ~"inf"; }
     if num == neg_infinity { return ~"-inf"; }
@@ -398,22 +414,22 @@ pub pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
 pub pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
 impl float : Eq {
-    pub pure fn eq(other: &float) -> bool { self == (*other) }
-    pub pure fn ne(other: &float) -> bool { self != (*other) }
+    pure fn eq(other: &float) -> bool { self == (*other) }
+    pure fn ne(other: &float) -> bool { self != (*other) }
 }
 
 impl float : Ord {
-    pub pure fn lt(other: &float) -> bool { self < (*other) }
-    pub pure fn le(other: &float) -> bool { self <= (*other) }
-    pub pure fn ge(other: &float) -> bool { self >= (*other) }
-    pub pure fn gt(other: &float) -> bool { self > (*other) }
+    pure fn lt(other: &float) -> bool { self < (*other) }
+    pure fn le(other: &float) -> bool { self <= (*other) }
+    pure fn ge(other: &float) -> bool { self >= (*other) }
+    pure fn gt(other: &float) -> bool { self > (*other) }
 }
 
 impl float: num::Num {
-    pub pure fn add(other: &float)    -> float { return self + *other; }
-    pub pure fn sub(other: &float)    -> float { return self - *other; }
-    pub pure fn mul(other: &float)    -> float { return self * *other; }
-    pub pure fn div(other: &float)    -> float { return self / *other; }
+    pure fn add(other: &float)    -> float { return self + *other; }
+    pure fn sub(other: &float)    -> float { return self - *other; }
+    pure fn mul(other: &float)    -> float { return self * *other; }
+    pure fn div(other: &float)    -> float { return self / *other; }
     pure fn modulo(other: &float) -> float { return self % *other; }
     pure fn neg()                  -> float { return -self;        }
 

branches/snap-stage3/src/libcore/io.rs

@@ -697,10 +697,8 @@ impl BytesWriter: Writer {
             vec::reserve(&mut buf, count);
             unsafe { vec::raw::set_len(buf, count); }
 
-            {
-                let view = vec::mut_view(buf, self.pos, count);
-                vec::bytes::memcpy(view, v, v_len);
-            }
+            let view = vec::mut_view(buf, self.pos, count);
+            vec::bytes::memcpy(view, v, v_len);
 
             self.pos += v_len;