---

yaml
---
r: 144574
b: refs/heads/try2
c: a2ffcea
h: refs/heads/master
v: v3

Author: bouk

[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: 8e3efc112f8eb61716c5e8c3fea8f2ef03d88498
+refs/heads/try2: a2ffceaedd5d80a83bafd3e930541c1d32424604
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/etc/emacs/rust-mode.el

@@ -5,7 +5,6 @@
 ;; Url: https://github.com/mozilla/rust
 
 (eval-when-compile (require 'cl))
-(eval-when-compile (require 'misc))
 
 ;; Syntax definitions and helpers
 (defvar rust-mode-syntax-table
@@ -58,39 +57,19 @@
               ;; A closing brace is 1 level unindended
               ((looking-at "}") (* rust-indent-offset (- level 1)))
 
-              ; Doc comments in /** style with leading * indent to line up the *s
-              ((and (nth 4 (syntax-ppss)) (looking-at "*"))
-               (+ 1 (* rust-indent-offset level)))
-
               ;; If we're in any other token-tree / sexp, then:
               ;;  - [ or ( means line up with the opening token
               ;;  - { means indent to either nesting-level * rust-indent-offset,
               ;;    or one further indent from that if either current line
               ;;    begins with 'else', or previous line didn't end in
-              ;;    semi, comma or brace (other than whitespace and line
-              ;;    comments) , and wasn't an attribute.  But if we have 
-              ;;    something after the open brace and ending with a comma,
-              ;;    treat it as fields and align them.  PHEW.
+              ;;    semi, comma or brace, and wasn't an attribute. PHEW.
               ((> level 0)
                (let ((pt (point)))
                  (rust-rewind-irrelevant)
                  (backward-up-list)
-                 (cond 
-                  ((and
-                      (looking-at "[[(]")
-                      ; We don't want to indent out to the open bracket if the
-                      ; open bracket ends the line
-                      (save-excursion 
-                        (forward-char)
-                        (not (looking-at "[[:space:]]*\\(?://.*\\)?$"))))
-                   (+ 1 (current-column)))
-                  ;; Check for fields on the same line as the open curly brace:
-                  ((looking-at "{[[:blank:]]*[^}\n]*,[[:space:]]*$")
+                 (if (looking-at "[[(]")
+                     (+ 1 (current-column))
                    (progn
-                    (forward-char)
-                    (forward-to-word 1)
-                    (current-column)))
-                  (t (progn
                      (goto-char pt)
                      (back-to-indentation)
                      (if (looking-at "\\<else\\>")
@@ -100,12 +79,12 @@
                          (beginning-of-line)
                          (rust-rewind-irrelevant)
                          (end-of-line)
-                         (if (looking-back "[,;{}(][[:space:]]*\\(?://.*\\)?")
+                         (if (looking-back "[{};,]")
                              (* rust-indent-offset level)
                            (back-to-indentation)
                            (if (looking-at "#")
                                (* rust-indent-offset level)
-                             (* rust-indent-offset (+ 1 level)))))))))))
+                             (* rust-indent-offset (+ 1 level))))))))))
 
               ;; Otherwise we're in a column-zero definition
               (t 0))))))

branches/try2/src/libextra/test.rs

@@ -745,7 +745,7 @@ fn get_concurrency() -> uint {
             let opt_n: Option<uint> = FromStr::from_str(s);
             match opt_n {
                 Some(n) if n > 0 => n,
-                _ => fail!("RUST_TEST_TASKS is `%s`, should be a positive integer.", s)
+                _ => fail!("RUST_TEST_TASKS is `%s`, should be a non-negative integer.", s)
             }
         }
         None => {

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

@@ -2585,13 +2585,11 @@ impl Resolver {
                 debug!("(resolving glob import) ... for value target");
                 dest_import_resolution.value_target =
                     Some(Target(containing_module, name_bindings));
-                dest_import_resolution.value_id = id;
             }
             if name_bindings.defined_in_public_namespace(TypeNS) {
                 debug!("(resolving glob import) ... for type target");
                 dest_import_resolution.type_target =
                     Some(Target(containing_module, name_bindings));
-                dest_import_resolution.type_id = id;
             }
         };
 

branches/try2/src/libstd/io.rs

@@ -619,7 +619,7 @@ pub trait ReaderUtil {
 
 impl<T:Reader> ReaderUtil for T {
 
-    fn read_bytes(&self,len: uint) -> ~[u8] {
+    fn read_bytes(&self, len: uint) -> ~[u8] {
         let mut bytes = vec::with_capacity(len);
         unsafe { vec::raw::set_len(&mut bytes, len); }
 

branches/try2/src/libstd/rt/args.rs

@@ -55,11 +55,10 @@ pub fn clone() -> Option<~[~str]> {
 mod imp {
     use libc;
     use option::{Option, Some, None};
-    use iterator::Iterator;
+    use iterator::{Iterator, range};
     use str;
     use unstable::finally::Finally;
     use util;
-    use vec;
 
     pub unsafe fn init(argc: int, argv: **u8) {
         let args = load_argc_and_argv(argc, argv);
@@ -112,9 +111,11 @@ mod imp {
 
     // Copied from `os`.
     unsafe fn load_argc_and_argv(argc: int, argv: **u8) -> ~[~str] {
-        do vec::from_fn(argc as uint) |i| {
-            str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int))
+        let mut args = ~[];
+        for i in range(0u, argc as uint) {
+            args.push(str::raw::from_c_str(*(argv as **libc::c_char).offset(i as int)));
         }
+        args
     }
 
     #[cfg(stage0)]

branches/try2/src/libstd/rt/local_ptr.rs

@@ -121,20 +121,27 @@ pub unsafe fn borrow<T>(f: &fn(&mut T)) {
 /// For the Scheduler pointer to be aliased
 pub unsafe fn unsafe_borrow<T>() -> *mut T {
     let key = tls_key();
-    let void_ptr = tls::get(key);
+    let mut void_ptr: *mut c_void = tls::get(key);
     if void_ptr.is_null() {
         rtabort!("thread-local pointer is null. bogus!");
     }
-    void_ptr as *mut T
+    let ptr: *mut *mut c_void = &mut void_ptr;
+    let ptr: *mut ~T = ptr as *mut ~T;
+    let ptr: *mut T = &mut **ptr;
+    return ptr;
 }
 
 pub unsafe fn try_unsafe_borrow<T>() -> Option<*mut T> {
     let key = tls_key();
-    let void_ptr = tls::get(key);
+    let mut void_ptr: *mut c_void = tls::get(key);
     if void_ptr.is_null() {
-        None
-    } else {
-        Some(void_ptr as *mut T)
+        return None;
+    }
+    {
+        let ptr: *mut *mut c_void = &mut void_ptr;
+        let ptr: *mut ~T = ptr as *mut ~T;
+        let ptr: *mut T = &mut **ptr;
+        return Some(ptr);
     }
 }
 

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

@@ -59,7 +59,7 @@ Several modules in `core` are clients of `rt`:
 use cell::Cell;
 use clone::Clone;
 use container::Container;
-use iterator::Iterator;
+use iterator::{Iterator, range};
 use option::{Option, None, Some};
 use ptr::RawPtr;
 use rt::local::Local;
@@ -71,8 +71,7 @@ use rt::work_queue::WorkQueue;
 use rt::uv::uvio::UvEventLoop;
 use unstable::atomics::{AtomicInt, SeqCst};
 use unstable::sync::UnsafeArc;
-use vec;
-use vec::{OwnedVector, MutableVector, ImmutableVector};
+use vec::{OwnedVector, MutableVector};
 
 /// The global (exchange) heap.
 pub mod global_heap;
@@ -252,21 +251,25 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
 
     // Create a work queue for each scheduler, ntimes. Create an extra
     // for the main thread if that flag is set. We won't steal from it.
-    let work_queues: ~[WorkQueue<~Task>] = vec::from_fn(nscheds, |_| WorkQueue::new());
+    let mut work_queues = ~[];
+    for _ in range(0u, nscheds) {
+        let work_queue: WorkQueue<~Task> = WorkQueue::new();
+        work_queues.push(work_queue);
+    }
 
     // The schedulers.
     let mut scheds = ~[];
     // Handles to the schedulers. When the main task ends these will be
     // sent the Shutdown message to terminate the schedulers.
     let mut handles = ~[];
 
-    for work_queue in work_queues.iter() {
+    for i in range(0u, nscheds) {
         rtdebug!("inserting a regular scheduler");
 
         // Every scheduler is driven by an I/O event loop.
         let loop_ = ~UvEventLoop::new();
         let mut sched = ~Scheduler::new(loop_,
-                                        work_queue.clone(),
+                                        work_queues[i].clone(),
                                         work_queues.clone(),
                                         sleepers.clone());
         let handle = sched.make_handle();
@@ -355,8 +358,9 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     }
 
     // Run each remaining scheduler in a thread.
-    for sched in scheds.move_rev_iter() {
+    while !scheds.is_empty() {
         rtdebug!("creating regular schedulers");
+        let sched = scheds.pop();
         let sched_cell = Cell::new(sched);
         let thread = do Thread::start {
             let mut sched = sched_cell.take();

branches/try2/src/libstd/rt/util.rs

@@ -11,7 +11,7 @@
 use container::Container;
 use from_str::FromStr;
 use libc;
-use option::{Some, None, Option};
+use option::{Some, None};
 use os;
 use str::StrSlice;
 use unstable::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst};
@@ -57,13 +57,7 @@ pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool {
 /// either `RUST_THREADS` or `num_cpus`.
 pub fn default_sched_threads() -> uint {
     match os::getenv("RUST_THREADS") {
-        Some(nstr) => {
-            let opt_n: Option<uint> = FromStr::from_str(nstr);
-            match opt_n {
-                Some(n) if n > 0 => n,
-                _ => rtabort!("`RUST_THREADS` is `%s`, should be a positive integer", nstr)
-            }
-        }
+        Some(nstr) => FromStr::from_str(nstr).unwrap(),
         None => {
             if limit_thread_creation_due_to_osx_and_valgrind() {
                 1

branches/try2/src/libstd/str.rs

@@ -907,6 +907,46 @@ pub fn with_capacity(capacity: uint) -> ~str {
     }
 }
 
+/// As char_len but for a slice of a string
+///
+/// # Arguments
+///
+/// * s - A valid string
+/// * start - The position inside `s` where to start counting in bytes
+/// * end - The position where to stop counting
+///
+/// # Return value
+///
+/// The number of Unicode characters in `s` between the given indices.
+pub fn count_chars(s: &str, start: uint, end: uint) -> uint {
+    assert!(s.is_char_boundary(start));
+    assert!(s.is_char_boundary(end));
+    let mut i = start;
+    let mut len = 0u;
+    while i < end {
+        let next = s.char_range_at(i).next;
+        len += 1u;
+        i = next;
+    }
+    return len;
+}
+
+/// Counts the number of bytes taken by the first `n` chars in `s`
+/// starting from `start`.
+pub fn count_bytes<'b>(s: &'b str, start: uint, n: uint) -> uint {
+    assert!(s.is_char_boundary(start));
+    let mut end = start;
+    let mut cnt = n;
+    let l = s.len();
+    while cnt > 0u {
+        assert!(end < l);
+        let next = s.char_range_at(end).next;
+        cnt -= 1u;
+        end = next;
+    }
+    end - start
+}
+
 // https://tools.ietf.org/html/rfc3629
 static UTF8_CHAR_WIDTH: [u8, ..256] = [
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

branches/try2/src/libstd/unstable/sync.rs

@@ -26,7 +26,6 @@ use vec;
 /// An atomically reference counted pointer.
 ///
 /// Enforces no shared-memory safety.
-#[unsafe_no_drop_flag]
 pub struct UnsafeArc<T> {
     data: *mut ArcData<T>,
 }
@@ -222,9 +221,8 @@ impl<T: Send> Clone for UnsafeArc<T> {
 impl<T> Drop for UnsafeArc<T>{
     fn drop(&self) {
         unsafe {
-            // Happens when destructing an unwrapper's handle and from `#[unsafe_no_drop_flag]`
             if self.data.is_null() {
-                return
+                return; // Happens when destructing an unwrapper's handle.
             }
             let mut data: ~ArcData<T> = cast::transmute(self.data);
             // Must be acquire+release, not just release, to make sure this
@@ -442,12 +440,6 @@ mod tests {
     use super::{Exclusive, UnsafeArc, atomically};
     use task;
     use util;
-    use sys::size_of;
-
-    #[test]
-    fn test_size() {
-        assert_eq!(size_of::<UnsafeArc<[int, ..10]>>(), size_of::<*[int, ..10]>());
-    }
 
     #[test]
     fn test_atomically() {