Use more explicit lifetimes (TagIter)

Not all changes were needed to make rustc accept the code, because the
unsafe pointer dereferences hide the lifetime-dependencies from rustc. I
made these dependencies explicit in the function signatures in lib.rs.

src/header.rs

@@ -1,3 +1,5 @@
+use core::marker::PhantomData;
+
 #[derive(Clone, Copy, Debug)]
 #[repr(C)]
 pub struct Tag {
@@ -7,14 +9,24 @@ pub struct Tag {
 }
 
 #[derive(Clone, Debug)]
-pub struct TagIter {
+pub struct TagIter<'a> {
     pub current: *const Tag,
+    phantom: PhantomData<&'a Tag>,
+}
+
+impl<'a> TagIter<'a> {
+    pub fn new(first: *const Tag) -> Self {
+        TagIter {
+            current: first,
+            phantom: PhantomData,
+        }
+    }
 }
 
-impl Iterator for TagIter {
-    type Item = &'static Tag;
+impl<'a> Iterator for TagIter<'a> {
+    type Item = &'a Tag;
 
-    fn next(&mut self) -> Option<&'static Tag> {
+    fn next(&mut self) -> Option<&'a Tag> {
         match unsafe{&*self.current} {
             &Tag{typ:0, size:8} => None, // end tag
             tag => {

src/lib.rs

@@ -74,7 +74,7 @@ impl BootInformation {
         })
     }
 
-    pub fn memory_map_tag(&self) -> Option<&'static MemoryMapTag> {
+    pub fn memory_map_tag<'a>(&'a self) -> Option<&'a MemoryMapTag> {
         self.get_tag(6).map(|tag| unsafe { &*(tag as *const Tag as *const MemoryMapTag) })
     }
 
@@ -82,23 +82,23 @@ impl BootInformation {
         module::module_iter(self.tags())
     }
 
-    pub fn boot_loader_name_tag(&self) -> Option<&'static BootLoaderNameTag> {
+    pub fn boot_loader_name_tag<'a>(&'a self) -> Option<&'a BootLoaderNameTag> {
         self.get_tag(2).map(|tag| unsafe { &*(tag as *const Tag as *const BootLoaderNameTag) })
     }
 
-    pub fn command_line_tag(&self) -> Option<&'static CommandLineTag> {
+    pub fn command_line_tag<'a>(&'a self) -> Option<&'a CommandLineTag> {
         self.get_tag(1).map(|tag| unsafe { &*(tag as *const Tag as *const CommandLineTag) })
     }
 
-    pub fn framebuffer_tag(&self) -> Option<FramebufferTag<'static>> {
+    pub fn framebuffer_tag<'a>(&'a self) -> Option<FramebufferTag<'a>> {
         self.get_tag(8).map(|tag| framebuffer::framebuffer_tag(tag))
     }
 
-    pub fn rsdp_v1_tag(&self) -> Option<&'static RsdpV1Tag> {
+    pub fn rsdp_v1_tag<'a>(&self) -> Option<&'a RsdpV1Tag> {
         self.get_tag(14).map(|tag| unsafe { &*(tag as *const Tag as *const RsdpV1Tag) })
     }
 
-    pub fn rsdp_v2_tag(&self) -> Option<&'static RsdpV2Tag> {
+    pub fn rsdp_v2_tag<'a>(&'a self) -> Option<&'a RsdpV2Tag> {
         self.get_tag(15).map(|tag| unsafe { &*(tag as *const Tag as *const RsdpV2Tag) })
     }
 
@@ -106,12 +106,12 @@ impl BootInformation {
         unsafe { &*self.inner }
     }
 
-    fn get_tag(&self, typ: u32) -> Option<&'static Tag> {
+    fn get_tag<'a>(&'a self, typ: u32) -> Option<&'a Tag> {
         self.tags().find(|tag| tag.typ == typ)
     }
 
     fn tags(&self) -> TagIter {
-        TagIter { current: unsafe { self.inner.offset(1) } as *const _ }
+        TagIter::new(unsafe { self.inner.offset(1) } as *const _)
     }
 }
 

src/module.rs

@@ -37,14 +37,14 @@ pub fn module_iter(iter: TagIter) -> ModuleIter {
 }
 
 #[derive(Clone, Debug)]
-pub struct ModuleIter {
-    iter: TagIter,
+pub struct ModuleIter<'a> {
+    iter: TagIter<'a>,
 }
 
-impl Iterator for ModuleIter {
-    type Item = &'static ModuleTag;
+impl<'a> Iterator for ModuleIter<'a> {
+    type Item = &'a ModuleTag;
 
-    fn next(&mut self) -> Option<&'static ModuleTag> {
+    fn next(&mut self) -> Option<&'a ModuleTag> {
         self.iter.find(|x| x.typ == 3)
             .map(|tag| unsafe{&*(tag as *const Tag as *const ModuleTag)})
     }