Use slice representation for module entries in CrateMap

Relaxe lifetime of CrateMap as well.

2 files changed, 47 insertions, 87 deletions

diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index e9ee0709d01..499516bb4fd 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -8,10 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use cast::transmute;
+#[cfg(not(stage0))] use cast::transmute;
 use container::MutableSet;
 use hashmap::HashSet;
 use libc::c_char;
+use option::{Some, None};
+use vec::ImmutableVector;
 
 // Need to tell the linker on OS X to not barf on undefined symbols
 // and instead look them up at runtime, which we need to resolve
@@ -24,7 +26,7 @@ extern {}
 extern {
     #[weak_linkage]
     #[link_name = "_rust_crate_map_toplevel"]
-    static CRATE_MAP: CrateMap;
+    static CRATE_MAP: CrateMap<'static>;
 }
 
 pub struct ModEntry {
@@ -32,28 +34,28 @@ pub struct ModEntry {
     log_level: *mut u32
 }
 
-struct CrateMapV0 {
-    entries: &static [ModEntry],
-    children: &'static [&'static CrateMap]
+pub struct CrateMapV0<'self> {
+    entries: &'self [ModEntry],
+    children: &'self [&'self CrateMap<'self>]
 }
 
-struct CrateMap {
+pub struct CrateMap<'self> {
     version: i32,
-    entries: &static [ModEntry],
+    entries: &'self [ModEntry],
     /// a dynamically sized struct, where all pointers to children are listed adjacent
     /// to the struct, terminated with NULL
-    children: [*CrateMap, ..1]
+    children: &'self [&'self CrateMap<'self>]
 }
 
 #[cfg(not(windows))]
