---

yaml
---
r: 13534
b: refs/heads/master
c: a14df27
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8103611b7f6860dbbff40bcac8f22788692223b4
+refs/heads/master: a14df270dc18cd13965e741967eaeac443e20466
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/rust.css

@@ -51,9 +51,3 @@ h3 a:link, h3 a:visited { color: black; }
 .cm-s-default span.cm-bracket {color: #cc7;}
 .cm-s-default span.cm-tag {color: #170;}
 .cm-s-default span.cm-attribute {color: #00c;}
-
-h1.title {
-  background-image: url('http://www.rust-lang.org/logos/rust-logo-32x32-blk.png');
-  background-repeat: no-repeat;
-  background-position: right;
-}

trunk/mk/rt.mk

@@ -70,6 +70,7 @@ RUNTIME_CS_$(1) := \
               rt/rust_cc.cpp \
               rt/rust_debug.cpp \
               rt/rust_box_annihilator.cpp \
+              rt/rust_cond_lock.cpp \
               rt/memory_region.cpp \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \

trunk/src/cargo/cargo.rs

@@ -238,15 +238,7 @@ fn load_link(mis: [@ast::meta_item]) -> (option<str>,
 }
 
 fn load_crate(filename: str) -> option<crate> {
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
+    let sess = parse::new_parse_sess(none);
     let c = parse::parse_crate_from_crate_file(filename, [], sess);
 
     let mut name = none;

trunk/src/fuzzer/fuzzer.rs

@@ -416,15 +416,7 @@ fn check_compiling(filename: str) -> happiness {
 
 fn parse_and_print(code: @str) -> str {
     let filename = "tmp.rs";
-    let cm = codemap::new_codemap();
-    let handler = diagnostic::mk_handler(none);
-    let sess = @{
-        cm: cm,
-        mut next_id: 1,
-        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-        mut chpos: 0u,
-        mut byte_pos: 0u
-    };
+    let sess = parse::new_parse_sess(option::none);
     write_file(filename, *code);
     let crate = parse::parse_crate_from_source_str(
         filename, code, [], sess);
@@ -566,15 +558,7 @@ fn check_variants(files: [str], cx: context) {
         }
 
         log(error, "check_variants: " + file);
-        let cm = codemap::new_codemap();
-        let handler = diagnostic::mk_handler(none);
-        let sess = @{
-            cm: cm,
-            mut next_id: 1,
-            span_diagnostic: diagnostic::mk_span_handler(handler, cm),
-            mut chpos: 0u,
-            mut byte_pos: 0u
-        };
+        let sess = parse::new_parse_sess(option::none);
         let crate =
             parse::parse_crate_from_source_str(
                 file,

trunk/src/libstd/arc.rs renamed to trunk/src/libcore/arc.rs

@@ -2,9 +2,12 @@
 share immutable data between tasks."]
 
 import comm::{port, chan, methods};
+import sys::methods;
 
 export arc, get, clone, shared_arc, get_arc;
 
+export exclusive, methods;
+
 #[abi = "cdecl"]
 native mod rustrt {
     #[rust_stack]
@@ -16,12 +19,12 @@ native mod rustrt {
         -> libc::intptr_t;
 }
 
-type arc_data<T: const> = {
+type arc_data<T> = {
     mut count: libc::intptr_t,
     data: T
 };
 
-resource arc_destruct<T: const>(data: *libc::c_void) {
+resource arc_destruct<T>(data: *libc::c_void) {
     unsafe {
         let data: ~arc_data<T> = unsafe::reinterpret_cast(data);
         let new_count = rustrt::rust_atomic_decrement(&mut data.count);
@@ -71,6 +74,46 @@ fn clone<T: const>(rc: &arc<T>) -> arc<T> {
     arc_destruct(**rc)
 }
 
+// An arc over mutable data that is protected by a lock.
+type ex_data<T> = {lock: sys::lock_and_signal, data: T};
+type exclusive<T> = arc_destruct<ex_data<T>>;
+
+fn exclusive<T>(-data: T) -> exclusive<T> {
+    let data = ~{mut count: 1, data: {lock: sys::create_lock(),
+                                      data: data}};
+    unsafe {
+        let ptr = unsafe::reinterpret_cast(data);
+        unsafe::forget(data);
+        arc_destruct(ptr)
+    }
+}
+
+impl methods<T> for exclusive<T> {
+    fn clone() -> exclusive<T> {
+        unsafe {
+            // this makes me nervous...
+            let ptr: ~arc_data<ex_data<T>> = unsafe::reinterpret_cast(*self);
+            rustrt::rust_atomic_increment(&mut ptr.count);
+            unsafe::forget(ptr);
+        }
+        arc_destruct(*self)
+    }
+
+    fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
+        unsafe {
+            let ptr: ~arc_data<ex_data<T>> = unsafe::reinterpret_cast(*self);
+            let r = {
+                let rec: &ex_data<T> = &(*ptr).data;
+                rec.lock.lock_cond() {|c|
+                    f(c, &rec.data)
+                }
+            };
+            unsafe::forget(ptr);
+            r
+        }
+    }
+}
+
 // Convenience code for sharing arcs between tasks
 
 type get_chan<T: const send> = chan<chan<arc<T>>>;
@@ -115,6 +158,7 @@ fn get_arc<T: send const>(c: get_chan<T>) -> arc::arc<T> {
 #[cfg(test)]
 mod tests {
     import comm::*;
+    import future::future;
 
     #[test]
     fn manually_share_arc() {
@@ -160,4 +204,31 @@ mod tests {
 
         assert p.recv() == ();
     }
+
+    #[test]
+    fn exclusive_arc() {
+        let mut futures = [];
+
+        let num_tasks = 10u;
+        let count = 1000u;
+
+        let total = exclusive(~mut 0u);
+
+        for uint::range(0u, num_tasks) {|_i|
+            let total = total.clone();
+            futures += [future::spawn({||
+                for uint::range(0u, count) {|_i|
+                    total.with {|_cond, count|
+                        **count += 1u;
+                    }
+                }
+            })];
+        };
+
+        for futures.each {|f| f.get() };
+
+        total.with {|_cond, total|
+            assert **total == num_tasks * count
+        };
+    }
 }

trunk/src/libcore/core.rc

@@ -39,7 +39,7 @@ export float, f32, f64;
 export box, char, str, ptr, vec, bool;
 export either, option, result, iter;
 export libc, os, io, run, rand, sys, unsafe, logging;
-export comm, task, future;
+export arc, comm, task, future;
 export extfmt;
 export tuple;
 export to_str;
@@ -175,6 +175,7 @@ mod dvec_iter {
 }
 
 // Concurrency
+mod arc;
 mod comm;
 mod task;
 mod future;

trunk/src/libcore/dvec.rs

@@ -129,7 +129,7 @@ impl extensions<A> for dvec<A> {
     #[doc = "Overwrite the current contents"]
     fn set(+w: [mut A]) {
         self.check_not_borrowed();
-        self.data <- w; //FIXME check for recursive use (#2607)
+        self.data <- w;
     }
 }
 

trunk/src/libcore/extfmt.rs

@@ -94,7 +94,8 @@ mod ct {
         }
         let mut i = 0u;
         while i < lim {
-            let curr = str::slice(s, i, i+1u);
+            let size = str::utf8_char_width(s[i]);
+            let curr = str::slice(s, i, i+size);
             if str::eq(curr, "%") {
                 i += 1u;
                 if i >= lim {
@@ -110,7 +111,7 @@ mod ct {
                     pieces += [rs.piece];
                     i = rs.next;
                 }
-            } else { buf += curr; i += 1u; }
+            } else { buf += curr; i += size; }
         }
         flush_buf(buf, pieces);
         ret pieces;

trunk/src/libcore/sys.rs

@@ -7,6 +7,7 @@ export min_align_of;
 export pref_align_of;
 export refcount;
 export log_str;
+export create_lock, lock_and_signal, condition, methods;
 
 enum type_desc = {
     first_param: **libc::c_int,
@@ -15,11 +16,20 @@ enum type_desc = {
     // Remaining fields not listed
 };
 
+type rust_cond_lock = *libc::c_void;
+
 #[abi = "cdecl"]
 native mod rustrt {
     pure fn refcount(t: *()) -> libc::intptr_t;
     fn unsupervise();
     pure fn shape_log_str(t: *sys::type_desc, data: *()) -> str;
+
+    fn rust_create_cond_lock() -> rust_cond_lock;
+    fn rust_destroy_cond_lock(lock: rust_cond_lock);
+    fn rust_lock_cond_lock(lock: rust_cond_lock);
+    fn rust_unlock_cond_lock(lock: rust_cond_lock);
+    fn rust_wait_cond_lock(lock: rust_cond_lock);
+    fn rust_signal_cond_lock(lock: rust_cond_lock) -> bool;
 }
 
 #[abi = "rust-intrinsic"]
@@ -74,6 +84,46 @@ pure fn log_str<T>(t: T) -> str {
     }
 }
 
+resource lock_and_signal(lock: rust_cond_lock) {
+    rustrt::rust_destroy_cond_lock(lock);
+}
+
+enum condition {
+    condition_(rust_cond_lock)
+}
+
+resource unlock(lock: rust_cond_lock) {
+    rustrt::rust_unlock_cond_lock(lock);
+}
+
+fn create_lock() -> lock_and_signal {
+    lock_and_signal(rustrt::rust_create_cond_lock())
+}
+
+impl methods for lock_and_signal {
+    fn lock<T>(f: fn() -> T) -> T {
+        rustrt::rust_lock_cond_lock(*self);
+        let _r = unlock(*self);
+        f()
+    }
+
+    fn lock_cond<T>(f: fn(condition) -> T) -> T {
+        rustrt::rust_lock_cond_lock(*self);
+        let _r = unlock(*self);
+        f(condition_(*self))
+    }
+}
+
+impl methods for condition {
+    fn wait() {
+        rustrt::rust_wait_cond_lock(*self);
+    }
+
+    fn signal() -> bool {
+        rustrt::rust_signal_cond_lock(*self)
+    }
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -121,6 +171,26 @@ mod tests {
         assert pref_align_of::<uint>() == 8u;
         assert pref_align_of::<*uint>() == 8u;
     }
+
+    #[test]
+    fn condition_variable() {
+        let lock = arc::arc(create_lock());
+        let lock2 = arc::clone(&lock);
+
+        task::spawn {|move lock2|
+            let lock = arc::get(&lock2);
+            (*lock).lock_cond {|c|
+                c.wait();
+            }
+        }
+
+        let mut signaled = false;
+        while !signaled {
+            (*arc::get(&lock)).lock_cond {|c|
+                signaled = c.signal()
+            }
+        }
+    }
 }
 
 // Local Variables:

trunk/src/libstd/std.rc

@@ -19,7 +19,7 @@ export net, net_tcp;
 export uv, uv_ll, uv_iotask, uv_global_loop;
 export c_vec, util, timer;
 export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap;
-export rope, arena, arc, par;
+export rope, arena, par;
 export ebml, dbg, getopts, json, rand, sha1, term, time, prettyprint;
 export test, tempfile, serialization;
 export cmp;
@@ -69,7 +69,6 @@ mod term;
 mod time;
 mod prettyprint;
 mod arena;
-mod arc;
 mod par;
 mod cmp;
 

trunk/src/libsyntax/ast.rs

@@ -17,6 +17,8 @@ import std::serialization::{serializer,
                             deserialize_str,
                             serialize_bool,
                             deserialize_bool};
+import parse::token;
+
 
 /* Note #1972 -- spans are serialized but not deserialized */
 fn serialize_span<S>(_s: S, _v: span) {
@@ -371,6 +373,13 @@ enum blk_sort {
 }
 */
 
+#[auto_serialize]
+enum token_tree {
+    /* for macro invocations; parsing is the macro's job */
+    tt_delim([token_tree]),
+    tt_flat(span, token::token)
+}
+
 #[auto_serialize]
 type mac = spanned<mac_>;
 
@@ -386,6 +395,7 @@ type mac_body = option<mac_body_>;
 #[auto_serialize]
 enum mac_ {
     mac_invoc(@path, mac_arg, mac_body),
+    mac_invoc_tt(@path, token_tree), //will kill mac_invoc and steal its name
     mac_embed_type(@ty),
     mac_embed_block(blk),
     mac_ellipsis,

trunk/src/libsyntax/ast_util.rs

@@ -455,7 +455,8 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
         visit_expr: fn@(e: @expr) {
             vfn(e.id);
             alt e.node {
-              expr_unary(_, _) | expr_binary(_, _, _) {
+              expr_index(*) | expr_assign_op(*) |
+              expr_unary(*) | expr_binary(*) {
                 vfn(ast_util::op_expr_callee_id(e));
               }
               _ { /* fallthrough */ }