Merge pull request #79 from phil-opp/rustfmt

Run rustfmt

src/lib.rs

@@ -28,7 +28,7 @@ mod vga_buffer;
 mod memory;
 
 #[no_mangle]
-pub extern fn rust_main(multiboot_information_address: usize) {
+pub extern "C" fn rust_main(multiboot_information_address: usize) {
     // ATTENTION: we have a very small stack and no guard page
     vga_buffer::clear_screen();
     println!("Hello World{}", "!");
@@ -39,13 +39,17 @@ pub extern fn rust_main(multiboot_information_address: usize) {
 
     println!("memory areas:");
     for area in memory_map_tag.memory_areas() {
-        println!("    start: 0x{:x}, length: 0x{:x}", area.base_addr, area.length);
+        println!("    start: 0x{:x}, length: 0x{:x}",
+                 area.base_addr,
+                 area.length);
     }
 
     println!("kernel sections:");
     for section in elf_sections_tag.sections() {
         println!("    addr: 0x{:x}, size: 0x{:x}, flags: 0x{:x}",
-            section.addr, section.size, section.flags);
+                 section.addr,
+                 section.size,
+                 section.flags);
     }
 
     let kernel_start = elf_sections_tag.sections().map(|s| s.addr).min().unwrap();
@@ -54,11 +58,18 @@ pub extern fn rust_main(multiboot_information_address: usize) {
     let multiboot_start = multiboot_information_address;
     let multiboot_end = multiboot_start + (boot_info.total_size as usize);
 
-    println!("kernel start: 0x{:x}, kernel end: 0x{:x}", kernel_start, kernel_end);
+    println!("kernel start: 0x{:x}, kernel end: 0x{:x}",
-    println!("multiboot start: 0x{:x}, multiboot end: 0x{:x}", multiboot_start, multiboot_end);
+             kernel_start,
+             kernel_end);
+    println!("multiboot start: 0x{:x}, multiboot end: 0x{:x}",
+             multiboot_start,
+             multiboot_end);
 
     let mut frame_allocator = memory::AreaFrameAllocator::new(kernel_start as usize,
-        kernel_end as usize, multiboot_start, multiboot_end, memory_map_tag.memory_areas());
+                                                              kernel_end as usize,
+                                                              multiboot_start,
+                                                              multiboot_end,
+                                                              memory_map_tag.memory_areas());
 
     memory::test_paging(&mut frame_allocator);
 
@@ -67,11 +78,11 @@ pub extern fn rust_main(multiboot_information_address: usize) {
 
 #[cfg(not(test))]
 #[lang = "eh_personality"]
-extern fn eh_personality() {}
+extern "C" fn eh_personality() {}
 
 #[cfg(not(test))]
 #[lang = "panic_fmt"]
-extern fn panic_fmt(fmt: core::fmt::Arguments, file: &str, line: u32) -> ! {
+extern "C" fn panic_fmt(fmt: core::fmt::Arguments, file: &str, line: u32) -> ! {
     println!("\n\nPANIC in {} at line {}:", file, line);
     println!("    {}", fmt);
     loop {}

src/memory/area_frame_allocator.rs

@@ -17,9 +17,12 @@ pub struct AreaFrameAllocator {
 }
 
 impl AreaFrameAllocator {
-    pub fn new(kernel_start: usize, kernel_end: usize, multiboot_start: usize, multiboot_end: usize,
+    pub fn new(kernel_start: usize,
-        memory_areas: MemoryAreaIter) -> AreaFrameAllocator
+               kernel_end: usize,
-    {
+               multiboot_start: usize,
+               multiboot_end: usize,
+               memory_areas: MemoryAreaIter)
+               -> AreaFrameAllocator {
         let mut allocator = AreaFrameAllocator {
             next_free_frame: Frame::containing_address(0),
             current_area: None,
@@ -34,10 +37,14 @@ impl AreaFrameAllocator {
     }
 
     fn choose_next_area(&mut self) {
-        self.current_area = self.areas.clone().filter(|area| {
+        self.current_area = self.areas
+                                .clone()
+                                .filter(|area| {
                                     let address = area.base_addr + area.length - 1;
-            Frame::containing_address(address as usize) >= self.next_free_frame
+                                    Frame::containing_address(address as usize) >=
-        }).min_by_key(|area| area.base_addr);
+                                    self.next_free_frame
+                                })
+                                .min_by_key(|area| area.base_addr);
 
         if let Some(area) = self.current_area {
             let start_frame = Frame::containing_address(area.base_addr as usize);
@@ -82,5 +89,7 @@ impl FrameAllocator for AreaFrameAllocator {
         }
     }
 
-    fn deallocate_frame(&mut self, _frame: Frame) {unimplemented!()}
+    fn deallocate_frame(&mut self, _frame: Frame) {
+        unimplemented!()
+    }
 }

src/memory/paging/mod.rs

@@ -170,9 +170,8 @@ pub fn test_paging<A>(allocator: &mut A)
     println!("next free frame: {:?}", allocator.allocate_frame());
 
     // test unmap
-    println!("{:#x}", unsafe {
+    println!("{:#x}",
-        *(Page::containing_address(addr).start_address() as *const u64)
+             unsafe { *(Page::containing_address(addr).start_address() as *const u64) });
-    });
     page_table.unmap(Page::containing_address(addr), allocator);
     println!("None = {:?}", page_table.translate(addr));
 }