---

yaml
---
r: 101867
b: refs/heads/master
c: 359ac36
h: refs/heads/master
i:
  101865: 6725b9e
  101863: e900571
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4af28c98fac5bc36a93527b79c77081eedfb554b
+refs/heads/master: 359ac360a453b31494d18bf838f6620032a663e5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/src/doc/guide-ffi.md

@@ -229,7 +229,7 @@ impl<T: Send> Drop for Unique<T> {
             let x = mem::uninit(); // dummy value to swap in
             // We need to move the object out of the box, so that
             // the destructor is called (at the end of this scope.)
-            ptr::replace(self.ptr, x);
+            ptr::replace_ptr(self.ptr, x);
             free(self.ptr as *mut c_void)
         }
     }
@@ -306,7 +306,7 @@ which would call back to `callback()` in Rust.
 The former example showed how a global function can be called from C code.
 However it is often desired that the callback is targetted to a special
 Rust object. This could be the object that represents the wrapper for the
-respective C object.
+respective C object. 
 
 This can be achieved by passing an unsafe pointer to the object down to the
 C library. The C library can then include the pointer to the Rust object in
@@ -335,7 +335,7 @@ extern {
 fn main() {
     // Create the object that will be referenced in the callback
     let rust_object = ~RustObject{a: 5, ...};
-
+     
     unsafe {
         // Gets a raw pointer to the object
         let target_addr:*RustObject = ptr::to_unsafe_ptr(rust_object);
@@ -380,8 +380,8 @@ Rust is to use channels (in `std::comm`) to forward data from the C thread
 that invoked the callback into a Rust task.
 
 If an asychronous callback targets a special object in the Rust address space
-it is also absolutely necessary that no more callbacks are performed by the
-C library after the respective Rust object gets destroyed.
+it is also absolutely necessary that no more callbacks are performed by the 
+C library after the respective Rust object gets destroyed. 
 This can be achieved by unregistering the callback in the object's
 destructor and designing the library in a way that guarantees that no
 callback will be performed after unregistration.

trunk/src/doc/tutorial.md

@@ -3240,6 +3240,7 @@ guides on individual topics.
 * [Macros][macros]
 * [The foreign function interface][ffi]
 * [Containers and iterators][container]
+* [Error-handling and Conditions][conditions]
 * [Documenting Rust code][rustdoc]
 * [Testing Rust code][testing]
 * [The Rust Runtime][runtime]
@@ -3252,6 +3253,7 @@ There is further documentation on the [wiki], however those tend to be even more
 [macros]: guide-macros.html
 [ffi]: guide-ffi.html
 [container]: guide-container.html
+[conditions]: guide-conditions.html
 [testing]: guide-testing.html
 [runtime]: guide-runtime.html
 [rustdoc]: rustdoc.html

trunk/src/libcollections/dlist.rs

@@ -83,7 +83,7 @@ impl<T> Rawlink<T> {
 
     /// Like Option::Some for Rawlink
     fn some(n: &mut T) -> Rawlink<T> {
-        Rawlink{p: n}
+        Rawlink{p: ptr::to_mut_unsafe_ptr(n)}
     }
 
     /// Convert the `Rawlink` into an Option value

trunk/src/librustc/middle/trans/base.rs

@@ -273,15 +273,7 @@ pub fn decl_rust_fn(ccx: &CrateContext, has_env: bool,
                     llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
                 }
             }
-            _ => {
-                // For non-immediate arguments the callee gets its own copy of
-                // the value on the stack, so there are no aliases
-                if !type_is_immediate(ccx, arg_ty) {
-                    unsafe {
-                        llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
-                    }
-                }
-            }
+            _ => {}
         }
     }
 

trunk/src/librustc/middle/ty.rs

@@ -33,6 +33,7 @@ use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::hashmap::{HashMap, HashSet};
 use std::ops;
+use std::ptr::to_unsafe_ptr;
 use std::rc::Rc;
 use std::to_bytes;
 use std::to_str::ToStr;
@@ -1136,7 +1137,7 @@ pub fn mk_t(cx: ctxt, st: sty) -> t {
         _ => {}
     };
 
-    let key = intern_key { sty: &st };
+    let key = intern_key { sty: to_unsafe_ptr(&st) };
 
     {
         let mut interner = cx.interner.borrow_mut();
@@ -1233,7 +1234,7 @@ pub fn mk_t(cx: ctxt, st: sty) -> t {
         flags: flags,
     };
 
-    let sty_ptr = &t.sty as *sty;
+    let sty_ptr = to_unsafe_ptr(&t.sty);
 
     let key = intern_key {
         sty: sty_ptr,

trunk/src/libstd/c_str.rs

@@ -79,7 +79,6 @@ use str;
 use vec::{ImmutableVector, MutableVector};
 use vec;
 use rt::global_heap::malloc_raw;
-use unstable::raw::Slice;
 
 /// The representation of a C String.
 ///
@@ -170,7 +169,6 @@ impl CString {
     }
 
     /// Converts the CString into a `&[u8]` without copying.
-    /// Includes the terminating NUL byte.
     ///
     /// # Failure
     ///
@@ -179,21 +177,7 @@ impl CString {
     pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
         if self.buf.is_null() { fail!("CString is null!"); }
         unsafe {
-            cast::transmute(Slice { data: self.buf, len: self.len() + 1 })
-        }
-    }
-
-    /// Converts the CString into a `&[u8]` without copying.
-    /// Does not include the terminating NUL byte.
-    ///
-    /// # Failure
-    ///
-    /// Fails if the CString is null.
-    #[inline]
-    pub fn as_bytes_no_nul<'a>(&'a self) -> &'a [u8] {
-        if self.buf.is_null() { fail!("CString is null!"); }
-        unsafe {
-            cast::transmute(Slice { data: self.buf, len: self.len() })
+            cast::transmute((self.buf, self.len() + 1))
         }
     }
 
@@ -205,7 +189,8 @@ impl CString {
     /// Fails if the CString is null.
     #[inline]
     pub fn as_str<'a>(&'a self) -> Option<&'a str> {
-        let buf = self.as_bytes_no_nul();
+        let buf = self.as_bytes();
+        let buf = buf.slice_to(buf.len()-1); // chop off the trailing NUL
         str::from_utf8(buf)
     }
 
