---

yaml
---
r: 23364
b: refs/heads/master
c: 7fe1005
h: refs/heads/master
v: v3

Author: bblum

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6083409f172c8bbea59cec4bac749c46057b4774
+refs/heads/master: 7fe1005fd124fe79f4a4ea17d0056e55ff7bd3ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/core.rc

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

trunk/src/libcore/managed.rs

@@ -0,0 +1,62 @@
+/*!
+
+Module for wrapping freezable data structures in managed boxes.
+Normally freezable data structures require an unaliased reference,
+such as `T` or `~T`, so that the compiler can track when they are
+being mutated.  The `rw<T>` type converts these static checks into
+dynamic checks: your program will fail if you attempt to perform
+mutation when the data structure should be immutable.
+
+*/
+
+#[forbid(non_camel_case_types)];
+#[forbid(deprecated_mode)];
+#[forbid(deprecated_pattern)];
+
+import util::with;
+import unsafe::transmute_immut;
+
+export Managed;
+
+enum Mode { ReadOnly, Mutable, Immutable }
+
+struct Data<T> {
+    mut value: T;
+    mut mode: Mode;
+}
+
+type Managed<T> = @Data<T>;
+
+fn Managed<T>(+t: T) -> Managed<T> {
+    @Data {value: t, mode: ReadOnly}
+}
+
+impl<T> Data<T> {
+    fn borrow_mut<R>(op: &fn(t: &mut T) -> R) -> R {
+        match self.mode {
+          Immutable => fail fmt!("%? currently immutable",
+                                 self.value),
+          ReadOnly | Mutable => {}
+        }
+
+        do with(&mut self.mode, Mutable) {
+            op(&mut self.value)
+        }
+    }
+
+    fn borrow_const<R>(op: &fn(t: &const T) -> R) -> R {
+        op(&const self.value)
+    }
+
+    fn borrow_imm<R>(op: &fn(t: &T) -> R) -> R {
+        match self.mode {
+          Mutable => fail fmt!("%? currently mutable",
+                               self.value),
+          ReadOnly | Immutable => {}
+        }
+
+        do with(&mut self.mode, Immutable) {
+            op(unsafe{transmute_immut(&mut self.value)})
+        }
+    }
+}

trunk/src/libcore/os.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,6 +963,9 @@ 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");

trunk/src/libcore/send_map.rs

@@ -58,12 +58,6 @@ 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 {
@@ -155,8 +149,7 @@ 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,
-                                              unsafe{borrow(k)}) {
+            match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
               TableFull => {fail ~"Internal logic error";}
               FoundHole(idx) => {
                 debug!{"insert fresh (%?->%?) at idx %?, hash %?",
@@ -187,7 +180,7 @@ mod linear {
                 self.expand();
             }
 
-            let hash = self.hashfn(unsafe{borrow(k)});
+            let hash = self.hashfn(&k);
             self.insert_internal(hash, k, v)
         }
 
@@ -228,6 +221,13 @@ 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,11 +279,19 @@ mod linear {
 
     impl<K,V> &LinearMap<K,V> {
         /*
-        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)
+        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
+              }
+            }
         }
         */
 

trunk/src/libcore/util.rs

@@ -12,6 +12,24 @@ 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.

trunk/src/libstd/map.rs

@@ -4,6 +4,9 @@
 
 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;
@@ -59,10 +62,10 @@ trait map<K: copy, V: copy> {
     fn find(+key: K) -> option<V>;
 
     /**
-     * Remove and return a value from the map. If the key does not exist
-     * in the map then returns none.
+     * Remove and return a value from the map. Returns true if the
+     * key was present in the map, otherwise false.
      */
-    fn remove(+key: K) -> option<V>;
+    fn remove(+key: K) -> bool;
 
     /// Clear the map, removing all key/value pairs.
     fn clear();
@@ -279,18 +282,18 @@ mod chained {
             option::unwrap(opt_v)
         }
 
-        fn remove(+k: K) -> option<V> {
+        fn remove(+k: K) -> bool {
             match self.search_tbl(&k, self.hasher(&k)) {
-              not_found => none,
+              not_found => false,
               found_first(idx, entry) => {
                 self.count -= 1u;
                 self.chains[idx] = entry.next;
-                some(entry.value)
+                true
               }
               found_after(eprev, entry) => {
                 self.count -= 1u;
                 eprev.next = entry.next;
-                some(entry.value)
+                true
               }
             }
         }
@@ -468,6 +471,93 @@ 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 {
 

trunk/src/libstd/smallintmap.rs

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