---

yaml
---
r: 63339
b: refs/heads/snap-stage3
c: 5de67f9
h: refs/heads/master
i:
  63337: 42c34ca
  63335: 6edd4d6
v: v3

Author: mstewartgallus

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7d1065e913e6d50ddb1a157f81bb7752caeca329
+refs/heads/snap-stage3: 5de67f9cc9674752bb6b9db6c2db790a19ec4e9c
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -65,34 +65,24 @@ pub fn source_name(input: &input) -> @str {
 
 pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::crate_cfg {
-    let libc = match sess.targ_cfg.os {
-      session::os_win32 => @"msvcrt.dll",
-      session::os_macos => @"libc.dylib",
-      session::os_linux => @"libc.so.6",
-      session::os_android => @"libc.so",
-      session::os_freebsd => @"libc.so.7"
-      // _ { "libc.so" }
+    let (libc, tos) = match sess.targ_cfg.os {
+        session::os_win32 =>   (@"msvcrt.dll", @"win32"),
+        session::os_macos =>   (@"libc.dylib", @"macos"),
+        session::os_linux =>   (@"libc.so.6",  @"linux"),
+        session::os_android => (@"libc.so",    @"android"),
+        session::os_freebsd => (@"libc.so.7",  @"freebsd")
     };
-    let tos = match sess.targ_cfg.os {
-      session::os_win32 => @"win32",
-      session::os_macos => @"macos",
-      session::os_linux => @"linux",
-      session::os_android => @"android",
-      session::os_freebsd => @"freebsd"
-      // _ { "libc.so" }
-    };
-
-    let mk = attr::mk_name_value_item_str;
 
     // ARM is bi-endian, however using NDK seems to default
     // to little-endian unless a flag is provided.
     let (end,arch,wordsz) = match sess.targ_cfg.arch {
-        abi::X86 => (@"little",@"x86",@"32"),
-        abi::X86_64 => (@"little",@"x86_64",@"64"),
-        abi::Arm => (@"little",@"arm",@"32"),
-        abi::Mips => (@"big",@"mips",@"32")
+        abi::X86 =>    (@"little", @"x86",    @"32"),
+        abi::X86_64 => (@"little", @"x86_64", @"64"),
+        abi::Arm =>    (@"little", @"arm",    @"32"),
+        abi::Mips =>   (@"big",    @"mips",   @"32")
     };
 
+    let mk = attr::mk_name_value_item_str;
     return ~[ // Target bindings.
          attr::mk_word_item(os::FAMILY.to_managed()),
          mk(@"target_os", tos),
@@ -463,36 +453,37 @@ pub fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: &input,
 }
 
 pub fn get_os(triple: &str) -> Option<session::os> {
-    if triple.contains("win32") ||
-               triple.contains("mingw32") {
-            Some(session::os_win32)
-        } else if triple.contains("darwin") {
-            Some(session::os_macos)
-        } else if triple.contains("android") {
-            Some(session::os_android)
-        } else if triple.contains("linux") {
-            Some(session::os_linux)
-        } else if triple.contains("freebsd") {
-            Some(session::os_freebsd)
-        } else { None }
+    for os_names.each |&(name, os)| {
+        if triple.contains(name) { return Some(os) }
+    }
+    None
 }
+static os_names : &'static [(&'static str, session::os)] = &'static [
+    ("win32",   session::os_win32),
+    ("darwin",  session::os_macos),
+    ("android", session::os_android),
+    ("linux",   session::os_linux),
+    ("freebsd", session::os_freebsd)];
 
 pub fn get_arch(triple: &str) -> Option<abi::Architecture> {
-    if triple.contains("i386") ||
-        triple.contains("i486") ||
-               triple.contains("i586") ||
-               triple.contains("i686") ||
-               triple.contains("i786") {
-            Some(abi::X86)
-        } else if triple.contains("x86_64") {
-            Some(abi::X86_64)
-        } else if triple.contains("arm") ||
-                      triple.contains("xscale") {
-            Some(abi::Arm)
-        } else if triple.contains("mips") {
-            Some(abi::Mips)
-        } else { None }
+    for architecture_abis.each |&(arch, abi)| {
+        if triple.contains(arch) { return Some(abi) }
+    }
+    None
 }
