---

yaml
---
r: 178651
b: refs/heads/snap-stage3
c: fcb30a0
h: refs/heads/master
i:
  178649: 656caad
  178647: f46498a
v: v3

Author: semarie

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3d072a193bfcb76206aab576049e696d6d8db25d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9529ab0e7e469940db890604060c073179db8464
+refs/heads/snap-stage3: fcb30a0b67b1bd4acbc3422ff74fac5d031ae1ae
 refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/COPYRIGHT

@@ -23,12 +23,12 @@ The following third party packages are included, and carry
 their own copyright notices and license terms:
 
 * Two header files that are part of the Valgrind
-  package. These files are found at src/rt/valgrind/valgrind.h and
-  src/rt/valgrind/memcheck.h, within this distribution. These files
+  package. These files are found at src/rt/vg/valgrind.h and
+  src/rt/vg/memcheck.h, within this distribution. These files
   are redistributed under the following terms, as noted in
   them:
 
-  for src/rt/valgrind/valgrind.h:
+  for src/rt/vg/valgrind.h:
 
     This file is part of Valgrind, a dynamic binary
     instrumentation framework.
@@ -74,7 +74,7 @@ their own copyright notices and license terms:
     USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     OF SUCH DAMAGE.
 
-  for src/rt/valgrind/memcheck.h:
+  for src/rt/vg/memcheck.h:
 
     This file is part of MemCheck, a heavyweight Valgrind
     tool for detecting memory errors.
@@ -120,6 +120,18 @@ their own copyright notices and license terms:
     USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     OF SUCH DAMAGE.
 
+* The auxiliary file src/etc/pkg/modpath.iss contains a
+  library routine compiled, by Inno Setup, into the Windows
+  installer binary. This file is licensed under the LGPL,
+  version 3, but, in our legal interpretation, this does not
+  affect the aggregate "collected work" license of the Rust
+  distribution (MIT/ASL2) nor any other components of it. We
+  believe that the terms governing distribution of the
+  binary Windows installer built from modpath.iss are
+  therefore LGPL, but not the terms governing distribution
+  of any of the files installed by such an installer (such
+  as the Rust compiler or runtime libraries themselves).
+
 * The src/rt/miniz.c file, carrying an implementation of
   RFC1950/RFC1951 DEFLATE, by Rich Geldreich
   <[email protected]>. All uses of this file are

branches/snap-stage3/configure

@@ -374,6 +374,10 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=unknown-dragonfly
         ;;
 
+    OpenBSD)
+	CFG_OSTYPE=unknown-openbsd
+       ;;
+
     Darwin)
         CFG_OSTYPE=apple-darwin
         ;;

branches/snap-stage3/mk/cfg/x86_64-unknown-openbsd.mk

@@ -0,0 +1,26 @@
+# x86_64-pc-openbsd-elf configuration
+CC_x86_64-unknown-openbsd=$(CC)
+CXX_x86_64-unknown-openbsd=$(CXX)
+CPP_x86_64-unknown-openbsd=$(CPP)
+AR_x86_64-unknown-openbsd=$(AR)
+CFG_LIB_NAME_x86_64-unknown-openbsd=lib$(1).so
+CFG_STATIC_LIB_NAME_x86_64-unknown-openbsd=lib$(1).a
+CFG_LIB_GLOB_x86_64-unknown-openbsd=lib$(1)-*.so
+CFG_LIB_DSYM_GLOB_x86_64-unknown-openbsd=$(1)-*.dylib.dSYM
+CFG_JEMALLOC_CFLAGS_x86_64-unknown-openbsd := -m64 -I/usr/include $(CFLAGS)
+CFG_GCCISH_CFLAGS_x86_64-unknown-openbsd := -Wall -Werror -g -fPIC -m64 -I/usr/include $(CFLAGS)
+CFG_GCCISH_LINK_FLAGS_x86_64-unknown-openbsd := -shared -fPIC -g -pthread -m64
+CFG_GCCISH_DEF_FLAG_x86_64-unknown-openbsd := -Wl,--export-dynamic,--dynamic-list=
+CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-openbsd := -Wl,-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-openbsd := -Wl,-no-whole-archive
+CFG_DEF_SUFFIX_x86_64-unknown-openbsd := .bsd.def
+CFG_LLC_FLAGS_x86_64-unknown-openbsd :=
+CFG_INSTALL_NAME_x86_64-unknown-openbsd =
+CFG_EXE_SUFFIX_x86_64-unknown-openbsd :=
+CFG_WINDOWSY_x86_64-unknown-openbsd :=
+CFG_UNIXY_x86_64-unknown-openbsd := 1
+CFG_PATH_MUNGE_x86_64-unknown-openbsd :=
+CFG_LDPATH_x86_64-unknown-openbsd :=
+CFG_RUN_x86_64-unknown-openbsd=$(2)
+CFG_RUN_TARG_x86_64-unknown-openbsd=$(call CFG_RUN_x86_64-unknown-openbsd,,$(2))
+CFG_GNU_TRIPLE_x86_64-unknown-openbsd := x86_64-unknown-openbsd

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

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -23,6 +23,7 @@ static OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("linux", "linux"),
     ("freebsd", "freebsd"),
     ("dragonfly", "dragonfly"),
