---

yaml
---
r: 22143
b: refs/heads/snap-stage3
c: 3efe499
h: refs/heads/master
i:
  22141: df79e76
  22139: 4fd0e24
  22135: 6bf706f
  22127: b4ed2e6
  22111: 580121d
  22079: b909c04
  22015: 191ea3f
v: v3

Author: graydon

[refs]

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

branches/snap-stage3/AUTHORS.txt

@@ -17,6 +17,7 @@ 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 `again` can be used
+keyword `break` can be used to abort the loop, and `loop` 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`, `again`, and `return`
+Additionally, within a `for` loop, `break`, `loop`, 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 `again`.
+to the next iteration, write `loop`.
 
 ~~~~
 # 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,7 +2,6 @@
 
 #[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,14 +39,6 @@ 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;
@@ -56,15 +48,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'
  */
-pure fn is_lowercase(c: char) -> bool {
+pub 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'.
  */
-pure fn is_uppercase(c: char) -> bool {
+pub pure fn is_uppercase(c: char) -> bool {
     return unicode::general_category::Lu(c);
 }
 
@@ -73,7 +65,7 @@ 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]
  */
-pure fn is_whitespace(c: char) -> bool {
+pub pure fn is_whitespace(c: char) -> bool {
     return ('\x09' <= c && c <= '\x0d')
         || unicode::general_category::Zs(c)
         || unicode::general_category::Zl(c)
@@ -85,20 +77,20 @@ pure fn is_whitespace(c: char) -> bool {
  * defined in terms of the Unicode General Categories 'Nd', 'Nl', 'No'
  * and the Derived Core Property 'Alphabetic'.
  */
-pure fn is_alphanumeric(c: char) -> bool {
+pub 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
-pure fn is_ascii(c: char) -> bool {
+pub pure fn is_ascii(c: char) -> bool {
    c - ('\x7F' & c) == '\x00'
 }
 
 /// Indicates whether the character is numeric (Nd, Nl, or No)
-pure fn is_digit(c: char) -> bool {
+pub pure fn is_digit(c: char) -> bool {
     return unicode::general_category::Nd(c) ||
         unicode::general_category::Nl(c) ||
         unicode::general_category::No(c);
@@ -114,7 +106,7 @@ 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.
  */
-pure fn to_digit(c: char, radix: uint) -> Option<uint> {
+pub 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),
@@ -134,7 +126,7 @@ 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`
  */
-fn escape_unicode(c: char) -> ~str {
+pub 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) }
@@ -159,7 +151,7 @@ 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`.
  */
-fn escape_default(c: char) -> ~str {
+pub fn escape_default(c: char) -> ~str {
     match c {
       '\t' => ~"\\t",
       '\r' => ~"\\r",
@@ -179,7 +171,7 @@ fn escape_default(c: char) -> ~str {
  *
  * -1 if a < b, 0 if a == b, +1 if a > b
  */
-pure fn cmp(a: char, b: char) -> int {
+pub 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,6 +37,7 @@ 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)];
@@ -195,11 +196,8 @@ mod u64 {
 }
 
 
-#[legacy_exports]
 mod box;
-#[legacy_exports]
 mod char;
-#[legacy_exports]
 mod float;
 #[legacy_exports]
 mod f32;
@@ -307,29 +305,17 @@ 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
@@ -345,9 +331,7 @@ 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,8 +2,6 @@
 
 // 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,8 +11,6 @@ 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,
@@ -29,7 +27,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"
 
-fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
+pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
@@ -47,7 +45,7 @@ fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     }
 }
 
-fn inflate_bytes(bytes: &[const u8]) -> ~[u8] {
+pub 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,26 +7,10 @@
 // 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
 
@@ -44,11 +28,11 @@ use f64::{j0, j1, jn, y0, y1, yn};
 use cmp::{Eq, Ord};
 use num::from_int;
 
-const NaN: float = 0.0/0.0;
+pub const NaN: float = 0.0/0.0;
 
-const infinity: float = 1.0/0.0;
+pub const infinity: float = 1.0/0.0;
 
-const neg_infinity: float = -1.0/0.0;
+pub const neg_infinity: float = -1.0/0.0;
 
 /* Module: consts */
 pub mod consts {
@@ -107,7 +91,7 @@ pub mod consts {
  * * digits - The number of significant digits
  * * exact - Whether to enforce the exact number of significant digits
  */
-fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
+pub 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"; }
@@ -414,22 +398,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 {
-    pure fn eq(other: &float) -> bool { self == (*other) }
-    pure fn ne(other: &float) -> bool { self != (*other) }
+    pub pure fn eq(other: &float) -> bool { self == (*other) }
+    pub pure fn ne(other: &float) -> bool { self != (*other) }
 }
 
 impl float : Ord {
-    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) }
+    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) }
 }
 
 impl float: num::Num {
-    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; }
+    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 modulo(other: &float) -> float { return self % *other; }
     pure fn neg()                  -> float { return -self;        }
 

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

@@ -697,8 +697,10 @@ 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;