---

yaml
---
r: 139971
b: refs/heads/try2
c: 5c2e9b2
h: refs/heads/master
i:
  139969: e58c505
  139967: ba8009b
v: v3

Author: huonw

[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: 4ff701b7db609cabe59832d47779832a16627b5f
+refs/heads/try2: 5c2e9b29f10694ad76dcb6b88e95243a44813c05
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial.md

@@ -1670,7 +1670,7 @@ do spawn {
 ~~~~
 
 If you want to see the output of `debug!` statements, you will need to turn on `debug!` logging.
-To enable `debug!` logging, set the RUST_LOG environment variable to the name of your crate, which, for a file named `foo.rs`, will be `foo` (e.g., with bash, `export RUST_LOG=foo`).
+To enable `debug!` logging, set the RUST_LOG environment variable to `debug` (e.g., with bash, `export RUST_LOG=debug`)
 
 ## For loops
 

branches/try2/src/etc/unicode.py

@@ -112,49 +112,7 @@ def escape_char(c):
         return "'\\u%4.4x'" % c
     return "'\\U%8.8x'" % c
 
-def ch_prefix(ix):
-    if ix == 0:
-        return "        "
-    if ix % 2 == 0:
-        return ",\n        "
-    else:
-        return ", "
-
-def emit_bsearch_range_table(f):
-    f.write("""
-    pure fn bsearch_range_table(c: char, r: &[(char,char)]) -> bool {
-        use cmp::{EQ, LT, GT};
-        use vec::bsearch;
-        use option::None;
-        (do bsearch(r) |&(lo,hi)| {
-            if lo <= c && c <= hi { EQ }
-            else if hi < c { LT }
-            else { GT }
-        }) != None
-    }\n\n
-""");
-
 def emit_property_module(f, mod, tbl):
-    f.write("pub mod %s {\n" % mod)
-    keys = tbl.keys()
-    keys.sort()
-    emit_bsearch_range_table(f);
-    for cat in keys:
-        f.write("    const %s_table : &[(char,char)] = &[\n" % cat)
-        ix = 0
-        for pair in tbl[cat]:
-            f.write(ch_prefix(ix))
-            f.write("(%s, %s)" % (escape_char(pair[0]), escape_char(pair[1])))
-            ix += 1
-        f.write("\n    ];\n\n")
-
-        f.write("    pub pure fn %s(c: char) -> bool {\n" % cat)
-        f.write("        bsearch_range_table(c, %s_table)\n" % cat)
-        f.write("    }\n\n")
-    f.write("}\n")
-
-
-def emit_property_module_old(f, mod, tbl):
     f.write("mod %s {\n" % mod)
     keys = tbl.keys()
     keys.sort()
@@ -235,9 +193,8 @@ def emit_decomp_module(f, canon, compat):
 rf = open(r, "w")
 
 (canon_decomp, compat_decomp, gencats) = load_unicode_data("UnicodeData.txt")
+emit_decomp_module(rf, canon_decomp, compat_decomp)
 emit_property_module(rf, "general_category", gencats)
 
-#emit_decomp_module(rf, canon_decomp, compat_decomp)
-
 derived = load_derived_core_properties("DerivedCoreProperties.txt")
 emit_property_module(rf, "derived_property", derived)

branches/try2/src/libcore/comm.rs

@@ -112,6 +112,8 @@ pub mod streamp {
 
     #[allow(non_camel_case_types)]
     pub mod server {
+        priv use core::kinds::Owned;
+
         #[allow(non_camel_case_types)]
         pub type Open<T> = ::core::pipes::RecvPacket<super::Open<T>>;
     }
@@ -386,6 +388,8 @@ pub mod oneshot {
 
     #[allow(non_camel_case_types)]
     pub mod server {
+        priv use core::kinds::Owned;
+
         #[allow(non_camel_case_types)]
         pub type Oneshot<T> =
             ::core::pipes::RecvPacketBuffered<super::Oneshot<T>,

branches/try2/src/libcore/rt/sched/local_sched.rs

@@ -66,16 +66,18 @@ pub fn borrow(f: &fn(&mut Scheduler)) {
 /// Because this leaves the Scheduler in thread-local storage it is possible
 /// For the Scheduler pointer to be aliased
 pub unsafe fn unsafe_borrow() -> &mut Scheduler {
-    let key = tls_key();
-    let mut void_sched: *mut c_void = tls::get(key);
-    assert!(void_sched.is_not_null());
-    {
-        let void_sched_ptr = &mut void_sched;
-        let sched: &mut ~Scheduler = {
-            transmute::<&mut *mut c_void, &mut ~Scheduler>(void_sched_ptr)
-        };
-        let sched: &mut Scheduler = &mut **sched;
-        return sched;
+    unsafe {
+        let key = tls_key();
+        let mut void_sched: *mut c_void = tls::get(key);
+        assert!(void_sched.is_not_null());
+        {
+            let void_sched_ptr = &mut void_sched;
+            let sched: &mut ~Scheduler = {
+                transmute::<&mut *mut c_void, &mut ~Scheduler>(void_sched_ptr)
+            };
+            let sched: &mut Scheduler = &mut **sched;
+            return sched;
+        }
     }
 }
 

branches/try2/src/libcore/rt/uv/net.rs

@@ -388,7 +388,7 @@ fn connect_read() {
                 vec_to_uv_buf(vec::from_elem(size, 0))
             };
             do stream_watcher.read_start(alloc)
-                |stream_watcher, _nread, buf, status| {
+                |stream_watcher, nread, buf, status| {
 
                 let buf = vec_from_uv_buf(buf);
                 rtdebug!("read cb!");

branches/try2/src/libcore/stackwalk.rs

@@ -64,7 +64,9 @@ fn test_simple_deep() {
         if i == 0 { return }
 
         for walk_stack |_frame| {
-            breakpoint();
+            unsafe {
+                breakpoint();
+            }
         }
         run(i - 1);
     }

branches/try2/src/libcore/str.rs

@@ -3346,15 +3346,15 @@ mod tests {
     #[test]
     fn test_shift_byte() {
         let mut s = ~"ABC";
-        let b = raw::shift_byte(&mut s);
+        let b = unsafe { raw::shift_byte(&mut s) };
         assert!((s == ~"BC"));
         assert!((b == 65u8));
     }
 
     #[test]
     fn test_pop_byte() {
         let mut s = ~"ABC";
-        let b = raw::pop_byte(&mut s);
+        let b = unsafe { raw::pop_byte(&mut s) };
         assert!((s == ~"AB"));
         assert!((b == 67u8));
     }

branches/try2/src/libcore/sys.rs

@@ -83,12 +83,24 @@ pub fn get_type_desc<T>() -> *TypeDesc {
     unsafe { rusti::get_tydesc::<T>() as *TypeDesc }
 }
 
+/// Returns a pointer to a type descriptor.
+#[inline(always)]
+pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
+    get_type_desc::<T>()
+}
+
 /// Returns the size of a type
 #[inline(always)]
 pub fn size_of<T>() -> uint {
     unsafe { rusti::size_of::<T>() }
 }
 
+/// Returns the size of the type that `_val` points to
+#[inline(always)]
+pub fn size_of_val<T>(_val: &T) -> uint {
+    size_of::<T>()
+}
+
 /**
  * Returns the size of a type, or 1 if the actual size is zero.
  *
@@ -100,6 +112,13 @@ pub fn nonzero_size_of<T>() -> uint {
     if s == 0 { 1 } else { s }
 }
 
+/// Returns the size of the type of the value that `_val` points to
+#[inline(always)]
+pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
+    nonzero_size_of::<T>()
+}
+
+
 /**
  * Returns the ABI-required minimum alignment of a type
  *
@@ -111,12 +130,26 @@ pub fn min_align_of<T>() -> uint {
     unsafe { rusti::min_align_of::<T>() }
 }
 
+/// Returns the ABI-required minimum alignment of the type of the value that
+/// `_val` points to
+#[inline(always)]
+pub fn min_align_of_val<T>(_val: &T) -> uint {
+    min_align_of::<T>()
+}
+
 /// Returns the preferred alignment of a type
 #[inline(always)]
 pub fn pref_align_of<T>() -> uint {
     unsafe { rusti::pref_align_of::<T>() }
 }
 
+/// Returns the preferred alignment of the type of the value that
+/// `_val` points to
+#[inline(always)]
+pub fn pref_align_of_val<T>(_val: &T) -> uint {
+    pref_align_of::<T>()
+}
+
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline(always)]
 pub fn refcount<T>(t: @T) -> uint {
@@ -162,7 +195,7 @@ pub fn fail_assert(msg: &str, file: &str, line: uint) -> ! {
 #[cfg(test)]
 mod tests {
     use cast;
-    use sys::{Closure, pref_align_of, size_of, nonzero_size_of};
+    use sys::*;
 
     #[test]
     fn size_of_basic() {
@@ -188,6 +221,14 @@ mod tests {
         assert!(size_of::<*uint>() == 8u);
     }
 
+    #[test]
+    fn size_of_val_basic() {
+        assert_eq!(size_of_val(&1u8), 1);
+        assert_eq!(size_of_val(&1u16), 2);
+        assert_eq!(size_of_val(&1u32), 4);
+        assert_eq!(size_of_val(&1u64), 8);
+    }
+
     #[test]
     fn nonzero_size_of_basic() {
         type Z = [i8, ..0];
@@ -196,6 +237,14 @@ mod tests {
         assert!(nonzero_size_of::<uint>() == size_of::<uint>());
     }
 
+    #[test]
+    fn nonzero_size_of_val_basic() {
+        let z = [0u8, ..0];
+        assert_eq!(size_of_val(&z), 0u);
+        assert_eq!(nonzero_size_of_val(&z), 1u);
+        assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
+    }
+
     #[test]
     fn align_of_basic() {
         assert!(pref_align_of::<u8>() == 1u);
@@ -219,6 +268,13 @@ mod tests {
         assert!(pref_align_of::<*uint>() == 8u);
     }
 
+    #[test]
+    fn align_of_val_basic() {
+        assert_eq!(pref_align_of_val(&1u8), 1u);
+        assert_eq!(pref_align_of_val(&1u16), 2u);
+        assert_eq!(pref_align_of_val(&1u32), 4u);
+    }
+
     #[test]
     fn synthesize_closure() {
         unsafe {

branches/try2/src/libcore/task/local_data.rs

@@ -150,28 +150,32 @@ fn test_tls_modify() {
 
 #[test]
 fn test_tls_crust_automorestack_memorial_bug() {
-    // This might result in a stack-canary clobber if the runtime fails to
-    // set sp_limit to 0 when calling the cleanup extern - it might
-    // automatically jump over to the rust stack, which causes next_c_sp
-    // to get recorded as something within a rust stack segment. Then a
-    // subsequent upcall (esp. for logging, think vsnprintf) would run on
-    // a stack smaller than 1 MB.
-    fn my_key(_x: @~str) { }
-    do task::spawn {
-        unsafe { local_data_set(my_key, @~"hax"); }
+    unsafe {
+        // This might result in a stack-canary clobber if the runtime fails to
+        // set sp_limit to 0 when calling the cleanup extern - it might
+        // automatically jump over to the rust stack, which causes next_c_sp
+        // to get recorded as something within a rust stack segment. Then a
+        // subsequent upcall (esp. for logging, think vsnprintf) would run on
+        // a stack smaller than 1 MB.
+        fn my_key(_x: @~str) { }
+        do task::spawn {
+            unsafe { local_data_set(my_key, @~"hax"); }
+        }
     }
 }
 
 #[test]
 fn test_tls_multiple_types() {
-    fn str_key(_x: @~str) { }
-    fn box_key(_x: @@()) { }
-    fn int_key(_x: @int) { }
-    do task::spawn {
-        unsafe {
-            local_data_set(str_key, @~"string data");
-            local_data_set(box_key, @@());
-            local_data_set(int_key, @42);
+    unsafe {
+        fn str_key(_x: @~str) { }
+        fn box_key(_x: @@()) { }
+        fn int_key(_x: @int) { }
+        do task::spawn {
+            unsafe {
+                local_data_set(str_key, @~"string data");
+                local_data_set(box_key, @@());
+                local_data_set(int_key, @42);
+            }
         }
     }
 }