---

yaml
---
r: 29963
b: refs/heads/incoming
c: 6083409
h: refs/heads/master
i:
  29961: 2d3f582
  29959: 7c54d82
v: v3

Author: Daniel Patterson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 236f8330072aec35f875f029dc215769e5fc6b91
+refs/heads/incoming: 6083409f172c8bbea59cec4bac749c46057b4774
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/core.rc

@@ -55,7 +55,6 @@ export hash;
 export cmp;
 export num;
 export path;
-export managed;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -262,7 +261,6 @@ mod sys;
 #[warn(non_camel_case_types)]
 mod unsafe;
 
-mod managed;
 
 // Modules supporting compiler-generated code
 // Exported but not part of the public interface

branches/incoming/src/libcore/managed.rs

@@ -358,7 +358,7 @@ fn pipe() -> {in: c_int, out: c_int} {
 }
 
 fn dup2(src: c_int, dst: c_int) -> c_int {
-    libc::dup2(src, dst)
+	libc::dup2(src, dst)
 }
 
 
@@ -963,9 +963,6 @@ mod tests {
         setenv(~"USERPROFILE", ~"/home/MountainView");
         assert os::homedir() == some(~"/home/MountainView");
 
-        setenv(~"USERPROFILE", ~"/home/MountainView");
-        assert os::homedir() == some(~"/home/MountainView");
-
         setenv(~"HOME", ~"/home/MountainView");
         setenv(~"USERPROFILE", ~"/home/PaloAlto");
         assert os::homedir() == some(~"/home/MountainView");

branches/incoming/src/libcore/os.rs

@@ -58,6 +58,12 @@ mod linear {
             buckets: vec::from_fn(initial_capacity, |_i| none)})
     }
 