@@ -432,7 +417,7 @@ mod tests {
             let expected = ["zero", "one"];
             let mut it = expected.iter();
             let result = from_c_multistring(ptr as *libc::c_char, None, |c| {
-                let cbytes = c.as_bytes_no_nul();
+                let cbytes = c.as_bytes().slice_to(c.len());
                 assert_eq!(cbytes, it.next().unwrap().as_bytes());
             });
             assert_eq!(result, 2);
@@ -567,31 +552,13 @@ mod tests {
         assert_eq!(c_str.as_bytes(), bytes!("foo", 0xff, 0));
     }
 
-    #[test]
-    fn test_as_bytes_no_nul() {
-        let c_str = "hello".to_c_str();
-        assert_eq!(c_str.as_bytes_no_nul(), bytes!("hello"));
-        let c_str = "".to_c_str();
-        let exp: &[u8] = [];
-        assert_eq!(c_str.as_bytes_no_nul(), exp);
-        let c_str = bytes!("foo", 0xff).to_c_str();
-        assert_eq!(c_str.as_bytes_no_nul(), bytes!("foo", 0xff));
-    }
-
     #[test]
     #[should_fail]
     fn test_as_bytes_fail() {
         let c_str = unsafe { CString::new(ptr::null(), false) };
         c_str.as_bytes();
     }
 
-    #[test]
-    #[should_fail]
-    fn test_as_bytes_no_nul_fail() {
-        let c_str = unsafe { CString::new(ptr::null(), false) };
-        c_str.as_bytes_no_nul();
-    }
-
     #[test]
     fn test_as_str() {
         let c_str = "hello".to_c_str();

trunk/src/libstd/fmt/mod.rs

@@ -1200,17 +1200,7 @@ impl<T> Pointer for *T {
 }
 impl<T> Pointer for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(*self as *T), f)
-    }
-}
-impl<'a, T> Pointer for &'a T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(&**self as *T), f)
-    }
-}
-impl<'a, T> Pointer for &'a mut T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(&**self as *T), f)
+        secret_pointer(&(*self as *T), f)
     }
 }
 

trunk/src/libstd/hashmap.rs

@@ -56,7 +56,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv, max};
 use default::Default;
-#[cfg(not(stage0))] use fmt;
+use fmt;
 use hash::Hash;
 use iter;
 use iter::{Iterator, FromIterator, Extendable};
@@ -66,7 +66,7 @@ use num;
 use option::{None, Option, Some};
 use rand::Rng;
 use rand;
-#[cfg(not(stage0))] use result::{Ok, Err};
+use result::{Ok, Err};
 use vec::{ImmutableVector, MutableVector, OwnedVector, Items, MutItems};
 use vec_ng;
 use vec_ng::Vec;
@@ -597,7 +597,6 @@ impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
     }
 }
 
-#[cfg(not(stage0))]
 impl<A: fmt::Show + Hash + Eq, B: fmt::Show> fmt::Show for HashMap<A, B> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if_ok!(write!(f.buf, r"\{"))
@@ -876,7 +875,6 @@ impl<T:Hash + Eq + Clone> Clone for HashSet<T> {
     }
 }
 
-#[cfg(not(stage0))]
 impl<A: fmt::Show + Hash + Eq> fmt::Show for HashSet<A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if_ok!(write!(f.buf, r"\{"))

trunk/src/libstd/io/mod.rs

@@ -779,13 +779,6 @@ pub trait Reader {
         self.read_byte().map(|i| i as i8)
     }
 
-    /// Creates a wrapper around a mutable reference to the reader.
-    ///
-    /// This is useful to allow applying adaptors while still
-    /// retaining ownership of the original value.
-    fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self> {
-        RefReader { inner: self }
-    }
 }
 
 impl Reader for ~Reader {
@@ -796,14 +789,6 @@ impl<'a> Reader for &'a mut Reader {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.read(buf) }
 }
 
