gistfile1.diff

diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index ce3fc46..d3dea6c 100644
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -387,7 +387,8 @@ impl<T> TypedArenaChunk<T> {
             None => {}
             Some(mut next) => {
                 // We assume that the next chunk is completely filled.
-                next.destroy(next.capacity)
+                let capacity = next.capacity;
+                next.destroy(capacity)
             }
         }
     }
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index f45c968..18ae5e2 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -61,7 +61,8 @@ impl<T> Deque<T> for RingBuf<T> {
 
     /// Return a mutable reference to the last element in the RingBuf
     fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
-        if self.nelts > 0 { Some(self.get_mut(self.nelts - 1)) } else { None }
+        let nelts = self.nelts;
+        if nelts > 0 { Some(self.get_mut(nelts - 1)) } else { None }
     }
 
     /// Remove and return the first element in the RingBuf, or None if it is empty
diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs
index cacd38c..bd163fe 100644
--- a/src/libnative/io/net.rs
+++ b/src/libnative/io/net.rs
@@ -622,7 +622,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
                 mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
 
         let dolock = || self.lock_nonblocking();
-        let doread = |nb| unsafe {
+        let n = try!(read(fd, self.read_deadline, dolock, |nb| unsafe {
             let flags = if nb {c::MSG_DONTWAIT} else {0};
             libc::recvfrom(fd,
                            buf.as_mut_ptr() as *mut libc::c_void,
@@ -630,8 +630,7 @@ impl rtio::RtioUdpSocket for UdpSocket {
                            flags,
                            storagep,
                            &mut addrlen) as libc::c_int
-        };
-        let n = try!(read(fd, self.read_deadline, dolock, doread));
+        }));
         sockaddr_to_addr(&storage, addrlen as uint).and_then(|addr| {
             Ok((n as uint, addr))
         })
diff --git a/src/libregex/parse/mod.rs b/src/libregex/parse/mod.rs
index bc36558..39f7bd6 100644
--- a/src/libregex/parse/mod.rs
+++ b/src/libregex/parse/mod.rs
@@ -342,18 +342,19 @@ impl<'a> Parser<'a> {
     }
 
     fn push_literal(&mut self, c: char) -> Result<(), Error> {
+        let flags = self.flags;
         match c {
             '.' => {
-                self.push(Dot(self.flags))
+                self.push(Dot(flags))
             }
             '^' => {
-                self.push(Begin(self.flags))
+                self.push(Begin(flags))
             }
             '$' => {
-                self.push(End(self.flags))
+                self.push(End(flags))
             }
             _ => {
-                self.push(Literal(c, self.flags))
+                self.push(Literal(c, flags))
             }
         }
         Ok(())
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index d800232..17c5070 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -140,13 +140,15 @@ impl<'a> ReprVisitor<'a> {
     #[inline]
     pub fn get<T>(&mut self, f: |&mut ReprVisitor, &T| -> bool) -> bool {
         unsafe {
-            f(self, transmute::<*u8,&T>(self.ptr))
+            let ptr = self.ptr;
+            f(self, transmute::<*u8,&T>(ptr))
         }
     }
 
     #[inline]
     pub fn visit_inner(&mut self, inner: *TyDesc) -> bool {
-        self.visit_ptr_inner(self.ptr, inner)
+        let ptr = self.ptr;
+        self.visit_ptr_inner(ptr, inner)
     }
 
     #[inline]
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 3c1e83e..e66ecfe 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -117,8 +117,9 @@ impl<T> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
             while xs.len < length {
-                mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(xs.len),
-                                   op(xs.len));
+                let len = xs.len;
+                mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(len),
+                                   op(len));
                 xs.len += 1;
             }
             xs
@@ -214,7 +215,8 @@ impl<T: Clone> Vec<T> {
         unsafe {
             let mut xs = Vec::with_capacity(length);
             while xs.len < length {
-                mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(xs.len),
+                let len = xs.len;
+                mem::overwrite(xs.as_mut_slice().unsafe_mut_ref(len),
                                    value.clone());
                 xs.len += 1;
             }
@@ -325,9 +327,10 @@ impl<T:Clone> Clone for Vec<T> {
             let this_slice = self.as_slice();
             while vector.len < len {
                 unsafe {
+                    let len = vector.len;
                     mem::overwrite(
-                        vector.as_mut_slice().unsafe_mut_ref(vector.len),
-                        this_slice.unsafe_ref(vector.len).clone());
+                        vector.as_mut_slice().unsafe_mut_ref(len),
+                        this_slice.unsafe_ref(len).clone());
                 }
                 vector.len += 1;
             }
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index 6b96a78..f023592 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -349,7 +349,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                         let res = format(stack.pop().unwrap(), FormatOp::from_char(cur), *flags);
                         if res.is_err() { return res }
                         output.push_all(res.unwrap().as_slice());
-                        old_state = state; // will cause state to go to Nothing
+                        old_state = FormatPattern(*flags, *fstate); // will cause state to go to Nothing
                     } else { return Err("stack is empty".to_strbuf()) },
                     (FormatStateFlags,'#') => {
                         flags.alternate = true;