+static architecture_abis : &'static [(&'static str, abi::Architecture)] = &'static [
+    ("i386",   abi::X86),
+    ("i486",   abi::X86),
+    ("i586",   abi::X86),
+    ("i686",   abi::X86),
+    ("i786",   abi::X86),
+
+    ("x86_64", abi::X86_64),
+
+    ("arm",    abi::Arm),
+    ("xscale", abi::Arm),
+
+    ("mips",   abi::Mips)];
 
 pub fn build_target_config(sopts: @session::options,
                            demitter: diagnostic::Emitter)

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

@@ -10,49 +10,49 @@
 
 /*!
 
-# The Rust standard library
+# The Rust core library
 
-The Rust standard library provides runtime features required by the language,
+The Rust core library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
 
-`std` includes modules corresponding to each of the integer types, each of
+`core` includes modules corresponding to each of the integer types, each of
 the floating point types, the `bool` type, tuples, characters, strings
 (`str`), vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`),
-and unsafe and borrowed pointers (`ptr`).  Additionally, `std` provides
+and unsafe and borrowed pointers (`ptr`).  Additionally, `core` provides
 pervasive types (`option` and `result`), task creation and communication
 primitives (`task`, `comm`), platform abstractions (`os` and `path`), basic
 I/O abstractions (`io`), common traits (`kinds`, `ops`, `cmp`, `num`,
 `to_str`), and complete bindings to the C standard library (`libc`).
 
-# Standard library injection and the Rust prelude
+# Core injection and the Rust prelude
 
-`std` is imported at the topmost level of every crate by default, as
+`core` is imported at the topmost level of every crate by default, as
 if the first line of each crate was
 
-    extern mod std;
+    extern mod core;
 
-This means that the contents of std can be accessed from any context
-with the `std::` path prefix, as in `use std::vec`, `use std::task::spawn`,
+This means that the contents of core can be accessed from any context
+with the `core::` path prefix, as in `use core::vec`, `use core::task::spawn`,
 etc.
 
-Additionally, `std` contains a `prelude` module that reexports many of the
-most common std modules, types and traits. The contents of the prelude are
+Additionally, `core` contains a `prelude` module that reexports many of the
+most common core modules, types and traits. The contents of the prelude are
 imported into every *module* by default.  Implicitly, all modules behave as if
 they contained the following prologue:
 
-    use std::prelude::*;
+    use core::prelude::*;
 
 */
 
 
 #[link(name = "std",
        vers = "0.7-pre",
        uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
-       url = "https://github.com/mozilla/rust/tree/master/src/libstd")];
+       url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
 
-#[comment = "The Rust standard library"];
+#[comment = "The Rust core library"];
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 

branches/snap-stage3/src/libsyntax/ext/deriving/rand.rs

@@ -79,19 +79,18 @@ fn rand_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
             let variant_count = cx.expr_uint(span, variants.len());
 
             // need to specify the uint-ness of the random number
-            let uint_ty = cx.ty_ident(span, cx.ident_of("uint"));
+            let u32_ty = cx.ty_ident(span, cx.ident_of("uint"));
             let r_ty = cx.ty_ident(span, cx.ident_of("R"));
-            let rand_name = cx.path_all(span, true, copy rand_ident, None, ~[ uint_ty, r_ty ]);
+            let rand_name = cx.path_all(span, false, copy rand_ident, None, ~[ u32_ty, r_ty ]);
             let rand_name = cx.expr_path(rand_name);
 
-            // ::std::rand::Rand::rand::<uint>(rng)
             let rv_call = cx.expr_call(span,
                                        rand_name,
                                        ~[ rng[0].duplicate(cx) ]);
 
             // rand() % variants.len()
             let rand_variant = cx.expr_binary(span, ast::rem,
-                                              rv_call, variant_count);
+                                                rv_call, variant_count);
 
             let mut arms = do variants.mapi |i, id_sum| {
                 let i_expr = cx.expr_uint(span, i);