---

yaml
---
r: 127422
b: refs/heads/auto
c: 0f5ce0f
h: refs/heads/master
v: v3

Author: Gankra

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4ed40ffe8ebbb4479f48af59781d9cf7dcc359da
+refs/heads/auto: 0f5ce0f0df106bde3b65a97079ebf8cd9e47bc20
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/CONTRIBUTING.md

@@ -16,8 +16,7 @@ please do two things:
 
 2. Run the full Rust test suite with the `make check` command.  You're
    not off the hook even if you just stick to documentation; code
-   examples in the docs are tested as well! Although for simple
-   wording or grammar fixes, this is probably unnecessary.
+   examples in the docs are tested as well!
 
 Pull requests will be treated as "review requests", and we will give
 feedback we expect to see corrected on

branches/auto/mk/main.mk

@@ -139,10 +139,6 @@ endif
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
-# Landing pads require a lot of codegen. We can get through bootstrapping faster
-# by not emitting them.
-RUSTFLAGS_STAGE0 += -Z no-landing-pads
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/auto/src/doc/guide.md

@@ -1432,86 +1432,6 @@ building our guessing game, but we need to know how to do one last thing first:
 get input from the keyboard. You can't have a guessing game without the ability
 to guess!
 
-# Strings
-
-Strings are an important concept for any programmer to master. Rust's string
-handling system is a bit different than in other languages, due to its systems
-focus. Any time you have a data structure of variable size, things can get
-tricky, and strings are a re-sizable data structure. That said, Rust's strings
-also work differently than in some other systems languages, such as C.
-
-Let's dig into the details. A **string** is a sequence of unicode scalar values
-encoded as a stream of UTF-8 bytes. All strings are guaranteed to be
-validly-encoded UTF-8 sequences. Additionally, strings are not null-terminated
-and can contain null bytes.
-
-Rust has two main types of strings: `&str` and `String`.
-
-The first kind is a `&str`. This is pronounced a 'string slice.' String literals
-are of the type `&str`:
-
-```{rust}
-let string = "Hello there.";
-```
-
-This string is statically allocated, meaning that it's saved inside our
-compiled program, and exists for the entire duration it runs. The `string`
-binding is a reference to this statically allocated string. String slices
-have a fixed size, and cannot be mutated.
-
-A `String`, on the other hand, is an in-memory string.  This string is
-growable, and is also guaranteed to be UTF-8.
-
-```{rust}
-let mut s = "Hello".to_string();
-println!("{}", s);
-
-s.push_str(", world.");
-println!("{}", s);
-```
-
-You can coerce a `String` into a `&str` with the `as_slice()` method:
-
-```{rust}
-fn takes_slice(slice: &str) {
-    println!("Got: {}", slice);
-}
-
-fn main() {
-    let s = "Hello".to_string();
-    takes_slice(s.as_slice());
-}
-```
-
-To compare a String to a constant string, prefer `as_slice()`...
-
-```{rust}
-fn compare(string: String) {
-    if string.as_slice() == "Hello" {
-        println!("yes");
-    }
-}
-```
-
-... over `to_string()`:
-
-```{rust}
-fn compare(string: String) {
-    if string == "Hello".to_string() {
-        println!("yes");
-    }
-}
-```
-
-Converting a `String` to a `&str` is cheap, but converting the `&str` to a
-`String` involves allocating memory. No reason to do that unless you have to!
-
-That's the basics of strings in Rust! They're probably a bit more complicated
-than you are used to, if you come from a scripting language, but when the
-low-level details matter, they really matter. Just remember that `String`s
-allocate memory and control their data, while `&str`s are a reference to
-another string, and you'll be all set.
-
 # Standard Input
 
 Getting input from the keyboard is pretty easy, but uses some things

branches/auto/src/libcollections/ringbuf.rs

