---

yaml
---
r: 62707
b: refs/heads/snap-stage3
c: 008e6e5
h: refs/heads/master
i:
  62705: 8a3e885
  62703: b8e99ad
v: v3

Author: James Miller

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bf57d65a117f2d3634b4eda62001e45fe31b0e9d
+refs/heads/snap-stage3: 008e6e5e7e4d2e102d7048a948e9fcac82e1e210
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/.gitignore

@@ -73,7 +73,6 @@ src/.DS_Store
 /doc/html
 /doc/latex
 /doc/std
-/doc/extra
 /nd/
 /llvm/
 version.md
@@ -82,6 +81,7 @@ keywords.md
 x86_64-apple-darwin/
 x86_64-unknown-linux-gnu/
 i686-unknown-linux-gnu/
+doc/core/
 tmp.*.rs
 config.stamp
 .DS_Store

branches/snap-stage3/configure

@@ -555,11 +555,11 @@ then
     CFG_CLANG_VERSION=$("$CFG_CLANG" \
                       --version \
                       | grep version \
-                      | sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
+                      | sed 's/.*\(version .*\)/\1/' \
                       | cut -d ' ' -f 2)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3*)
+        (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 4.0* | 4.1* | 4.2*)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

branches/snap-stage3/mk/platform.mk

@@ -29,7 +29,7 @@ $(foreach t,$(CFG_TARGET_TRIPLES),$(info cfg: os for $(t) is $(OSTYPE_$(t))))
 # FIXME: no-omit-frame-pointer is just so that task_start_wrapper
 # has a frame pointer and the stack walker can understand it. Turning off
 # frame pointers everywhere is overkill
-CFG_GCCISH_CFLAGS += -fno-omit-frame-pointer -DUSE_UTF8
+CFG_GCCISH_CFLAGS += -fno-omit-frame-pointer
 
 # On Darwin, we need to run dsymutil so the debugging information ends
 # up in the right place.  On other platforms, it automatically gets

branches/snap-stage3/src/libextra/arc.rs

@@ -107,7 +107,7 @@ pub impl<'self> Condvar<'self> {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
+struct ARC<T> { x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
 pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
@@ -118,22 +118,29 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-pub impl<T:Const+Owned> ARC<T> {
-    fn get<'a>(&'a self) -> &'a T {
+pub fn get<'a, T:Const + Owned>(rc: &'a ARC<T>) -> &'a T {
+    rc.get()
+}
+
+impl<T:Const+Owned> ARC<T> {
+    pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
 }
-
 /**
  * Duplicate an atomically reference counted wrapper.
  *
  * The resulting two `arc` objects will point to the same underlying data
  * object. However, one of the `arc` objects can be sent to another task,
  * allowing them to share the underlying data.
  */
+pub fn clone<T:Const + Owned>(rc: &ARC<T>) -> ARC<T> {
+    ARC { x: rc.x.clone() }
+}
+
 impl<T:Const + Owned> Clone for ARC<T> {
     fn clone(&self) -> ARC<T> {
-        ARC { x: self.x.clone() }
+        clone(self)
     }
 }
 
@@ -505,31 +512,34 @@ pub impl<'self, T:Const + Owned> RWReadMode<'self, T> {
 #[cfg(test)]
 mod tests {
     use core::prelude::*;
-    use core::cell::Cell;
+
     use arc::*;
     use arc;
 
+    use core::cell::Cell;
+    use core::task;
+
     #[test]
     fn manually_share_arc() {
         let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        let arc_v = ARC(v);
+        let arc_v = arc::ARC(v);
 
         let (p, c) = comm::stream();
 
         do task::spawn() || {
             let p = comm::PortSet::new();
             c.send(p.chan());
 
-            let arc_v : ARC<~[int]> = p.recv();
+            let arc_v = p.recv();
 
-            let v = copy (*arc_v.get());
+            let v = copy *arc::get::<~[int]>(&arc_v);
             assert_eq!(v[3], 4);
         };
 
         let c = p.recv();
-        c.send(arc_v.clone());
+        c.send(arc::clone(&arc_v));
 
-        assert_eq!(arc_v.get()[2], 3);
+        assert_eq!((*arc::get(&arc_v))[2], 3);
         assert_eq!(arc_v.get()[4], 5);
 
         info!(arc_v);

branches/snap-stage3/src/librust/rust.rc

@@ -32,17 +32,16 @@ extern mod rustc;
 use core::prelude::*;
 
 use core::run;
-use core::libc::exit;
 
 enum ValidUsage {
-    Valid(int), Invalid
+    Valid, Invalid
 }
 
 impl ValidUsage {
     fn is_valid(&self) -> bool {
         match *self {
-            Valid(_)   => true,
-            Invalid    => false
+            Valid   => true,
+            Invalid => false
         }
     }
 }
@@ -145,7 +144,7 @@ fn cmd_help(args: &[~str]) -> ValidUsage {
                     UsgStr(msg) => io::println(fmt!("%s\n", msg)),
                     UsgCall(f)  => f(),
                 }
-                Valid(0)
+                Valid
             },
             None => Invalid
         }
@@ -163,8 +162,8 @@ fn cmd_test(args: &[~str]) -> ValidUsage {
             let test_exec = Path(filename).filestem().unwrap() + "test~";
             invoke("rustc", &[~"--test", filename.to_owned(),
                               ~"-o", test_exec.to_owned()], rustc::main);
-            let exit_code = run::run_program(~"./" + test_exec, []);
-            Valid(exit_code)
+            run::run_program(~"./" + test_exec, []);
+            Valid
         }
         _ => Invalid
     }