-pub fn get_crate_map() -> *CrateMap {
-    &'static CRATE_MAP as *CrateMap
+pub fn get_crate_map() -> &'static CrateMap<'static> {
+    &'static CRATE_MAP
 }
 
 #[cfg(windows)]
 #[fixed_stack_segment]
 #[inline(never)]
-pub fn get_crate_map() -> *CrateMap {
+pub fn get_crate_map() -> &'static CrateMap<'static> {
     use c_str::ToCStr;
     use unstable::dynamic_lib::dl;
 
@@ -65,11 +67,10 @@ pub fn get_crate_map() -> *CrateMap {
         dl::close(module);
         sym
     };
-
-    sym as *CrateMap
+    sym
 }
 
-fn version(crate_map: &'static CrateMap) -> i32 {
+fn version(crate_map: &CrateMap) -> i32 {
     match crate_map.version {
         1 => return 1,
         _ => return 0
@@ -77,12 +78,13 @@ fn version(crate_map: &'static CrateMap) -> i32 {
 }
 
 #[cfg(not(stage0))]
-fn entries(crate_map: &'static CrateMap) -> *ModEntry {
+fn get_entries_and_children<'a>(crate_map: &'a CrateMap<'a>) ->
+                    (&'a [ModEntry], &'a [&'a CrateMap<'a>]) {
     match version(crate_map) {
         0 => {
             unsafe {
-                let v0: &'static CrateMapV0 = transmute(crate_map);
-                return v0.entries;
+                let v0: &'a CrateMapV0<'a> = transmute(crate_map);
+                return (v0.entries, v0.children);
             }
         }
         1 => return (*crate_map).entries,
@@ -91,79 +93,43 @@ fn entries(crate_map: &'static CrateMap) -> *ModEntry {
 }
 
 #[cfg(not(stage0))]
-fn iterator(crate_map: &'static CrateMap) -> &'static [&'static CrateMap] {
-    match version(crate_map) {
-        0 => {
-            unsafe {
-                let v0: &'static CrateMapV0 = transmute(crate_map);
-                return v0.children;
-            }
-        }
-        1 => return vec::raw::to_ptr((*crate_map).children),
-        _ => fail2!("Unknown crate map version!")
-    }
-}
-
-fn iter_module_map(mod_entries: *ModEntry, f: &fn(&mut ModEntry)) {
-    let mut curr = mod_entries;
-
-    unsafe {
-        while !(*curr).name.is_null() {
-            f(transmute(curr));
-            curr = curr.offset(1);
-        }
+fn iter_module_map(mod_entries: &[ModEntry], f: &fn(&ModEntry)) {
+    for entry in mod_entries.iter() {
+        f(entry);
     }
 }
 
-
-
 #[cfg(not(stage0))]
-fn do_iter_crate_map(crate_map: &'static CrateMap, f: &fn(&mut ModEntry),
-                            visited: &mut HashSet<*CrateMap>) {
+fn do_iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: &fn(&ModEntry),
+                            visited: &mut HashSet<*CrateMap<'a>>) {
     if visited.insert(crate_map as *CrateMap) {
-        iter_module_map(crate_map.entries, |x| f(x));
-        let child_crates = iterator(crate_map);
-        
-        let mut i = 0;
-        while i < child_crates.len() {
-            do_iter_crate_map(child_crates[i], |x| f(x), visited);
-            i = i + 1;
+        let (entries, children) = get_entries_and_children(crate_map);
+        iter_module_map(entries, |x| f(x));
+        for child in children.iter() {
+            do_iter_crate_map(*child, |x| f(x), visited);
         }
     }
 }
 
 #[cfg(stage0)]
 /// Iterates recursively over `crate_map` and all child crate maps
-pub fn iter_crate_map(crate_map: *u8, f: &fn(&mut ModEntry)) {
+pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: &fn(&ModEntry)) {
 }
 
 #[cfg(not(stage0))]
 /// Iterates recursively over `crate_map` and all child crate maps
-pub fn iter_crate_map(crate_map: &'static CrateMap, f: &fn(&mut ModEntry)) {
+pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: &fn(&ModEntry)) {
     // XXX: use random numbers as keys from the OS-level RNG when there is a nice
     //        way to do this
-    let mut v: HashSet<*CrateMap> = HashSet::with_capacity_and_keys(0, 0, 32);
-    unsafe {
-        do_iter_crate_map(transmute(crate_map), f, &mut v);
-    }
+    let mut v: HashSet<*CrateMap<'a>> = HashSet::with_capacity_and_keys(0, 0, 32);
+    do_iter_crate_map(crate_map, f, &mut v);
 }
 
 #[cfg(test)]
 mod tests {
     use c_str::ToCStr;
     use cast::transmute;
-    use ptr;
-    use vec;
-
-    use rt::crate_map::{ModEntry, iter_crate_map};
-
-    struct CrateMap<'self> { 
-        version: i32,
-        entries: *ModEntry,
-        /// a dynamically sized struct, where all pointers to children are listed adjacent
-        /// to the struct, terminated with NULL
-        children: &'self [&'self CrateMap<'self>] 
-    }
+    use rt::crate_map::{CrateMap, ModEntry, iter_crate_map};
 
     #[test]
     fn iter_crate_map_duplicates() {
@@ -171,20 +137,19 @@ mod tests {
             let mod_name1 = "c::m1".to_c_str();
             let mut level3: u32 = 3;
 
-            let entries: ~[ModEntry] = ~[
+            let entries = [
                 ModEntry { name: mod_name1.with_ref(|buf| buf), log_level: &mut level3},
-                ModEntry { name: ptr::null(), log_level: ptr::mut_null()}
             ];
 
             let child_crate = CrateMap {
                 version: 1,
-                entries: vec::raw::to_ptr(entries),
+                entries: entries,
                 children: []
             };
 
             let root_crate = CrateMap {
                 version: 1,
-                entries: vec::raw::to_ptr([ModEntry { name: ptr::null(), log_level: ptr::mut_null()}]),
+                entries: [],
                 children: [&child_crate, &child_crate]
             };
 
@@ -206,29 +171,26 @@ mod tests {
             let mut level3: u32 = 3;
             let child_crate2 = CrateMap {
                 version: 1,
-                entries: vec::raw::to_ptr([
+                entries: [
                     ModEntry { name: mod_name1.with_ref(|buf| buf), log_level: &mut level2},
                     ModEntry { name: mod_name2.with_ref(|buf| buf), log_level: &mut level3},
-                    ModEntry { name: ptr::null(), log_level: ptr::mut_null()}
-                ]),
+                ],
                 children: []
             };
 
             let child_crate1 = CrateMap {
                 version: 1,
-                entries: vec::raw::to_ptr([
+                entries: [
                     ModEntry { name: "t::f1".to_c_str().with_ref(|buf| buf), log_level: &mut 1},
-                    ModEntry { name: ptr::null(), log_level: ptr::mut_null()}
-                ]),
+                ],
                 children: [&child_crate2]
             };
 
             let root_crate = CrateMap {
                 version: 1,
-                entries: vec::raw::to_ptr([
+                entries: [
                     ModEntry { name: "t::f1".to_c_str().with_ref(|buf| buf), log_level: &mut 0},
-                    ModEntry { name: ptr::null(), log_level: ptr::mut_null()}
-                ]),
+                ],
                 children: [&child_crate1]
             };
 
diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs
index 0903171f1c1..8d85f72056e 100644
--- a/src/libstd/rt/logging.rs
+++ b/src/libstd/rt/logging.rs
@@ -14,14 +14,12 @@ use libc::{uintptr_t, exit};
 use option::{Some, None, Option};
 use rt;
 use rt::util::dumb_println;
-use rt::crate_map::{ModEntry, iter_crate_map};
-use rt::crate_map::get_crate_map;
+use rt::crate_map::{ModEntry, CrateMap, iter_crate_map, get_crate_map};
 use str::StrSlice;
 use str::raw::from_c_str;
 use u32;
 use vec::ImmutableVector;
-use send_str::{SendStr, SendStrOwned, SendStrStatic};
-use cast::transmute;
+#[cfg(test)] use cast::transmute;
 
 struct LogDirective {
     name: Option<~str>,
@@ -111,7 +109,7 @@ fn parse_logging_spec(spec: ~str) -> ~[LogDirective]{
 
 /// Set the log level of an entry in the crate map depending on the vector
 /// of log directives
-fn update_entry(dirs: &[LogDirective], entry: &mut ModEntry) -> u32 {
+fn update_entry(dirs: &[LogDirective], entry: &ModEntry) -> u32 {
     let mut new_lvl: u32 = DEFAULT_LOG_LEVEL;
     let mut longest_match = -1i;
     unsafe {
@@ -142,7 +140,7 @@ fn update_entry(dirs: &[LogDirective], entry: &mut ModEntry) -> u32 {
 #[fixed_stack_segment] #[inline(never)]
 /// Set log level for every entry in crate_map according to the sepecification
 /// in settings
-fn update_log_settings(crate_map: *u8, settings: ~str) {
+fn update_log_settings(crate_map: &CrateMap, settings: ~str) {
     let mut dirs = ~[];
     if settings.len() > 0 {
         if settings == ~"::help" || settings == ~"?" {
@@ -206,7 +204,7 @@ impl rt::io::Writer for StdErrLogger {
 pub fn init() {
     use os;
 
-    let crate_map = get_crate_map() as *u8;
+    let crate_map = get_crate_map();
 
     let log_spec = os::getenv("RUST_LOG");
     match log_spec {