---

yaml
---
r: 13532
b: refs/heads/master
c: 976fae8
h: refs/heads/master
v: v3

Author: killerswan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 52f1904ddde95fb7d8e654b4cc78a4f162385275
+refs/heads/master: 976fae80a0fb08057a992fff914fd3995829c6ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/rust.css

@@ -51,3 +51,11 @@ 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 {
+  padding-top: 140px;
+  background-image: url('http://www.rust-lang.org/logos/rust-logo-128x128-blk.png');
+  background-repeat: no-repeat;
+  backround-position: right;
+  backround-attachment: fixed;
+}

trunk/mk/rt.mk

@@ -70,7 +70,6 @@ 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,7 +238,15 @@ fn load_link(mis: [@ast::meta_item]) -> (option<str>,
 }
 
 fn load_crate(filename: str) -> option<crate> {
-    let sess = parse::new_parse_sess(none);
+    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 c = parse::parse_crate_from_crate_file(filename, [], sess);
 
     let mut name = none;

trunk/src/fuzzer/fuzzer.rs

@@ -416,7 +416,15 @@ fn check_compiling(filename: str) -> happiness {
 
 fn parse_and_print(code: @str) -> str {
     let filename = "tmp.rs";
-    let sess = parse::new_parse_sess(option::none);
+    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
+    };
     write_file(filename, *code);
     let crate = parse::parse_crate_from_source_str(
         filename, code, [], sess);
@@ -558,7 +566,15 @@ fn check_variants(files: [str], cx: context) {
         }
 
         log(error, "check_variants: " + file);
-        let sess = parse::new_parse_sess(option::none);
+        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 crate =
             parse::parse_crate_from_source_str(
                 file,

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 arc, comm, task, future;
+export comm, task, future;
 export extfmt;
 export tuple;
 export to_str;
@@ -175,7 +175,6 @@ 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;
+        self.data <- w; //FIXME check for recursive use (#2607)
     }
 }
 

trunk/src/libcore/extfmt.rs

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

trunk/src/libcore/sys.rs

@@ -7,7 +7,6 @@ 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,
@@ -16,20 +15,11 @@ 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"]
@@ -84,46 +74,6 @@ 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 {
 
@@ -171,26 +121,6 @@ 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/libcore/arc.rs renamed to trunk/src/libstd/arc.rs

@@ -2,12 +2,9 @@
 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]
@@ -19,12 +16,12 @@ native mod rustrt {
         -> libc::intptr_t;
 }
 
-type arc_data<T> = {
+type arc_data<T: const> = {
     mut count: libc::intptr_t,
     data: T
 };
 
-resource arc_destruct<T>(data: *libc::c_void) {
+resource arc_destruct<T: const>(data: *libc::c_void) {
     unsafe {
         let data: ~arc_data<T> = unsafe::reinterpret_cast(data);
         let new_count = rustrt::rust_atomic_decrement(&mut data.count);
@@ -74,46 +71,6 @@ 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>>>;
@@ -158,7 +115,6 @@ 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() {
@@ -204,31 +160,4 @@ 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/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, par;
+export rope, arena, arc, par;
 export ebml, dbg, getopts, json, rand, sha1, term, time, prettyprint;
 export test, tempfile, serialization;
 export cmp;
@@ -69,6 +69,7 @@ mod term;
 mod time;
 mod prettyprint;
 mod arena;
+mod arc;
 mod par;
 mod cmp;
 

trunk/src/libsyntax/ast.rs

@@ -17,8 +17,6 @@ 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) {
@@ -373,13 +371,6 @@ 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_>;
 
@@ -395,7 +386,6 @@ 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,8 +455,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
         visit_expr: fn@(e: @expr) {
             vfn(e.id);
             alt e.node {
-              expr_index(*) | expr_assign_op(*) |
-              expr_unary(*) | expr_binary(*) {
+              expr_unary(_, _) | expr_binary(_, _, _) {
                 vfn(ast_util::op_expr_callee_id(e));
               }
               _ { /* fallthrough */ }