@@ -403,11 +403,11 @@ impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
 fn grow<T>(nelts: uint, loptr: &mut uint, elts: &mut Vec<Option<T>>) {
     assert_eq!(nelts, elts.len());
     let lo = *loptr;
-    elts.reserve(nelts * 2);
-    let newlen = elts.capacity();
+    let newlen = nelts * 2;
+    elts.reserve(newlen);
 
     /* fill with None */
-    for _ in range(elts.len(), newlen) {
+    for _ in range(elts.len(), elts.capacity()) {
         elts.push(None);
     }
 
@@ -750,47 +750,6 @@ mod tests {
         assert_eq!(d.len(), 1);
     }
 
-    #[test]
-    fn test_with_capacity_non_power_two() {
-        let mut d3 = RingBuf::with_capacity(3);
-        d3.push(1i);
-
-        // X = None, | = lo
-        // [|1, X, X]
-        assert_eq!(d3.pop_front(), Some(1));
-        // [X, |X, X]
-        assert_eq!(d3.front(), None);
-
-        // [X, |3, X]
-        d3.push(3);
-        // [X, |3, 6]
-        d3.push(6);
-        // [X, X, |6]
-        assert_eq!(d3.pop_front(), Some(3));
-
-        // Pushing the lo past half way point to trigger
-        // the 'B' scenario for growth
-        // [9, X, |6]
-        d3.push(9);
-        // [9, 12, |6]
-        d3.push(12);
-
-        d3.push(15);
-        // There used to be a bug here about how the
-        // RingBuf made growth assumptions about the
-        // underlying Vec which didn't hold and lead
-        // to corruption.
-        // (Vec grows to next power of two)
-        //good- [9, 12, 15, X, X, X, X, |6]
-        //bug-  [15, 12, X, X, X, |6, X, X]
-        assert_eq!(d3.pop_front(), Some(6));
-
-        // Which leads us to the following state which
-        // would be a failure case.
-        //bug-  [15, 12, X, X, X, X, |X, X]
-        assert_eq!(d3.front(), Some(&9));
-    }
-
     #[test]
     fn test_reserve_exact() {
         let mut d = RingBuf::new();

branches/auto/src/libcore/num/f32.rs

@@ -293,7 +293,7 @@ impl Float for f32 {
     #[inline]
     fn frac_pi_8() -> f32 { consts::FRAC_PI_8 }
 
-    /// 1.0 / pi
+    /// 1 .0/ pi
     #[inline]
     fn frac_1_pi() -> f32 { consts::FRAC_1_PI }
 

branches/auto/src/liblibc/lib.rs

@@ -1142,16 +1142,18 @@ pub mod types {
     pub mod os {
         pub mod common {
             pub mod posix01 {
-                use types::os::arch::c95::{c_short, time_t, c_long};
+                use types::os::arch::c95::{c_short, time_t, suseconds_t,
+                                                 c_long};
                 use types::os::arch::extra::{int64, time64_t};
                 use types::os::arch::posix88::{dev_t, ino_t};
+                use types::os::arch::posix88::mode_t;
 
                 // pub Note: this is the struct called stat64 in win32. Not stat,
                 // nor stati64.
                 pub struct stat {
                     pub st_dev: dev_t,
                     pub st_ino: ino_t,
-                    pub st_mode: u16,
+                    pub st_mode: mode_t,
                     pub st_nlink: c_short,
                     pub st_uid: c_short,
                     pub st_gid: c_short,
@@ -1169,8 +1171,8 @@ pub mod types {
                 }
 
                 pub struct timeval {
-                    pub tv_sec: c_long,
-                    pub tv_usec: c_long,
+                    pub tv_sec: time_t,
+                    pub tv_usec: suseconds_t,
                 }
 
                 pub struct timespec {
@@ -1184,7 +1186,7 @@ pub mod types {
             pub mod bsd44 {
                 use types::os::arch::c95::{c_char, c_int, c_uint, size_t};
 
-                pub type SOCKET = uint;
+                pub type SOCKET = c_uint;
                 pub type socklen_t = c_int;
                 pub type sa_family_t = u16;
                 pub type in_port_t = u16;
@@ -1195,7 +1197,6 @@ pub mod types {
                 }
                 pub struct sockaddr_storage {
                     pub ss_family: sa_family_t,
-                    pub __ss_pad1: [u8, ..6],
                     pub __ss_align: i64,
                     pub __ss_pad2: [u8, ..112],
                 }
@@ -1292,9 +1293,12 @@ pub mod types {
             pub mod posix88 {
                 pub type off_t = i32;
                 pub type dev_t = u32;
-                pub type ino_t = u16;
+                pub type ino_t = i16;
 
-                pub type pid_t = u32;
+                #[cfg(target_arch = "x86")]
+                pub type pid_t = i32;
+                #[cfg(target_arch = "x86_64")]
+                pub type pid_t = i64;
 
                 pub type useconds_t = u32;
                 pub type mode_t = u16;
@@ -1411,7 +1415,7 @@ pub mod types {
                     pub dwPageSize: DWORD,
                     pub lpMinimumApplicationAddress: LPVOID,
                     pub lpMaximumApplicationAddress: LPVOID,
-                    pub dwActiveProcessorMask: uint,
+                    pub dwActiveProcessorMask: DWORD,
                     pub dwNumberOfProcessors: DWORD,
                     pub dwProcessorType: DWORD,
                     pub dwAllocationGranularity: DWORD,
@@ -1946,7 +1950,7 @@ pub mod consts {
         }
         pub mod extra {
             use types::os::arch::c95::c_int;
-            use types::os::arch::extra::{WORD, DWORD, BOOL, HANDLE};
+            use types::os::arch::extra::{WORD, DWORD, BOOL};
 
             pub static TRUE : BOOL = 1;
             pub static FALSE : BOOL = 0;
@@ -1975,7 +1979,7 @@ pub mod consts {
             pub static ERROR_IO_PENDING: c_int = 997;
             pub static ERROR_FILE_INVALID : c_int = 1006;
             pub static ERROR_NOT_FOUND: c_int = 1168;
-            pub static INVALID_HANDLE_VALUE: HANDLE = -1 as HANDLE;
+            pub static INVALID_HANDLE_VALUE : c_int = -1;
 
             pub static DELETE : DWORD = 0x00010000;
             pub static READ_CONTROL : DWORD = 0x00020000;

branches/auto/src/libnative/io/c_win32.rs

@@ -28,7 +28,6 @@ pub static ENABLE_PROCESSED_INPUT: libc::DWORD = 0x1;
 pub static ENABLE_QUICK_EDIT_MODE: libc::DWORD = 0x40;
 
 #[repr(C)]
-#[cfg(target_arch = "x86")]
 pub struct WSADATA {
     pub wVersion: libc::WORD,
     pub wHighVersion: libc::WORD,
@@ -38,17 +37,6 @@ pub struct WSADATA {
     pub iMaxUdpDg: u16,
     pub lpVendorInfo: *mut u8,
 }
-#[repr(C)]
-#[cfg(target_arch = "x86_64")]
-pub struct WSADATA {
-    pub wVersion: libc::WORD,
-    pub wHighVersion: libc::WORD,
-    pub iMaxSockets: u16,
-    pub iMaxUdpDg: u16,
-    pub lpVendorInfo: *mut u8,
-    pub szDescription: [u8, ..WSADESCRIPTION_LEN + 1],
-    pub szSystemStatus: [u8, ..WSASYS_STATUS_LEN + 1],
-}
 
 pub type LPWSADATA = *mut WSADATA;
 

branches/auto/src/libnative/io/file_win32.rs

@@ -320,7 +320,7 @@ pub fn open(path: &CString, fm: rtio::FileMode, fa: rtio::FileAccess)
                           dwFlagsAndAttributes,
                           ptr::mut_null())
     };
-    if handle == libc::INVALID_HANDLE_VALUE {
+    if handle == libc::INVALID_HANDLE_VALUE as libc::HANDLE {
         Err(super::last_error())
     } else {
         let fd = unsafe {
@@ -368,7 +368,7 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
         let wfd_ptr = malloc_raw(rust_list_dir_wfd_size() as uint);
         let find_handle = libc::FindFirstFileW(path.as_ptr(),
                                                wfd_ptr as libc::HANDLE);
-        if find_handle != libc::INVALID_HANDLE_VALUE {
+        if find_handle as libc::c_int != libc::INVALID_HANDLE_VALUE {
             let mut paths = vec!();
             let mut more_files = 1 as libc::c_int;
             while more_files != 0 {
@@ -440,7 +440,7 @@ pub fn readlink(p: &CString) -> IoResult<CString> {
                           libc::FILE_ATTRIBUTE_NORMAL,
                           ptr::mut_null())
     };
-    if handle == libc::INVALID_HANDLE_VALUE {
+    if handle as int == libc::INVALID_HANDLE_VALUE as int {
         return Err(super::last_error())
     }
     // Specify (sz - 1) because the documentation states that it's the size

branches/auto/src/libnative/io/pipe_win32.rs

@@ -223,7 +223,7 @@ impl UnixStream {
                 libc::FILE_FLAG_OVERLAPPED,
                 ptr::mut_null())
         };
-        if result != libc::INVALID_HANDLE_VALUE {
+        if result != libc::INVALID_HANDLE_VALUE as libc::HANDLE {
             return Some(result)
         }
 
@@ -238,7 +238,7 @@ impl UnixStream {
                     libc::FILE_FLAG_OVERLAPPED,
                     ptr::mut_null())
             };
-            if result != libc::INVALID_HANDLE_VALUE {
+            if result != libc::INVALID_HANDLE_VALUE as libc::HANDLE {
                 return Some(result)
             }
         }
@@ -253,7 +253,7 @@ impl UnixStream {
                     libc::FILE_FLAG_OVERLAPPED,
                     ptr::mut_null())
             };
-            if result != libc::INVALID_HANDLE_VALUE {
+            if result != libc::INVALID_HANDLE_VALUE as libc::HANDLE {
                 return Some(result)
             }
         }
@@ -565,7 +565,7 @@ impl UnixListener {
         // and such.
         let addr_v = try!(to_utf16(addr));
         let ret = unsafe { pipe(addr_v.as_ptr(), true) };
-        if ret == libc::INVALID_HANDLE_VALUE {
+        if ret == libc::INVALID_HANDLE_VALUE as libc::HANDLE {
             Err(super::last_error())
         } else {
             Ok(UnixListener { handle: ret, name: addr.clone() })
@@ -680,7 +680,7 @@ impl UnixAcceptor {
         // create a second server pipe. If this fails, we disconnect the
         // connected client and return an error (see comments above).
         let new_handle = unsafe { pipe(name.as_ptr(), false) };
-        if new_handle == libc::INVALID_HANDLE_VALUE {
+        if new_handle == libc::INVALID_HANDLE_VALUE as libc::HANDLE {
             let ret = Err(super::last_error());
             // If our disconnection fails, then there's not really a whole lot
             // that we can do, so fail the task.