+    // FIXME(#2979) would allow us to use region type for k
+    unsafe fn borrow<K>(&&k: K) -> &K {
+        let p: *K = ptr::addr_of(k);
+        unsafe::reinterpret_cast(p)
+    }
+
     priv impl<K, V> &const LinearMap<K,V> {
         #[inline(always)]
         pure fn to_bucket(h: uint) -> uint {
@@ -149,7 +155,8 @@ mod linear {
         /// Assumes that there will be a bucket.
         /// True if there was no previous entry with that key
         fn insert_internal(hash: uint, +k: K, +v: V) -> bool {
-            match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
+            match self.bucket_for_key_with_hash(self.buckets, hash,
+                                              unsafe{borrow(k)}) {
               TableFull => {fail ~"Internal logic error";}
               FoundHole(idx) => {
                 debug!{"insert fresh (%?->%?) at idx %?, hash %?",
@@ -180,7 +187,7 @@ mod linear {
                 self.expand();
             }
 
-            let hash = self.hashfn(&k);
+            let hash = self.hashfn(unsafe{borrow(k)});
             self.insert_internal(hash, k, v)
         }
 
@@ -221,13 +228,6 @@ mod linear {
             self.size -= 1;
             return true;
         }
-
-        fn clear() {
-            for uint::range(0, self.buckets.len()) |idx| {
-                self.buckets[idx] = none;
-            }
-            self.size = 0;
-        }
     }
 
     priv impl<K,V> &LinearMap<K,V> {
@@ -279,19 +279,11 @@ mod linear {
 
     impl<K,V> &LinearMap<K,V> {
         /*
-        FIXME(#3148)--region inference fails to capture needed deps
-
-        fn find_ref(k: &K) -> option<&self/V> {
-            match self.bucket_for_key(self.buckets, k) {
-              FoundEntry(idx) => {
-                match check self.buckets[idx] {
-                  some(ref bkt) => some(&bkt.value)
-                }
-              }
-              TableFull | FoundHole(_) => {
-                none
-              }
-            }
+        FIXME --- #2979 must be fixed to typecheck this
+        fn find_ptr(k: K) -> option<&V> {
+            //XXX this should not type check as written, but it should
+            //be *possible* to typecheck it...
+            self.with_ptr(k, |v| v)
         }
         */
 

branches/incoming/src/libcore/send_map.rs

@@ -12,24 +12,6 @@ pure fn id<T>(+x: T) -> T { x }
 /// Ignores a value.
 pure fn ignore<T>(+_x: T) { }
 
-/// Sets `*ptr` to `new_value`, invokes `op()`, and then restores the
-/// original value of `*ptr`.
-#[inline(always)]
-fn with<T: copy, R>(
-    ptr: &mut T,
-    +new_value: T,
-    op: &fn() -> R) -> R
-{
-    // NDM: if swap operator were defined somewhat differently,
-    // we wouldn't need to copy...
-
-    let old_value = *ptr;
-    *ptr = move new_value;
-    let result = op();
-    *ptr = move old_value;
-    return move result;
-}
-
 /**
  * Swap the values at two mutable locations of the same type, without
  * deinitialising or copying either one.

branches/incoming/src/libcore/util.rs

@@ -4,9 +4,6 @@
 
 import io::WriterUtil;
 import to_str::ToStr;
-import managed::Managed;
-import send_map::linear::LinearMap;
-
 export hashmap, hashfn, eqfn, set, map, chained, hashmap, str_hash;
 export box_str_hash;
 export bytes_hash, int_hash, uint_hash, set_add;
@@ -62,10 +59,10 @@ trait map<K: copy, V: copy> {
     fn find(+key: K) -> option<V>;
 
     /**
-     * Remove and return a value from the map. Returns true if the
-     * key was present in the map, otherwise false.
+     * Remove and return a value from the map. If the key does not exist
+     * in the map then returns none.
      */
-    fn remove(+key: K) -> bool;
+    fn remove(+key: K) -> option<V>;
 
     /// Clear the map, removing all key/value pairs.
     fn clear();
@@ -282,18 +279,18 @@ mod chained {
             option::unwrap(opt_v)
         }
 
-        fn remove(+k: K) -> bool {
+        fn remove(+k: K) -> option<V> {
             match self.search_tbl(&k, self.hasher(&k)) {
-              not_found => false,
+              not_found => none,
               found_first(idx, entry) => {
                 self.count -= 1u;
                 self.chains[idx] = entry.next;
-                true
+                some(entry.value)
               }
               found_after(eprev, entry) => {
                 self.count -= 1u;
                 eprev.next = entry.next;
-                true
+                some(entry.value)
               }
             }
         }
@@ -471,93 +468,6 @@ fn hash_from_uints<V: copy>(items: &[(uint, V)]) -> hashmap<uint, V> {
     hash_from_vec(uint::hash, uint::eq, items)
 }
 
-// XXX Transitionary
-impl<K: copy, V: copy> Managed<LinearMap<K, V>>: map<K, V> {
-    fn size() -> uint {
-        do self.borrow_const |p| {
-            p.len()
-        }
-    }
-
-    fn insert(+key: K, +value: V) -> bool {
-        do self.borrow_mut |p| {
-            p.insert(key, value)
-        }
-    }
-
-    fn contains_key(+key: K) -> bool {
-        do self.borrow_const |p| {
-            p.contains_key(&key)
-        }
-    }
-
-    fn contains_key_ref(key: &K) -> bool {
-        do self.borrow_const |p| {
-            p.contains_key(key)
-        }
-    }
-
-    fn get(+key: K) -> V {
-        do self.borrow_const |p| {
-            p.get(&key)
-        }
-    }
-
-    fn find(+key: K) -> option<V> {
-        do self.borrow_const |p| {
-            p.find(&key)
-        }
-    }
-
-    fn remove(+key: K) -> bool {
-        do self.borrow_mut |p| {
-            p.remove(&key)
-        }
-    }
-
-    fn clear() {
-        do self.borrow_mut |p| {
-            p.clear()
-        }
-    }
-
-    fn each(op: fn(+key: K, +value: V) -> bool) {
-        do self.borrow_imm |p| {
-            p.each(op)
-        }
-    }
-
-    fn each_key(op: fn(+key: K) -> bool) {
-        do self.borrow_imm |p| {
-            p.each_key(op)
-        }
-    }
-
-    fn each_value(op: fn(+value: V) -> bool) {
-        do self.borrow_imm |p| {
-            p.each_value(op)
-        }
-    }
-
-    fn each_ref(op: fn(key: &K, value: &V) -> bool) {
-        do self.borrow_imm |p| {
-            p.each_ref(op)
-        }
-    }
-
-    fn each_key_ref(op: fn(key: &K) -> bool) {
-        do self.borrow_imm |p| {
-            p.each_key_ref(op)
-        }
-    }
-
-    fn each_value_ref(op: fn(value: &V) -> bool) {
-        do self.borrow_imm |p| {
-            p.each_value_ref(op)
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
 

branches/incoming/src/libstd/map.rs

@@ -80,13 +80,13 @@ impl<V: copy> smallintmap<V>: map::map<uint, V> {
         insert(self, key, value);
         return !exists;
     }
-    fn remove(+key: uint) -> bool {
+    fn remove(+key: uint) -> option<V> {
         if key >= self.v.len() {
-            return false;
+            return none;
         }
         let old = self.v.get_elt(key);
         self.v.set_elt(key, none);
-        old.is_some()
+        old
     }
     fn clear() {
         self.v.set(~[mut]);