---

yaml
---
r: 128687
b: refs/heads/try
c: 0c158b4
h: refs/heads/master
i:
  128685: b1f9352
  128683: fed406a
  128679: 4934aa5
  128671: 840f8f1
v: v3

Author: spernsteiner

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 4136d5f44d739391a60f8e51429dd30f2d96aae8
+refs/heads/try: 0c158b4fbfcec7d6f18859661047dff2109fdfe4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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
@@ -3694,94 +3614,6 @@ guide](http://doc.rust-lang.org/guide-pointers.html#rc-and-arc).
 
 # Patterns
 
-# Method Syntax
-
-Functions are great, but if you want to call a bunch of them on some data, it
-can be awkward. Consider this code:
-
-```{rust,ignore}
-baz(bar(foo(x)));
-```
-
-We would read this left-to right, and so we see 'baz bar foo.' But this isn't the
-order that the functions would get called in, that's inside-out: 'foo bar baz.'
-Wouldn't it be nice if we could do this instead?
-
-```{rust,ignore}
-x.foo().bar().baz();
-```
-
-Luckily, as you may have guessed with the leading question, you can! Rust provides
-the ability to use this **method call syntax** via the `impl` keyword.
-
-Here's how it works:
-
-```
-struct Circle {
-    x: f64,
-    y: f64,
-    radius: f64,
-}
-
-impl Circle {
-    fn area(&self) -> f64 {
-        std::f64::consts::PI * (self.radius * self.radius)
-    }
-}
-
-fn main() {
-    let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
-    println!("{}", c.area());
-}
-```
-
-This will print `12.566371`.
-
-We've made a struct that represents a circle. We then write an `impl` block,
-and inside it, define a method, `area`. Methods take a  special first
-parameter, `&self`. There are three variants: `self`, `&self`, and `&mut self`.
-You can think of this first parameter as being the `x` in `x.foo()`. The three
-variants correspond to the three kinds of thing `x` could be: `self` if it's
-just a value on the stack, `&self` if it's a reference, and `&mut self` if it's
-a mutable reference. We should default to using `&self`, as it's the most
-common.
-
-Finally, as you may remember, the value of the area of a circle is `π*r²`.
-Because we took the `&self` parameter to `area`, we can use it just like any
-other parameter. Because we know it's a `Circle`, we can access the `radius`
-just like we would with any other struct. An import of π and some
-multiplications later, and we have our area.
-
-You can also define methods that do not take a `self` parameter. Here's a
-pattern that's very common in Rust code:
-
-```
-struct Circle {
-    x: f64,
-    y: f64,
-    radius: f64,
-}
-
-impl Circle {
-    fn new(x: f64, y: f64, radius: f64) -> Circle {
-        Circle {
-            x: x,
-            y: y,
-            radius: radius,
-        }
-    }
-}
-
-fn main() {
-    let c = Circle::new(0.0, 0.0, 2.0);
-}
-```
-
-This **static method** builds a new `Circle` for us. Note that static methods
-are called with the `Struct::method()` syntax, rather than the `ref.method()`
-syntax.
-
-
 # Closures
 
 So far, we've made lots of functions in Rust. But we've given them all names.

branches/try/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/try/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/try/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/try/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;