Bring in the line-length police

Author: alexcrichton

src/libgreen/stack.rs

@@ -10,45 +10,46 @@
 
 use std::rt::env::max_cached_stacks;
 use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
-    MapNonStandardFlags, MapVirtual};
-#[cfg(not(windows))]
-use std::libc::{MAP_STACK, MAP_PRIVATE, MAP_ANON};
-use std::libc::{c_uint, c_int, c_void, uintptr_t};
+              MapNonStandardFlags, MapVirtual};
+use std::libc;
 
 /// A task's stack. The name "Stack" is a vestige of segmented stacks.
 pub struct Stack {
     priv buf: MemoryMap,
     priv min_size: uint,
-    priv valgrind_id: c_uint,
+    priv valgrind_id: libc::c_uint,
 }
 
 // Try to use MAP_STACK on platforms that support it (it's what we're doing
 // anyway), but some platforms don't support it at all. For example, it appears
 // that there's a bug in freebsd that MAP_STACK implies MAP_FIXED (so it always
 // fails): http://lists.freebsd.org/pipermail/freebsd-bugs/2011-July/044840.html
 #[cfg(not(windows), not(target_os = "freebsd"))]
-static STACK_FLAGS: c_int = MAP_STACK | MAP_PRIVATE | MAP_ANON;
+static STACK_FLAGS: libc::c_int = libc::MAP_STACK | libc::MAP_PRIVATE |
+                                  libc::MAP_ANON;
 #[cfg(target_os = "freebsd")]
-static STACK_FLAGS: c_int = MAP_PRIVATE | MAP_ANON;
+static STACK_FLAGS: libc::c_int = libc::MAP_PRIVATE | libc::MAP_ANON;
 #[cfg(windows)]
-static STACK_FLAGS: c_int = 0;
+static STACK_FLAGS: libc::c_int = 0;
 
 impl Stack {
     /// Allocate a new stack of `size`. If size = 0, this will fail. Use
     /// `dummy_stack` if you want a zero-sized stack.
     pub fn new(size: uint) -> Stack {
-        // Map in a stack. Eventually we might be able to handle stack allocation failure, which
-        // would fail to spawn the task. But there's not many sensible things to do on OOM.
-        // Failure seems fine (and is what the old stack allocation did).
+        // Map in a stack. Eventually we might be able to handle stack
+        // allocation failure, which would fail to spawn the task. But there's
+        // not many sensible things to do on OOM.  Failure seems fine (and is
+        // what the old stack allocation did).
         let stack = match MemoryMap::new(size, [MapReadable, MapWritable,
                                          MapNonStandardFlags(STACK_FLAGS)]) {
             Ok(map) => map,
-            Err(e) => fail!("Creating memory map for stack of size {} failed: {}", size, e)
+            Err(e) => fail!("mmap for stack of size {} failed: {}", size, e)
         };
 
-        // Change the last page to be inaccessible. This is to provide safety; when an FFI
-        // function overflows it will (hopefully) hit this guard page. It isn't guaranteed, but
-        // that's why FFI is unsafe. buf.data is guaranteed to be aligned properly.
+        // Change the last page to be inaccessible. This is to provide safety;
+        // when an FFI function overflows it will (hopefully) hit this guard
+        // page. It isn't guaranteed, but that's why FFI is unsafe. buf.data is
+        // guaranteed to be aligned properly.
         if !protect_last_page(&stack) {
             fail!("Could not memory-protect guard page. stack={:?}, errno={}",
                   stack, errno());
@@ -61,7 +62,9 @@ impl Stack {
         };
 
         // XXX: Using the FFI to call a C macro. Slow
-        stk.valgrind_id = unsafe { rust_valgrind_stack_register(stk.start(), stk.end()) };
+        stk.valgrind_id = unsafe {
+            rust_valgrind_stack_register(stk.start(), stk.end())
+        };
         return stk;
     }
 
@@ -87,30 +90,27 @@ impl Stack {
     }
 }
 
-// These use ToPrimitive so that we never need to worry about the sizes of whatever types these
-// (which we would with scalar casts). It's either a wrapper for a scalar cast or failure: fast, or
-// will fail during compilation.
 #[cfg(unix)]
 fn protect_last_page(stack: &MemoryMap) -> bool {
-    use std::libc::{mprotect, PROT_NONE, size_t};
     unsafe {
-        // This may seem backwards: the start of the segment is the last page? Yes! The stack grows
-        // from higher addresses (the end of the allocated block) to lower addresses (the start of
-        // the allocated block).
-        let last_page = stack.data as *c_void;
-        mprotect(last_page, page_size() as size_t, PROT_NONE) != -1
+        // This may seem backwards: the start of the segment is the last page?
+        // Yes! The stack grows from higher addresses (the end of the allocated
+        // block) to lower addresses (the start of the allocated block).
+        let last_page = stack.data as *libc::c_void;
+        libc::mprotect(last_page, page_size() as libc::size_t,
+                       libc::PROT_NONE) != -1
     }
 }
 
 #[cfg(windows)]
 fn protect_last_page(stack: &MemoryMap) -> bool {
-    use std::libc::{VirtualProtect, PAGE_NOACCESS, SIZE_T, LPDWORD, DWORD};
     unsafe {
         // see above
-        let last_page = stack.data as *mut c_void;
-        let mut old_prot: DWORD = 0;
-        VirtualProtect(last_page, page_size() as SIZE_T, PAGE_NOACCESS,
-                       &mut old_prot as LPDWORD) != 0
+        let last_page = stack.data as *mut libc::c_void;
+        let mut old_prot: libc::DWORD = 0;
+        libc::VirtualProtect(last_page, page_size() as libc::SIZE_T,
+                             libc::PAGE_NOACCESS,
+                             &mut old_prot as libc::LPDWORD) != 0
     }
 }
 
@@ -124,7 +124,8 @@ impl Drop for Stack {
 }
 
 pub struct StackPool {
-    // Ideally this would be some datastructure that preserved ordering on Stack.min_size.
+    // Ideally this would be some datastructure that preserved ordering on
+    // Stack.min_size.
     priv stacks: ~[Stack],
 }
 
@@ -151,6 +152,7 @@ impl StackPool {
 }
 
 extern {
-    fn rust_valgrind_stack_register(start: *uintptr_t, end: *uintptr_t) -> c_uint;
-    fn rust_valgrind_stack_deregister(id: c_uint);
+    fn rust_valgrind_stack_register(start: *libc::uintptr_t,
+                                    end: *libc::uintptr_t) -> libc::c_uint;
+    fn rust_valgrind_stack_deregister(id: libc::c_uint);
 }