Correct typos and improve docs based on requested changes

src/boot_loader_name.rs

@@ -19,7 +19,7 @@ impl BootLoaderNameTag {
     /// ```ignore
     /// if let Some(tag) = boot_info.boot_loader_name_tag() {
     ///     let name = tag.name();
-    ///     // println!("Booted by: {:?}!", name);
+    ///     assert_eq!("GRUB 2.02~beta3-5", name);
     /// }
     /// ```
     pub fn name(&self) -> &str {

src/command_line.rs

@@ -18,7 +18,7 @@ impl CommandLineTag {
     /// ```ignore
     /// if let Some(tag) = boot_info.command_line_tag() {
     ///     let command_line = tag.command_line();
-    ///     // println!("Command line: {:?}!", command_line);
+    ///     assert_eq!("/bootarg", command_line);
     /// }
     /// ```
     pub fn command_line(&self) -> &str {

src/elf_sections.rs

@@ -64,7 +64,7 @@ impl ElfSectionsTag {
     }
 }
 
-/// An iterator over some elf sections.
+/// An iterator over some ELF sections.
 #[derive(Clone, Debug)]
 pub struct ElfSectionIter {
     current_section: *const u8,
@@ -163,7 +163,7 @@ impl ElfSection {
         self.get().typ()
     }
 
-    /// Read the name of the section from the string table and an offset.
+    /// Read the name of the section.
     pub fn name(&self) -> &str {
         use core::{str, slice};
 
@@ -193,12 +193,12 @@ impl ElfSection {
         self.get().addr() + self.get().size()
     }
 
-    /// This member gives the section's size in bytes.
+    /// Get the section's size in bytes.
     pub fn size(&self) -> u64 {
         self.get().size()
     }
 
-    /// Get the sections address alignment constraints.
+    /// Get the section's address alignment constraints.
     ///
     /// That is, the value of `start_address` must be congruent to 0,
     /// modulo the value of `addrlign`. Currently, only 0 and positive
@@ -208,7 +208,7 @@ impl ElfSection {
         self.get().addralign()
     }
 
-    /// Get the sections flags.
+    /// Get the section's flags.
     pub fn flags(&self) -> ElfSectionFlags {
         ElfSectionFlags::from_bits_truncate(self.get().flags())
     }
@@ -315,7 +315,7 @@ pub enum ElfSectionType {
     /// meaning are determined solely by the program.
     ProgramSection = 1,
 
-    /// This section holds a symbol table.
+    /// This section holds a linker symbol table.
     LinkerSymbolTable = 2,
 
     /// The section holds a string table.
@@ -329,14 +329,14 @@ pub enum ElfSectionType {
     /// The section holds a symbol hash table.
     SymbolHashTable = 5,
 
-    /// The section holds information for dynamic linking.
+    /// The section holds dynamic linking tables.
     DynamicLinkingTable = 6,
 
     /// This section holds information that marks the file in some way.
     Note = 7,
 
     /// A section of this type occupies no space in the file but otherwise resembles
-    /// SHT_PROGBITS. Although this section contains no bytes, the
+    /// `ProgramSection`. Although this section contains no bytes, the
     /// sh_offset member contains the conceptual file offset.
     Uninitialized = 8,
 
@@ -348,13 +348,15 @@ pub enum ElfSectionType {
     /// This section type is reserved but has unspecified semantics.
     Reserved = 10,
 
-    /// This section holds a symbol table.
+    /// This section holds a dynamic loader symbol table.
     DynamicLoaderSymbolTable = 11,
 
-    /// Values in this inclusive range are reserved for environment-specific semantics.
+    /// Values in this inclusive range (`[0x6000_0000, 0x6FFF_FFFF)`) are
+    /// reserved for environment-specific semantics.
     EnvironmentSpecific = 0x6000_0000,
 
-    /// Values in this inclusive range are reserved for processor-specific semantics.
+    /// Values in this inclusive range (`[0x7000_0000, 0x7FFF_FFFF)`) are
+    /// reserved for processor-specific semantics.
     ProcessorSpecific = 0x7000_0000,
 }
 

src/framebuffer.rs

@@ -1,6 +1,6 @@
-use header::Tag;
 use ::Reader;
 use core::slice;
+use header::Tag;
 
 /// The VBE Framebuffer information Tag.
 #[derive(Debug, PartialEq)]
@@ -15,17 +15,17 @@ pub struct FramebufferTag<'a> {
     /// Contains the pitch in bytes.
     pub pitch: u32,
 
-    /// Contain framebuffer width in pixels.
+    /// Contains framebuffer width in pixels.
     pub width: u32,
 
-    /// Contain framebuffer height in pixels.
+    /// Contains framebuffer height in pixels.
     pub height: u32,
 
     /// Contains number of bits per pixel.
     pub bpp: u8,
 
-    /// The type of framebuffer, one of: Indexed, RGB or Text.
-    pub buffer_type: FramebufferType<'a>
+    /// The type of framebuffer, one of: `Indexed`, `RGB` or `Text`.
+    pub buffer_type: FramebufferType<'a>,
 }
 
 /// The type of framebuffer.
@@ -34,7 +34,7 @@ pub enum FramebufferType<'a> {
     /// Indexed color.
     Indexed {
         #[allow(missing_docs)]
-        palette: &'a [FramebufferColor]
+        palette: &'a [FramebufferColor],
     },
 
     /// Direct RGB color.
@@ -42,7 +42,7 @@ pub enum FramebufferType<'a> {
     RGB {
         red: FramebufferField,
         green: FramebufferField,
-        blue: FramebufferField
+        blue: FramebufferField,
     },
 
     /// EGA Text.
@@ -51,7 +51,7 @@ pub enum FramebufferType<'a> {
     /// characters and not in pixels.
     ///
     /// The bpp is equal 16 (16 bits per character) and pitch is expressed in bytes per text line.
-    Text
+    Text,
 }
 
 /// An RGB color type field.
@@ -61,21 +61,21 @@ pub struct FramebufferField {
     pub position: u8,
 
     /// Color mask size.
-    pub size: u8
+    pub size: u8,
 }
 
 /// A framebuffer color descriptor in the palette.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[repr(C, packed)]
 pub struct FramebufferColor {
-    /// The amount of Red.
+    /// The Red component of the color.
     pub red: u8,
 
-    /// The amount of Green.
+    /// The Green component of the color.
     pub green: u8,
 
-    /// The amount of Blue.
-    pub blue: u8
+    /// The Blue component of the color.
+    pub blue: u8,
 }
 
 pub fn framebuffer_tag<'a>(tag: &'a Tag) -> FramebufferTag<'a> {
@@ -90,28 +90,40 @@ pub fn framebuffer_tag<'a>(tag: &'a Tag) -> FramebufferTag<'a> {
     reader.skip(2); // In the multiboot spec, it has this listed as a u8 _NOT_ a u16.
                     // Reading the GRUB2 source code reveals it is in fact a u16.
     let buffer_type = match type_no {
-        0 =>  {
+        0 => {
             let num_colors = reader.read_u32();
             let palette = unsafe {
-                slice::from_raw_parts(reader.current_address() as *const FramebufferColor, num_colors as usize)
+                slice::from_raw_parts(
+                    reader.current_address() as *const FramebufferColor,
+                    num_colors as usize,
+                )
             } as &'static [FramebufferColor];
             FramebufferType::Indexed { palette }
-        },
+        }
         1 => {
-            let red_pos = reader.read_u8();     // These refer to the bit positions of the LSB of each field
-            let red_mask = reader.read_u8();    // And then the length of the field from LSB to MSB
-            let green_pos = reader.read_u8();   
-            let green_mask = reader.read_u8();  
+            let red_pos = reader.read_u8(); // These refer to the bit positions of the LSB of each field
+            let red_mask = reader.read_u8(); // And then the length of the field from LSB to MSB
+            let green_pos = reader.read_u8();
+            let green_mask = reader.read_u8();
             let blue_pos = reader.read_u8();
             let blue_mask = reader.read_u8();
             FramebufferType::RGB {
-                red: FramebufferField { position: red_pos, size: red_mask },
-                green: FramebufferField { position: green_pos, size: green_mask },
-                blue: FramebufferField { position: blue_pos, size: blue_mask }
+                red: FramebufferField {
+                    position: red_pos,
+                    size: red_mask,
+                },
+                green: FramebufferField {
+                    position: green_pos,
+                    size: green_mask,
+                },
+                blue: FramebufferField {
+                    position: blue_pos,
+                    size: blue_mask,
+                },
             }
-        },
+        }
         2 => FramebufferType::Text,
-        _ => panic!("Unknown framebuffer type: {}", type_no)
+        _ => panic!("Unknown framebuffer type: {}", type_no),
     };
 
     FramebufferTag {
@@ -120,6 +132,6 @@ pub fn framebuffer_tag<'a>(tag: &'a Tag) -> FramebufferTag<'a> {
         width,
         height,
         bpp,
-        buffer_type
+        buffer_type,
     }
 }

