---

yaml
---
r: 161132
b: refs/heads/snap-stage3
c: dff48a9
h: refs/heads/master
v: v3

Author: SimonSapin

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4eb72d268f337a8f117c86a2ac1b98336cab9e9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 47c1d437c93872e6776570beac839f2587782f94
+refs/heads/snap-stage3: dff48a99d6bf9d2c4828f187bfa2c9ba382fe791
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/configure

@@ -550,20 +550,10 @@ CFG_LIBDIR_RELATIVE=lib
 if [ "$CFG_OSTYPE" = "pc-windows-gnu" ]
 then
     CFG_LIBDIR_RELATIVE=bin
-    CFG_LIBDIR="${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}"
-else
-    valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries (ignored on windows platform)"
-
-    case "$CFG_LIBDIR" in
-	"$CFG_PREFIX"/*) CAT_INC=2;;
-	"$CFG_PREFIX"*)  CAT_INC=1;;
-	*)
-            err "libdir must begin with the prefix. Use --prefix to set it accordingly.";;
-    esac
-
-    CFG_LIBDIR_RELATIVE=`echo ${CFG_LIBDIR} | cut -c$((${#CFG_PREFIX}+${CAT_INC}))-`
 fi
 
+valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries"
+
 if [ $HELP -eq 1 ]
 then
     echo
@@ -999,15 +989,6 @@ for h in $CFG_HOST
 do
     for t in $CFG_TARGET
     do
-        # host lib dir stage0
-        make_dir $h/stage0/lib
-
-        # target bin dir stage0
-        make_dir $h/stage0/lib/rustlib/$t/bin
-
-        # target lib dir stage0
-        make_dir $h/stage0/lib/rustlib/$t/lib
-
         for i in 0 1 2 3
         do
             # host bin dir

branches/snap-stage3/mk/crates.mk

@@ -37,7 +37,7 @@
 #
 #   DEPS_<crate>
 #	These lists are the dependencies of the <crate> that is to be built.
-#	Rust dependencies are listed bare (i.e. std) and native
+#	Rust dependencies are listed bare (i.e. std, green) and native
 #	dependencies have a "native:" prefix (i.e. native:hoedown). All deps
 #	will be built before the crate itself is built.
 #
@@ -49,7 +49,7 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std flate arena term \
+TARGET_CRATES := libc std green native flate arena term \
                  serialize sync getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
@@ -66,6 +66,8 @@ DEPS_rustrt := alloc core libc collections native:rustrt_native
 DEPS_std := core libc rand alloc collections rustrt sync unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
+DEPS_green := std native:context_switch
+DEPS_native := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc_trans := rustc rustc_back rustc_llvm libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
@@ -93,9 +95,9 @@ DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex
 DEPS_fmt_macros = std
 
-TOOL_DEPS_compiletest := test getopts
-TOOL_DEPS_rustdoc := rustdoc
-TOOL_DEPS_rustc := rustc_trans
+TOOL_DEPS_compiletest := test getopts native
+TOOL_DEPS_rustdoc := rustdoc native
+TOOL_DEPS_rustc := rustc_trans native
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs
 TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
 TOOL_SOURCE_rustc := $(S)src/driver/driver.rs

branches/snap-stage3/mk/main.mk

@@ -332,15 +332,7 @@ define SREQ
 # Destinations of artifacts for the host compiler
 HROOT$(1)_H_$(3) = $(3)/stage$(1)
 HBIN$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/bin
-ifeq ($$(CFG_WINDOWSY_$(3)),1)
 HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(CFG_LIBDIR_RELATIVE)
-else
-ifeq ($(1),0)
-HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/lib
-else
-HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(CFG_LIBDIR_RELATIVE)
-endif
-endif
 
 # Destinations of artifacts for target architectures
 TROOT$(1)_T_$(2)_H_$(3) = $$(HLIB$(1)_H_$(3))/rustlib/$(2)

branches/snap-stage3/src/README.md

@@ -9,6 +9,8 @@ Source layout:
 | `libcore/`          | The Rust core library                                     |
 | `libdebug/`         | Debugging utilities                                       |
 | `libstd/`           | The standard library (imported and linked by default)     |
+| `libgreen/`         | The M:N runtime library                                   |
+| `libnative/`        | The 1:1 runtime library                                   |
 | `libsyntax/`        | The Rust parser and pretty-printer                        |
 | `libtest/`          | Rust's test-runner code                                   |
 | ------------------- | --------------------------------------------------------- |

branches/snap-stage3/src/doc/reference.md

@@ -225,52 +225,6 @@ reserved for future extension, that is, the above gives the lexical
 grammar, but a Rust parser will reject everything but the 12 special
 cases mentioned in [Number literals](#number-literals) below.
 
-#### Examples
-
-##### Characters and strings
-
-|   | Example | Number of `#` pairs allowed | Available characters | Escapes | Equivalent to |
-|---|---------|-----------------------------|----------------------|---------|---------------|
-| [Character](#character-literals) | `'H'` | `N/A` | All unicode | `\'` & [Byte escapes](#byte-escapes) & [Unicode escapes](#unicode-escapes) | `N/A` |
-| [String](#string-literals) | `"hello"` | `N/A` | All unicode | `\"` & [Byte escapes](#byte-escapes) & [Unicode escapes](#unicode-escapes) | `N/A` |
-| [Raw](#raw-string-literals) | `r##"hello"##`  | `0...` | All unicode | `N/A` | `N/A` |
-| [Byte](#byte-literals) | `b'H'` | `N/A` | All ASCII | `\'` & [Byte escapes](#byte-escapes) | `u8` |
-| [Byte string](#byte-string-literals) | `b"hello"` | `N/A`  | All ASCII | `\"` & [Byte escapes](#byte-escapes) | `&'static [u8]` |
-| [Raw byte string](#raw-byte-string-literals) | `br##"hello"##` | `0...` | All ASCII | `N/A` | `&'static [u8]` (unsure...not stated) |
-
-##### Byte escapes
-
-|   | Name |
-|---|------|
-| `\x7F` | 8-bit character code (exactly 2 digits) |
-| `\n` | Newline |
-| `\r` | Carriage return |
-| `\t` | Tab |
-| `\\` | Backslash |
-
-##### Unicode escapes
-|   | Name |
-|---|------|
-| `\u7FFF` | 16-bit character code (exactly 4 digits) |
-| `\U7EEEFFFF` | 32-bit character code (exactly 8 digits) |
-
-##### Numbers
-
-| [Number literals](#number-literals)`*` | Example | Exponentiation | Suffixes |
-|----------------------------------------|---------|----------------|----------|
-| Decimal integer | `98_222i` | `N/A` | Integer suffixes |
-| Hex integer | `0xffi` | `N/A` | Integer suffixes |
-| Octal integer | `0o77i` | `N/A` | Integer suffixes |
-| Binary integer | `0b1111_0000i` | `N/A` | Integer suffixes |
-| Floating-point | `123.0E+77f64` | `Optional` | Floating-point suffixes |
-
-`*` All number literals allow `_` as a visual separator: `1_234.0E+18f64`
-
-##### Suffixes
-| Integer | Floating-point |
-|---------|----------------|
-| `i` (`int`), `u` (`uint`), `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64` | `f32`, `f64` |
-
 #### Character and string literals
 
 ```{.ebnf .gram}
@@ -299,21 +253,15 @@ nonzero_dec: '1' | '2' | '3' | '4'
            | '5' | '6' | '7' | '8' | '9' ;
 ```
 
-##### Character literals
-
 A _character literal_ is a single Unicode character enclosed within two
 `U+0027` (single-quote) characters, with the exception of `U+0027` itself,
 which must be _escaped_ by a preceding U+005C character (`\`).
 
-##### String literals
-
 A _string literal_ is a sequence of any Unicode characters enclosed within two
 `U+0022` (double-quote) characters, with the exception of `U+0022` itself,
 which must be _escaped_ by a preceding `U+005C` character (`\`), or a _raw
 string literal_.
 
-##### Character escapes
-
 Some additional _escapes_ are available in either character or non-raw string
 literals. An escape starts with a `U+005C` (`\`) and continues with one of the
 following forms:
@@ -333,8 +281,6 @@ following forms:
 * The _backslash escape_ is the character `U+005C` (`\`) which must be
   escaped in order to denote *itself*.
 
-##### Raw string literals
-
 Raw string literals do not process any escapes. They start with the character
 `U+0072` (`r`), followed by zero or more of the character `U+0023` (`#`) and a
 `U+0022` (double-quote) character. The _raw string body_ is not defined in the
@@ -376,16 +322,12 @@ raw_byte_string : '"' raw_byte_string_body '"' | '#' raw_byte_string '#' ;
 
 ```
 
-##### Byte literals
-
 A _byte literal_ is a single ASCII character (in the `U+0000` to `U+007F`
 range) enclosed within two `U+0027` (single-quote) characters, with the
 exception of `U+0027` itself, which must be _escaped_ by a preceding U+005C
 character (`\`), or a single _escape_. It is equivalent to a `u8` unsigned
 8-bit integer _number literal_.
 
-##### Byte string literals
-
 A _byte string literal_ is a sequence of ASCII characters and _escapes_
 enclosed within two `U+0022` (double-quote) characters, with the exception of
 `U+0022` itself, which must be _escaped_ by a preceding `U+005C` character
@@ -405,8 +347,6 @@ following forms:
 * The _backslash escape_ is the character `U+005C` (`\`) which must be
   escaped in order to denote its ASCII encoding `0x5C`.
 
-##### Raw byte string literals
-
 Raw byte string literals do not process any escapes. They start with the
 character `U+0062` (`b`), followed by `U+0072` (`r`), followed by zero or more
 of the character `U+0023` (`#`), and a `U+0022` (double-quote) character. The
@@ -1059,14 +999,14 @@ An example of what will and will not work for `use` items:
 
 ```
 # #![allow(unused_imports)]
-use foo::core::iter;  // good: foo is at the root of the crate
+use foo::native::start;  // good: foo is at the root of the crate
 use foo::baz::foobaz;    // good: foo is at the root of the crate
 
 mod foo {
-    extern crate core;
+    extern crate native;
 
-    use foo::core::iter; // good: foo is at crate root
-//  use core::iter;      // bad:  native is not at the crate root
+    use foo::native::start; // good: foo is at crate root
+//  use native::start;      // bad:  native is not at the crate root
     use self::baz::foobaz;  // good: self refers to module 'foo'
     use foo::bar::foobar;   // good: foo is at crate root
 

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

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![no_start]
-
 #[cfg(rustdoc)]
 extern crate "rustdoc" as this;
 

branches/snap-stage3/src/etc/install.sh

@@ -301,16 +301,9 @@ fi
 flag uninstall "only uninstall from the installation prefix"
 opt verify 1 "verify that the installed binaries run correctly"
 valopt prefix "/usr/local" "set installation prefix"
-# NB This is exactly the same definition as in `configure`.
+# NB This isn't quite the same definition as in `configure`.
+# just using 'lib' instead of CFG_LIBDIR_RELATIVE
 valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries"
-case "$CFG_LIBDIR" in
-    "$CFG_PREFIX"/*) CAT_INC=2;;
-    "$CFG_PREFIX"*)  CAT_INC=1;;
-    *)
-        err "libdir must begin with the prefix. Use --prefix to set it accordingly.";;
-esac
-CFG_LIBDIR_RELATIVE=`echo ${CFG_LIBDIR} | cut -c$((${#CFG_PREFIX}+${CAT_INC}))-`
-
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
 
 if [ $HELP -eq 1 ]
@@ -435,9 +428,9 @@ while read p; do
     # Decide the destination of the file
     FILE_INSTALL_PATH="${CFG_PREFIX}/$p"
 
-    if echo "$p" | grep "^${CFG_LIBDIR_RELATIVE}/" > /dev/null
+    if echo "$p" | grep "^lib/" > /dev/null
     then
-        pp=`echo $p | sed "s%^${CFG_LIBDIR_RELATIVE}/%%"`
+        pp=`echo $p | sed 's/^lib\///'`
         FILE_INSTALL_PATH="${CFG_LIBDIR}/$pp"
     fi
 

branches/snap-stage3/src/liballoc/lib.rs

@@ -73,6 +73,7 @@ extern crate libc;
 
 // Allow testing this library
 
+#[cfg(test)] extern crate native;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 

branches/snap-stage3/src/libcollections/lib.rs

@@ -31,6 +31,7 @@
 extern crate unicode;
 extern crate alloc;
 
+#[cfg(test)] extern crate native;
 #[cfg(test)] extern crate test;
 
 #[cfg(test)] #[phase(plugin, link)] extern crate std;

branches/snap-stage3/src/libcollections/slice.rs

@@ -424,7 +424,7 @@ fn merge_sort<T>(v: &mut [T], compare: |&T, &T| -> Ordering) {
     // allocate some memory to use as scratch memory, we keep the
     // length 0 so we can keep shallow copies of the contents of `v`
     // without risking the dtors running on an object twice if
-    // `compare` panics.
+    // `compare` fails.
     let mut working_space = Vec::with_capacity(2 * len);
     // these both are buffers of length `len`.
     let mut buf_dat = working_space.as_mut_ptr();
@@ -666,8 +666,6 @@ pub mod raw {
 
 #[cfg(test)]
 mod tests {
-    extern crate rustrt;
-
     use std::cell::Cell;
     use std::default::Default;
     use std::mem;
@@ -951,9 +949,9 @@ mod tests {
     #[test]
     fn test_swap_remove_noncopyable() {
         // Tests that we don't accidentally run destructors twice.
-        let mut v = vec![rustrt::exclusive::Exclusive::new(()),
-                         rustrt::exclusive::Exclusive::new(()),
-                         rustrt::exclusive::Exclusive::new(())];
+        let mut v = vec![rt::exclusive::Exclusive::new(()),
+                         rt::exclusive::Exclusive::new(()),
+                         rt::exclusive::Exclusive::new(())];
         let mut _e = v.swap_remove(0);
         assert_eq!(v.len(), 2);
         _e = v.swap_remove(1);

branches/snap-stage3/src/libcollections/str.rs

@@ -42,9 +42,9 @@
 //! # Representation
 //!
 //! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as a
-//! stream of UTF-8 bytes. All [strings](../../reference.html#literals) are
-//! guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are
-//! not null-terminated and can thus contain null bytes.
+//! stream of UTF-8 bytes. All strings are guaranteed to be validly encoded UTF-8
+//! sequences. Additionally, strings are not null-terminated and can thus contain
+//! null bytes.
 //!
 //! The actual representation of strings have direct mappings to slices: `&str`
 //! is the same as `&[u8]`.
@@ -74,7 +74,8 @@ use vec::Vec;
 pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
 pub use core::str::{Bytes, CharSplits};
 pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
-pub use core::str::{Utf16CodeUnits, eq_slice, is_utf8, is_utf16, Utf16Items};
+pub use core::str::{Utf16Encoder, Utf16CodeUnits};
+pub use core::str::{eq_slice, is_utf8, is_utf16, Utf16Items};
 pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
 pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
 pub use core::str::{FromStr, from_str};

branches/snap-stage3/src/libcollections/vec.rs

@@ -1647,10 +1647,7 @@ impl<T> Vec<T> {
             // Create a `Vec` from our `PartialVecZeroSized` and make sure the
             // destructor of the latter will not run. None of this can panic.
             let mut result = Vec::new();
-            unsafe {
-                result.set_len(pv.num_u);
-                mem::forget(pv);
-            }
+            unsafe { result.set_len(pv.num_u); }
             result
         }
     }

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

@@ -303,7 +303,7 @@ impl<T> Option<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the value is a `None` with a custom panic message provided by
+    /// Fails if the value is a `None` with a custom panic message provided by
     /// `msg`.
     ///
     /// # Example
@@ -315,7 +315,7 @@ impl<T> Option<T> {
     ///
     /// ```{.should_fail}
     /// let x: Option<&str> = None;
-    /// x.expect("the world is ending"); // panics with `world is ending`
+    /// x.expect("the world is ending"); // fails with `world is ending`
     /// ```
     #[inline]
     #[unstable = "waiting for conventions"]