+    ("openbsd", "openbsd"),
 ];
 
 pub fn get_os(triple: &str) -> &'static str {

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

@@ -424,7 +424,7 @@ Let's see an example. This Rust code will not compile:
 use std::thread::Thread;
 
 fn main() {
-    let mut numbers = vec![1, 2, 3];
+    let mut numbers = vec![1is, 2, 3];
 
     for i in 0..3 {
         Thread::spawn(move || {
@@ -478,7 +478,7 @@ use std::thread::Thread;
 use std::sync::{Arc,Mutex};
 
 fn main() {
-    let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
+    let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
 
     for i in 0us..3 {
         let number = numbers.clone();
@@ -539,7 +539,7 @@ safety check that makes this an error about moved values:
 use std::thread::Thread;
 
 fn main() {
-    let vec = vec![1, 2, 3];
+    let vec = vec![1is, 2, 3];
 
     for i in 0us..3 {
         Thread::spawn(move || {

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

@@ -268,7 +268,7 @@ cases mentioned in [Number literals](#number-literals) below.
 ##### Suffixes
 | Integer | Floating-point |
 |---------|----------------|
-| `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `is` (`isize`), `us` (`usize`) | `f32`, `f64` |
+| `is` (`isize`), `us` (`usize`), `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64` | `f32`, `f64` |
 
 #### Character and string literals
 
@@ -468,29 +468,27 @@ Like any literal, an integer literal may be followed (immediately,
 without any spaces) by an _integer suffix_, which forcibly sets the
 type of the literal. There are 10 valid values for an integer suffix:
 
+* The `is` and `us` suffixes give the literal type `isize` or `usize`,
+  respectively.
 * Each of the signed and unsigned machine types `u8`, `i8`,
   `u16`, `i16`, `u32`, `i32`, `u64` and `i64`
   give the literal the corresponding machine type.
-* The `is` and `us` suffixes give the literal type `isize` or `usize`,
-  respectively.
 
 The type of an _unsuffixed_ integer literal is determined by type inference.
 If an integer type can be _uniquely_ determined from the surrounding program
 context, the unsuffixed integer literal has that type. If the program context
-underconstrains the type, it defaults to the signed 32-bit integer `i32`; if
-the program context overconstrains the type, it is considered a static type
-error.
+underconstrains the type, it is considered a static type error; if the program
+context overconstrains the type, it is also considered a static type error.
 
 Examples of integer literals of various forms:
 
 ```
-123i32;                            // type i32
-123u32;                            // type u32
-123_u32;                           // type u32
+123is;                             // type isize
+123us;                             // type usize
+123_us;                            // type usize
 0xff_u8;                           // type u8
 0o70_i16;                          // type i16
 0b1111_1111_1001_0000_i32;         // type i32
-0us;                               // type usize
 ```
 
 ##### Floating-point literals
@@ -1137,8 +1135,8 @@ used as a type name.
 
 When a generic function is referenced, its type is instantiated based on the
 context of the reference. For example, calling the `iter` function defined
-above on `[1, 2]` will instantiate type parameter `T` with `i32`, and require
-the closure parameter to have type `fn(i32)`.
+above on `[1, 2]` will instantiate type parameter `T` with `isize`, and require
+the closure parameter to have type `fn(isize)`.
 
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary if
@@ -2197,7 +2195,8 @@ The following configurations must be defined by the implementation:
   `"unix"` or `"windows"`. The value of this configuration option is defined
   as a configuration itself, like `unix` or `windows`.
 * `target_os = "..."`. Operating system of the target, examples include
-  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"` or `"dragonfly"`.
+  `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"` or
+  `"openbsd"`.
 * `target_word_size = "..."`. Target word size in bits. This is set to `"32"`
   for targets with 32-bit pointers, and likewise set to `"64"` for 64-bit
   pointers.
@@ -2748,9 +2747,9 @@ constant expression that can be evaluated at compile time, such as a
 [literal](#literals) or a [static item](#static-items).
 
 ```
-[1, 2, 3, 4];
+[1is, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0; 128];              // array with 128 zeros
+[0is; 128];            // array with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ```
 
@@ -2923,7 +2922,7 @@ moves](#moved-and-copied-types) its right-hand operand to its left-hand
 operand.
 
 ```
-# let mut x = 0;
+# let mut x = 0is;
 # let y = 0;
 
 x = y;
@@ -3309,11 +3308,11 @@ fn main() {
 ```
 
 Patterns can also dereference pointers by using the `&`, `&mut` and `box`
-symbols, as appropriate. For example, these two matches on `x: &i32` are
+symbols, as appropriate. For example, these two matches on `x: &isize` are
 equivalent:
 
 ```
-# let x = &3;
+# let x = &3is;
 let y = match *x { 0 => "zero", _ => "some" };
 let z = match x { &0 => "zero", _ => "some" };
 
@@ -3334,7 +3333,7 @@ Multiple match patterns may be joined with the `|` operator. A range of values
 may be specified with `...`. For example:
 
 ```
-# let x = 2;
+# let x = 2is;
 
 let message = match x {
   0 | 1  => "not many",
@@ -3675,16 +3674,16 @@ The type of a closure mapping an input of type `A` to an output of type `B` is
 An example of creating and calling a closure:
 
 ```rust
-let captured_var = 10;
+let captured_var = 10is;
 
 let closure_no_args = |&:| println!("captured_var={}", captured_var);
 
-let closure_args = |&: arg: i32| -> i32 {
+let closure_args = |&: arg: isize| -> isize {
   println!("captured_var={}, arg={}", captured_var, arg);
   arg // Note lack of semicolon after 'arg'
 };
 
-fn call_closure<F: Fn(), G: Fn(i32) -> i32>(c1: F, c2: G) {
+fn call_closure<F: Fn(), G: Fn(isize) -> isize>(c1: F, c2: G) {
   c1();
   c2(2);
 }
@@ -3716,7 +3715,7 @@ trait Printable {
   fn stringify(&self) -> String;
 }
 
-impl Printable for i32 {
+impl Printable for isize {
   fn stringify(&self) -> String { self.to_string() }
 }
 
@@ -3725,7 +3724,7 @@ fn print(a: Box<Printable>) {
 }
 
 fn main() {
-   print(Box::new(10) as Box<Printable>);
+   print(Box::new(10is) as Box<Printable>);
 }
 ```
 

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

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+# Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
 # file at the top-level directory of this distribution and at
 # http://rust-lang.org/COPYRIGHT.
 #
@@ -18,7 +18,7 @@ LIB_PREFIX=lib
 
 OS=`uname -s`
 case $OS in
-    ("Linux"|"FreeBSD"|"DragonFly")
+    ("Linux"|"FreeBSD"|"DragonFly"|"OpenBSD")
     BIN_SUF=
     LIB_SUF=.so
     ;;

branches/snap-stage3/src/etc/snapshot.py

@@ -1,4 +1,4 @@
-# Copyright 2011-2014 The Rust Project Developers. See the COPYRIGHT
+# Copyright 2011-2015 The Rust Project Developers. See the COPYRIGHT
 # file at the top-level directory of this distribution and at
 # http://rust-lang.org/COPYRIGHT.
 #
@@ -46,6 +46,7 @@ def scrub(b):
         "winnt": ["bin/rustc.exe"],
         "freebsd": ["bin/rustc"],
         "dragonfly": ["bin/rustc"],
+        "openbsd": ["bin/rustc"],
         }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll", "libstdc++-6.dll"]
@@ -100,6 +101,8 @@ def get_kernel(triple):
         return "freebsd"
     if os_name == "dragonfly":
         return "dragonfly"
+    if os_name == "openbsd":
+        return "openbsd"
     return "linux"
 
 

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

@@ -39,7 +39,7 @@
 //!
 //! let five = Arc::new(5);
 //!
-//! for _ in 0..10 {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -56,7 +56,7 @@
 //!
 //! let five = Arc::new(Mutex::new(5));
 //!
-//! for _ in 0..10 {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -101,7 +101,7 @@ use heap::deallocate;
 ///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
-///     for _ in 0..10 {
+///     for _ in 0u..10 {
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         Thread::spawn(move || {
@@ -661,7 +661,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_make_unique() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let mut cow1 = cow0.clone();
         let mut cow2 = cow1.clone();
 
@@ -685,7 +685,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_unique2() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let cow1 = cow0.clone();
         let cow2 = cow1.clone();
 
@@ -708,7 +708,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_weak() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let cow1_weak = cow0.downgrade();
 
         assert!(75 == *cow0);