@@ -176,8 +175,8 @@ fn cmd_run(args: &[~str]) -> ValidUsage {
             let exec = Path(filename).filestem().unwrap() + "~";
             invoke("rustc", &[filename.to_owned(), ~"-o", exec.to_owned()],
                    rustc::main);
-            let exit_code = run::run_program(~"./"+exec, prog_args);
-            Valid(exit_code)
+            run::run_program(~"./"+exec, prog_args);
+            Valid
         }
         _ => Invalid
     }
@@ -195,7 +194,7 @@ fn do_command(command: &Command, args: &[~str]) -> ValidUsage {
         Call(f) => f(args),
         CallMain(prog, f) => {
             invoke(prog, args, f);
-            Valid(0)
+            Valid
         }
     }
 }
@@ -234,10 +233,7 @@ pub fn main() {
     if !args.is_empty() {
         for find_cmd(*args.head()).each |command| {
             let result = do_command(command, args.tail());
-            match result {
-                Valid(exit_code) => unsafe { exit(exit_code.to_i32()) },
-                _                => loop
-            }
+            if result.is_valid() { return; }
         }
     }
 

branches/snap-stage3/src/librustc/front/config.rs

@@ -136,10 +136,8 @@ fn fold_block(
 ) -> ast::blk_ {
     let filtered_stmts =
         b.stmts.filter_mapped(|a| filter_stmt(cx, *a));
-    let filtered_view_items =
-        b.view_items.filter_mapped(|a| filter_view_item(cx, *a));
     ast::blk_ {
-        view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)),
+        view_items: /*bad*/copy b.view_items,
         stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
         expr: b.expr.map(|x| fld.fold_expr(*x)),
         id: b.id,

branches/snap-stage3/src/libstd/unstable/atomics.rs

@@ -17,23 +17,23 @@ use cast;
 use option::{Option,Some,None};
 
 pub struct AtomicFlag {
-    priv v:int
+    priv v: int
 }
 
 pub struct AtomicBool {
-    priv v:uint
+    priv v: uint
 }
 
 pub struct AtomicInt {
-    priv v:int
+    priv v: int
 }
 
 pub struct AtomicUint {
-    priv v:uint
+    priv v: uint
 }
 
 pub struct AtomicPtr<T> {
-    priv p:~T
+    priv p: *mut T
 }
 
 pub enum Ordering {
@@ -173,60 +173,28 @@ impl AtomicUint {
 }
 
 impl<T> AtomicPtr<T> {
-    fn new(p:~T) -> AtomicPtr<T> {
+    fn new(p:*mut T) -> AtomicPtr<T> {
         AtomicPtr { p:p }
     }
 
-    /**
-     * Atomically swaps the stored pointer with the one given.
-     *
-     * Returns None if the pointer stored has been taken
-     */
     #[inline(always)]
-    fn swap(&mut self, ptr:~T, order:Ordering) -> Option<~T> {
-        unsafe {
-            let p = atomic_swap(&mut self.p, ptr, order);
-            let pv : &uint = cast::transmute(&p);
-
-            if *pv == 0 {
-                None
-            } else {
-                Some(p)
-            }
-        }
+    fn load(&self, order:Ordering) -> *mut T {
+        unsafe { atomic_load(&self.p, order) }
     }
 
-    /**
-     * Atomically takes the stored pointer out.
-     *
-     * Returns None if it was already taken.
-     */
     #[inline(always)]
-    fn take(&mut self, order:Ordering) -> Option<~T> {
-        unsafe { self.swap(cast::transmute(0), order) }
+    fn store(&mut self, ptr:*mut T, order:Ordering) {
+        unsafe { atomic_store(&mut self.p, ptr, order); }
     }
 
-    /**
-     * Atomically stores the given pointer, this will overwrite
-     * and previous value stored.
-     */
     #[inline(always)]
-    fn give(&mut self, ptr:~T, order:Ordering) {
-        let _ = self.swap(ptr, order);
+    fn swap(&mut self, ptr:*mut T, order:Ordering) -> *mut T {
+        unsafe { atomic_swap(&mut self.p, ptr, order) }
     }
 
-    /**
-     * Checks to see if the stored pointer has been taken.
-     */
-    fn taken(&self, order:Ordering) -> bool {
-        unsafe {
-            let p : ~T = atomic_load(&self.p, order);
-
-            let pv : &uint = cast::transmute(&p);
-
-            cast::forget(p);
-            *pv == 0
-        }
+    #[inline(always)]
+    fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order:Ordering) -> *mut T {
+        unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
     }
 }
 

branches/snap-stage3/src/libsyntax/ext/trace_macros.rs

@@ -16,7 +16,6 @@ use ext::base::ExtCtxt;
 use ext::base;
 use parse::lexer::{new_tt_reader, reader};
 use parse::parser::Parser;
-use parse::token::keywords;
 
 pub fn expand_trace_macros(cx: @ExtCtxt,
                            sp: span,
@@ -37,9 +36,9 @@ pub fn expand_trace_macros(cx: @ExtCtxt,
         rdr.dup()
     );
 
-    if rust_parser.is_keyword(keywords::True) {
+    if rust_parser.is_keyword("true") {
         cx.set_trace_macros(true);
-    } else if rust_parser.is_keyword(keywords::False) {
+    } else if rust_parser.is_keyword("false") {
         cx.set_trace_macros(false);
     } else {
         cx.span_fatal(sp, "trace_macros! only accepts `true` or `false`")