---

yaml
---
r: 139056
b: refs/heads/try2
c: 321a54d
h: refs/heads/master
v: v3

Author: boggle

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f54adca7c984c75334d9cb73ec85bf3b5c326ed9
+refs/heads/try2: 321a54d26f1851f64feab6dba19b7af2e9e7c75f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/cleanup.rs

@@ -145,7 +145,11 @@ unsafe fn each_live_alloc(f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
 
 #[cfg(unix)]
 fn debug_mem() -> bool {
-    ::rt::env::get().debug_mem
+    use os;
+    use libc;
+    do os::as_c_charp("RUST_DEBUG_MEM") |p| {
+        unsafe { libc::getenv(p) != null() }
+    }
 }
 
 #[cfg(windows)]

branches/try2/src/libcore/clone.rs

@@ -20,11 +20,6 @@ impl Clone for () {
     fn clone(&self) -> () { () }
 }
 
-impl<T:Clone> Clone for ~T {
-    #[inline(always)]
-    fn clone(&self) -> ~T { ~(**self).clone() }
-}
-
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {

branches/try2/src/libcore/rt/env.rs

@@ -45,4 +45,3 @@ mod work_queue;
 mod stack;
 mod context;
 mod thread;
-pub mod env;

branches/try2/src/libcore/rt/mod.rs

@@ -20,7 +20,6 @@
 use at_vec;
 use cast;
 use char;
-use clone::Clone;
 use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
@@ -2437,13 +2436,6 @@ impl OwnedStr for ~str {
     }
 }
 
-impl Clone for ~str {
-    #[inline(always)]
-    fn clone(&self) -> ~str {
-        self.to_str()  // hilarious
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use char;

branches/try2/src/libcore/str.rs

@@ -137,7 +137,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
 }
 
 impl<T> TrieMap<T> {
-    /// Create an empty TrieMap
     #[inline(always)]
     static pure fn new() -> TrieMap<T> {
         TrieMap{root: TrieNode::new(), length: 0}
@@ -192,12 +191,6 @@ impl Mutable for TrieSet {
 }
 
 impl TrieSet {
-    /// Create an empty TrieSet
-    #[inline(always)]
-    static pure fn new() -> TrieSet {
-        TrieSet{map: TrieMap::new()}
-    }
-
     /// Return true if the set contains a value
     #[inline(always)]
     pure fn contains(&self, value: &uint) -> bool {
@@ -272,8 +265,8 @@ impl<T> TrieNode<T> {
 // if this was done via a trait, the key could be generic
 #[inline(always)]
 pure fn chunk(n: uint, idx: uint) -> uint {
-    let sh = uint::bits - (SHIFT * (idx + 1));
-    (n >> sh) & MASK
+    let real_idx = uint::bytes - 1 - idx;
+    (n >> (SHIFT * real_idx)) & MASK
 }
 
 fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
@@ -469,26 +462,4 @@ mod tests {
             n -= 1;
         }
     }
-
-    #[test]
-    fn test_sane_chunk() {
-        let x = 1;
-        let y = 1 << (uint::bits - 1);
-
-        let mut trie = TrieSet::new();
-
-        fail_unless!(trie.insert(x));
-        fail_unless!(trie.insert(y));
-
-        fail_unless!(trie.len() == 2);
-
-        let expected = [x, y];
-
-        let mut i = 0;
-
-        for trie.each |x| {
-            fail_unless!(expected[i] == *x);
-            i += 1;
-        }
-    }
 }

branches/try2/src/libcore/trie.rs

@@ -68,11 +68,11 @@ unsafe fn global_data_clone_create_<T:Owned + Clone>(
         match value {
             None => {
                 let value = create();
-                clone_value = Some((*value).clone());
+                clone_value = Some(value.clone());
                 Some(value)
             }
             Some(value) => {
-                clone_value = Some((*value).clone());
+                clone_value = Some(value.clone());
                 Some(value)
             }
         }
@@ -193,7 +193,7 @@ fn get_global_state() -> Exclusive<GlobalState> {
             // Successfully installed the global pointer
 
             // Take a handle to return
-            let clone = (*state).clone();
+            let clone = state.clone();
 
             // Install a runtime exit function to destroy the global object
             do at_exit {

branches/try2/src/libcore/unstable/global.rs

@@ -15,7 +15,6 @@
 use container::{Container, Mutable};
 use cast;
 use cmp::{Eq, Equiv, Ord, TotalOrd, Ordering, Less, Equal, Greater};
-use clone::Clone;
 use iter::BaseIter;
 use iter;
 use kinds::Copy;
@@ -2502,18 +2501,6 @@ impl<A:Copy> iter::CopyableNonstrictIter<A> for @[A] {
     }
 }
 
-impl<A:Clone> Clone for ~[A] {
-    #[inline]
-    fn clone(&self) -> ~[A] {
-        let mut dolly = ~[];
-        vec::reserve(&mut dolly, self.len());
-        for self.each |item| {
-            dolly.push(item.clone());
-        }
-        return dolly;
-    }
-}
-
 // ___________________________________________________________________________
 
 #[cfg(test)]

branches/try2/src/libcore/vec.rs

@@ -1347,15 +1347,7 @@ pub impl Liveness {
             self.propagate_through_expr(e, succ)
           }
 
-          expr_inline_asm(_, ins, outs, _, _, _) =>{
-            let succ = do ins.foldr(succ) |&(_, expr), succ| {
-                self.propagate_through_expr(expr, succ)
-            };
-            do outs.foldr(succ) |&(_, expr), succ| {
-                self.propagate_through_expr(expr, succ)
-            }
-          }
-
+          expr_inline_asm(*) |
           expr_lit(*) => {
             succ
           }
@@ -1621,20 +1613,6 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
         visit::visit_expr(expr, self, vt);
       }
 
-      expr_inline_asm(_, ins, outs, _, _, _) => {
-        for ins.each |&(_, in)| {
-          (vt.visit_expr)(in, self, vt);
-        }
-
-        // Output operands must be lvalues
-        for outs.each |&(_, out)| {
-          self.check_lvalue(out, vt);
-          (vt.visit_expr)(out, self, vt);
-        }
-
-        visit::visit_expr(expr, self, vt);
-      }
-
       // no correctness conditions related to liveness
       expr_call(*) | expr_method_call(*) | expr_if(*) | expr_match(*) |
       expr_while(*) | expr_loop(*) | expr_index(*) | expr_field(*) |
@@ -1643,7 +1621,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
       expr_cast(*) | expr_unary(*) | expr_ret(*) | expr_break(*) |
       expr_again(*) | expr_lit(_) | expr_block(*) | expr_swap(*) |
       expr_mac(*) | expr_addr_of(*) | expr_struct(*) | expr_repeat(*) |
-      expr_paren(*) => {
+      expr_paren(*) | expr_inline_asm(*) => {
         visit::visit_expr(expr, self, vt);
       }
     }

branches/try2/src/librustc/middle/liveness.rs

@@ -558,10 +558,10 @@ pub impl VisitContext {
                 self.use_expr(base, Read, visitor);
             }
 
-            expr_inline_asm(*) |
             expr_break(*) |
             expr_again(*) |
-            expr_lit(*) => {}
+            expr_lit(*)   |
+            expr_inline_asm(*) => {}
 
             expr_loop(ref blk, _) => {
                 self.consume_block(blk, visitor);

branches/try2/src/librustc/middle/moves.rs

@@ -873,7 +873,6 @@ pub fn add_comment(bcx: block, text: &str) {
 }
 
 pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char,
-                     inputs: &[ValueRef], output: TypeRef,
                      volatile: bool, alignstack: bool,
                      dia: AsmDialect) -> ValueRef {
     unsafe {
@@ -884,17 +883,11 @@ pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char,
         let alignstack = if alignstack { lib::llvm::True }
                          else          { lib::llvm::False };
 
-        let argtys = do inputs.map |v| {
-            debug!("Asm Input Type: %?", val_str(cx.ccx().tn, *v));
-            val_ty(*v)
-        };
-
-        debug!("Asm Output Type: %?", ty_str(cx.ccx().tn, output));
-        let llfty = T_fn(argtys, output);
+        let llfty = T_fn(~[], T_void());
         let v = llvm::LLVMInlineAsm(llfty, asm, cons, volatile,
                                     alignstack, dia as c_uint);
 
-        Call(cx, v, inputs)
+        Call(cx, v, ~[])
     }
 }