-pub struct RefReader<'a, R> {
-    priv inner: &'a mut R
-}
-
-impl<'a, R: Reader> Reader for RefReader<'a, R> {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.inner.read(buf) }
-}
-
 fn extend_sign(val: u64, nbytes: uint) -> i64 {
     let shift = (8 - nbytes) * 8;
     (val << shift) as i64 >> shift
@@ -984,14 +969,6 @@ pub trait Writer {
     fn write_i8(&mut self, n: i8) -> IoResult<()> {
         self.write([n as u8])
     }
-
-    /// Creates a wrapper around a mutable reference to the writer.
-    ///
-    /// This is useful to allow applying wrappers while still
-    /// retaining ownership of the original value.
-    fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self> {
-        RefWriter { inner: self }
-    }
 }
 
 impl Writer for ~Writer {
@@ -1004,16 +981,6 @@ impl<'a> Writer for &'a mut Writer {
     fn flush(&mut self) -> IoResult<()> { self.flush() }
 }
 
-pub struct RefWriter<'a, W> {
-    inner: &'a mut W
-}
-
-impl<'a, W: Writer> Writer for RefWriter<'a, W> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.inner.write(buf) }
-    fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
-}
-
-
 pub trait Stream: Reader + Writer { }
 
 impl<T: Reader + Writer> Stream for T {}

trunk/src/libstd/io/test.rs

@@ -155,15 +155,17 @@ mod darwin_fd_limit {
     pub unsafe fn raise_fd_limit() {
         // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
         // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
-        use ptr::mut_null;
+        use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null};
         use mem::size_of_val;
         use os::last_os_error;
 
         // Fetch the kern.maxfilesperproc value
         let mut mib: [libc::c_int, ..2] = [CTL_KERN, KERN_MAXFILESPERPROC];
         let mut maxfiles: libc::c_int = 0;
         let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t;
-        if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size,
+        if sysctl(to_mut_unsafe_ptr(&mut mib[0]), 2,
+                  to_mut_unsafe_ptr(&mut maxfiles) as *mut libc::c_void,
+                  to_mut_unsafe_ptr(&mut size),
                   mut_null(), 0) != 0 {
             let err = last_os_error();
             error!("raise_fd_limit: error calling sysctl: {}", err);
@@ -172,7 +174,7 @@ mod darwin_fd_limit {
 
         // Fetch the current resource limits
         let mut rlim = rlimit{rlim_cur: 0, rlim_max: 0};
-        if getrlimit(RLIMIT_NOFILE, &mut rlim) != 0 {
+        if getrlimit(RLIMIT_NOFILE, to_mut_unsafe_ptr(&mut rlim)) != 0 {
             let err = last_os_error();
             error!("raise_fd_limit: error calling getrlimit: {}", err);
             return;
@@ -182,7 +184,7 @@ mod darwin_fd_limit {
         rlim.rlim_cur = ::cmp::min(maxfiles as rlim_t, rlim.rlim_max);
 
         // Set our newly-increased resource limit
-        if setrlimit(RLIMIT_NOFILE, &rlim) != 0 {
+        if setrlimit(RLIMIT_NOFILE, to_unsafe_ptr(&rlim)) != 0 {
             let err = last_os_error();
             error!("raise_fd_limit: error calling setrlimit: {}", err);
             return;

trunk/src/libstd/io/util.rs

@@ -14,20 +14,19 @@ use io;
 use vec::bytes::MutableByteVector;
 
 /// Wraps a `Reader`, limiting the number of bytes that can be read from it.
-pub struct LimitReader<R> {
+pub struct LimitReader<'a, R> {
     priv limit: uint,
-    priv inner: R
+    priv inner: &'a mut R
 }
 
-impl<R: Reader> LimitReader<R> {
+impl<'a, R: Reader> LimitReader<'a, R> {
     /// Creates a new `LimitReader`
-    pub fn new(r: R, limit: uint) -> LimitReader<R> {
+    pub fn new<'a>(r: &'a mut R, limit: uint) -> LimitReader<'a, R> {
         LimitReader { limit: limit, inner: r }
     }
-    pub fn unwrap(self) -> R { self.inner }
 }
 
-impl<R: Reader> Reader for LimitReader<R> {
+impl<'a, R: Reader> Reader for LimitReader<'a, R> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         if self.limit == 0 {
             return Err(io::standard_error(io::EndOfFile));
@@ -193,7 +192,7 @@ mod test {
     fn test_bounded_reader_unlimited() {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
-            let mut r = LimitReader::new(r.by_ref(), 4);
+            let mut r = LimitReader::new(&mut r, 4);
             assert_eq!(~[0, 1, 2], r.read_to_end().unwrap());
         }
     }
@@ -202,7 +201,7 @@ mod test {
     fn test_bound_reader_limited() {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
-            let mut r = LimitReader::new(r.by_ref(), 2);
+            let mut r = LimitReader::new(&mut r, 2);
             assert_eq!(~[0, 1], r.read_to_end().unwrap());
         }
         assert_eq!(~[2], r.read_to_end().unwrap());