src/memory_map.rs

@@ -8,8 +8,8 @@ use core::marker::PhantomData;
 /// overwrite these regions.
 ///
 /// This tag may not be provided by some boot loaders on EFI platforms if EFI
-/// boot services are enabled and available for the loaded image
-/// (EFI boot services not terminated tag exists in Multiboot2 information structure).   
+/// boot services are enabled and available for the loaded image (The EFI boot
+/// services tag may exist in the Multiboot2 boot information structure).
 #[derive(Debug)]
 #[repr(C)]
 pub struct MemoryMapTag {
@@ -91,7 +91,7 @@ pub enum MemoryAreaType {
     Defective,
 }
 
-/// An area over Available memory areas.
+/// An iterator over Available memory areas.
 #[derive(Clone, Debug)]
 pub struct MemoryAreaIter<'a> {
     current_area: u64,

src/rsdp.rs

@@ -24,7 +24,7 @@ pub struct RsdpV1Tag {
 impl RsdpV1Tag {
     /// The "RSD PTR " marker singature.
     ///
-    /// This is originally a 8-byte C string (not null terminated!) must contain "RSD PTR ".
+    /// This is originally a 8-byte C string (not null terminated!) that must contain "RSD PTR "
     pub fn signature<'a>(&'a self) -> Option<&'a str> {
         str::from_utf8(&self.signature).ok()
     }
@@ -46,7 +46,7 @@ impl RsdpV1Tag {
         self.revision
     }
 
-    /// 32-bit physical (I repeat: physical) address of the RSDT table.
+    /// The physical (I repeat: physical) address of the RSDT table.
     pub fn rsdt_address(&self) -> usize {
         self.rsdt_address as usize
     }
@@ -72,7 +72,7 @@ pub struct RsdpV2Tag {
 impl RsdpV2Tag {
     /// The "RSD PTR " marker singature.
     ///
-    /// This is originally a 8-byte C string (not null terminated!) must contain "RSD PTR ".
+    /// This is originally a 8-byte C string (not null terminated!) that must contain "RSD PTR ".
     pub fn signature<'a>(&'a self) -> Option<&'a str> {
         str::from_utf8(&self.signature).ok()
     }

src/vbe_info.rs

@@ -12,12 +12,21 @@ pub struct VBEInfoTag {
     pub mode: u16,
 
     /// Contain the segment of the table of a protected mode interface defined in VBE 2.0+.
+    ///
+    /// If the information for a protected mode interface is not available
+    /// this field is set to zero.
     pub interface_segment: u16,
 
     /// Contain the segment offset of the table of a protected mode interface defined in VBE 2.0+.
+    ///
+    /// If the information for a protected mode interface is not available
+    /// this field is set to zero.
     pub interface_offset: u16,
 
     /// Contain the segment length of the table of a protected mode interface defined in VBE 2.0+.
+    ///
+    /// If the information for a protected mode interface is not available
+    /// this field is set to zero.
     pub interface_length: u16,
 
     /// Contains VBE controller information returned by the VBE Function `00h`.
@@ -234,13 +243,15 @@ bitflags! {
     /// The Capabilities field indicates the support of specific features in the graphics environment.
     pub struct VBECapabilities: u32 {
         /// Can the DAC be switched between 6 and 8 bit modes.
-        const SWITCHABLE_DAC = 0x1;     // The DAC can be switched between 6 and 8-bit modes.
+        const SWITCHABLE_DAC = 0x1;
 
         /// Is the controller VGA compatible.
-        const NOT_VGA_COMPATIBLE = 0x2; // The controller can be switched into VGA modes.
+        const NOT_VGA_COMPATIBLE = 0x2;
 
-        /// The operating behaviour of the RAMDAC
-        const RAMDAC_FIX = 0x4;         // When writing lots of information to the palette, the blank bit should be used.
+        /// The operating behaviour of the RAMDAC.
+        ///
+        /// When writing lots of information to the RAMDAC, use the blank bit in Function `09h`.
+        const RAMDAC_FIX = 0x4;
     }
 }
 
@@ -248,10 +259,10 @@ bitflags! {
     /// A Mode attributes bitfield.
     pub struct VBEModeAttributes: u16 {
         /// Mode supported by hardware configuration.
-        const SUPPORTED = 0x1;           // This mode is supported by the hardware.
+        const SUPPORTED = 0x1;
 
         /// TTY Output functions supported by BIOS
-        const TTY_SUPPORTED = 0x4;       // TTY output is supported.
+        const TTY_SUPPORTED = 0x4;
 
         /// Color support.
         const COLOR = 0x8;
@@ -267,7 +278,7 @@ bitflags! {
         /// If this is set, the window A and B fields of VBEModeInfo are invalid. 
         const NO_VGA_WINDOW = 0x40;
 
-        /// Linear framebugger availability.
+        /// Linear framebuffer availability.
         ///
         /// Set if a linear framebuffer is available for this mode.
         const LINEAR_FRAMEBUFFER = 0x80;
@@ -296,15 +307,15 @@ bitflags! {
     /// Bit D0 specifies whether the color ramp of the DAC is fixed or
     /// programmable. If the color ramp is fixed, then it can not be changed.
     /// If the color ramp is programmable, it is assumed that the red, green,
-    /// and blue lookup tables can be loaded by using VBE Function 09h
+    /// and blue lookup tables can be loaded by using VBE Function `09h`
     /// (it is assumed all color ramp data is 8 bits per primary).
     /// Bit D1 specifies whether the bits in the Rsvd field of the direct color
     /// pixel can be used by the application or are reserved, and thus unusable.
     pub struct VBEDirectColorAttributes: u8 {
-        /// Color ramp is fixed/programmable
+        /// Color ramp is fixed when cleared and programmable when set.
         const PROGRAMMABLE = 0x1;
 
-        /// Bits in Rsvd field are usable/reserved
+        /// Bits in Rsvd field when cleared are reserved and usable when set.
         const RESERVED_USABLE = 0x2;
     }
 }