---

yaml
---
r: 62804
b: refs/heads/snap-stage3
c: ff86830
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6861d542a2ab3c8eca58a64bd6b93f067427e1bb
+refs/heads/snap-stage3: ff86830c9c2c0e4e88070206bd73f88ad7141b1e
 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/Makefile.in

@@ -275,7 +275,7 @@ DRIVER_CRATE := $(S)src/driver/driver.rs
 
 # FIXME: x86-ism
 LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit \
-                interpreter instrumentation
+                interpreter
 
 define DEF_LLVM_VARS
 # The configure script defines these variables with the target triples

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/doc/tutorial-tasks.md

@@ -284,7 +284,7 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() );
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 
-## Backgrounding computations: Futures
+## Futures
 With `extra::future`, rust has a mechanism for requesting a computation and getting the result
 later.
 
@@ -329,77 +329,6 @@ fn main() {
 }
 ~~~
 
-## Sharing immutable data without copy: ARC
-
-To share immutable data between tasks, a first approach would be to only use pipes as we have seen
-previously. A copy of the data to share would then be made for each task. In some cases, this would
-add up to a significant amount of wasted memory and would require copying the same data more than
-necessary.
-
-To tackle this issue, one can use an Atomically Reference Counted wrapper (`ARC`) as implemented in
-the `extra` library of Rust. With an ARC, the data will no longer be copied for each task. The ARC
-acts as a reference to the shared data and only this reference is shared and cloned.
-
-Here is a small example showing how to use ARCs. We wish to run concurrently several computations on
-a single large vector of floats. Each task needs the full vector to perform its duty.
-~~~
-use extra::arc::ARC;
-
-fn pnorm(nums: &~[float], p: uint) -> float {
-    (vec::foldl(0.0, *nums, |a,b| a+(*b).pow(p as float) )).pow(1f / (p as float))
-}
-
-fn main() {
-    let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-    println(fmt!("Inf-norm = %?",  numbers.max()));
-
-    let numbers_arc = ARC(numbers);
-
-    for uint::range(1,10) |num| {
-        let (port, chan)  = stream();
-        chan.send(numbers_arc.clone());
-
-        do spawn {
-            let local_arc : ARC<~[float]> = port.recv();
-            let task_numbers = local_arc.get();
-            println(fmt!("%u-norm = %?", num, pnorm(task_numbers, num)));
-        }
-    }
-}
-~~~
-
-The function `pnorm` performs a simple computation on the vector (it computes the sum of its items
-at the power given as argument and takes the inverse power of this value). The ARC on the vector is
-created by the line
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-let numbers_arc=ARC(numbers);
-~~~
-and a clone of it is sent to each task
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-# let numbers_arc = ARC(numbers);
-# let (port, chan)  = stream();
-chan.send(numbers_arc.clone());
-~~~
-copying only the wrapper and not its contents.
-
-Each task recovers the underlying data by
-~~~
-# use extra::arc::ARC;
-# let numbers=vec::from_fn(1000000, |_| rand::random::<float>());
-# let numbers_arc=ARC(numbers);
-# let (port, chan)  = stream();
-# chan.send(numbers_arc.clone());
-# let local_arc : ARC<~[float]> = port.recv();
-let task_numbers = local_arc.get();
-~~~
-and can use it as if it were local.
-
-The `arc` module also implements ARCs around mutable data that are not covered here.
-
 # Handling task failure
 
 Rust has a built-in mechanism for raising exceptions. The `fail!()` macro

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/mk/rustllvm.mk

@@ -22,7 +22,7 @@ LLVM_EXTRA_INCDIRS_$(1)= -iquote $(S)src/llvm/include \
                          -iquote llvm/$(1)/include
 endif
 
-RUSTLLVM_OBJS_CS_$(1) := $$(addprefix rustllvm/, RustWrapper.cpp PassWrapper.cpp)
+RUSTLLVM_OBJS_CS_$(1) := $$(addprefix rustllvm/, RustWrapper.cpp)
 
 RUSTLLVM_DEF_$(1) := rustllvm/rustllvm$(CFG_DEF_SUFFIX_$(1))
 

branches/snap-stage3/mk/target.mk

@@ -8,6 +8,11 @@
 # option. This file may not be copied, modified, or distributed
 # except according to those terms.
 
+# This is the compile-time target-triple for the compiler. For the compiler at
+# runtime, this should be considered the host-triple. More explanation for why
+# this exists can be found on issue #2400
+export CFG_COMPILER_TRIPLE
+
 # TARGET_STAGE_N template: This defines how target artifacts are built
 # for all stage/target architecture combinations. The arguments:
 # $(1) is the stage
@@ -62,6 +67,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUSTLLVM_$(3)): \
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
+$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)): CFG_COMPILER_TRIPLE = $(2)
 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)):		\
 		$$(COMPILER_CRATE) $$(COMPILER_INPUTS)		\
                 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3)) \

branches/snap-stage3/mk/tests.mk

@@ -284,7 +284,7 @@ define TEST_RUNNER
 # If NO_REBUILD is set then break the dependencies on extra so we can
 # test crates without rebuilding std and extra first
 ifeq ($(NO_REBUILD),)
-STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_EXTRALIB_$(2))
+STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 else
 STDTESTDEP_$(1)_$(2)_$(3) =
 endif
@@ -307,6 +307,7 @@ $(3)/stage$(1)/test/syntaxtest-$(2)$$(X_$(2)):			\
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
+$(3)/stage$(1)/test/rustctest-$(2)$$(X_$(2)): CFG_COMPILER_TRIPLE = $(2)
 $(3)/stage$(1)/test/rustctest-$(2)$$(X_$(2)):					\
 		$$(COMPILER_CRATE) $$(COMPILER_INPUTS) \
 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM_$(2)) \

branches/snap-stage3/src/compiletest/procsrv.rs

@@ -10,6 +10,8 @@
 
 use core::prelude::*;
 
+use core::libc::c_int;
+use core::run::spawn_process;
 use core::run;
 
 #[cfg(target_os = "win32")]
@@ -36,35 +38,86 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
 fn target_env(_lib_path: &str, _prog: &str) -> ~[(~str,~str)] {
-    os::env()
+    ~[]
 }
 
 pub struct Result {status: int, out: ~str, err: ~str}
 
+// FIXME (#2659): This code is duplicated in core::run::program_output
 pub fn run(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
            input: Option<~str>) -> Result {
+    let pipe_in = os::pipe();
+    let pipe_out = os::pipe();
+    let pipe_err = os::pipe();
+    let pid = spawn_process(prog, args,
+                            &Some(env + target_env(lib_path, prog)),
+                            &None, pipe_in.in, pipe_out.out, pipe_err.out);
+
+    os::close(pipe_in.in);
+    os::close(pipe_out.out);
+    os::close(pipe_err.out);
+    if pid == -1i32 {
+        os::close(pipe_in.out);
+        os::close(pipe_out.in);
+        os::close(pipe_err.in);
+        fail!();
+    }
 
-    let env = env + target_env(lib_path, prog);
-    let mut proc = run::Process::new(prog, args, run::ProcessOptions {
-        env: Some(env.slice(0, env.len())),
-        dir: None,
-        in_fd: None,
-        out_fd: None,
-        err_fd: None
-    });
 
-    for input.each |input| {
-        proc.input().write_str(*input);
+    writeclose(pipe_in.out, input);
+    let p = comm::PortSet::new();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let errput = readclose(pipe_err.in);
+        ch.send((2, errput));
     }
-    let output = proc.finish_with_output();
+    let ch = p.chan();
+    do task::spawn_sched(task::SingleThreaded) || {
+        let output = readclose(pipe_out.in);
+        ch.send((1, output));
+    }
+    let status = run::waitpid(pid);
+    let mut errs = ~"";
+    let mut outs = ~"";
+    let mut count = 2;
+    while count > 0 {
+        match p.recv() {
+          (1, s) => {
+            outs = s;
+          }
+          (2, s) => {
+            errs = s;
+          }
+          _ => { fail!() }
+        };
+        count -= 1;
+    };
+    return Result {status: status, out: outs, err: errs};
+}
 
-    Result {
-        status: output.status,
-        out: str::from_bytes(output.output),
-        err: str::from_bytes(output.error)
+fn writeclose(fd: c_int, s: Option<~str>) {
+    if s.is_some() {
+        let writer = io::fd_writer(fd, false);
+        writer.write_str(s.get());
     }
+
+    os::close(fd);
 }
 
+fn readclose(fd: c_int) -> ~str {
+    unsafe {
+        // Copied from run::program_output
+        let file = os::fdopen(fd);
+        let reader = io::FILE_reader(file, false);
+        let mut buf = ~"";
+        while !reader.eof() {
+            let bytes = reader.read_bytes(4096u);
+            str::push_str(&mut buf, str::from_bytes(bytes));
+        }
+        os::fclose(file);
+        return buf;
+    }
+}

branches/snap-stage3/src/etc/ctags.rust

@@ -4,7 +4,9 @@
 --regex-rust=/[ \t]*type[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*enum[ \t]+([a-zA-Z0-9_]+)/\1/T,types/
 --regex-rust=/[ \t]*struct[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
+--regex-rust=/[ \t]*class[ \t]+([a-zA-Z0-9_]+)/\1/m,types/
 --regex-rust=/[ \t]*mod[ \t]+([a-zA-Z0-9_]+)/\1/m,modules/
---regex-rust=/[ \t]*static[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
+--regex-rust=/[ \t]*const[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
 --regex-rust=/[ \t]*trait[ \t]+([a-zA-Z0-9_]+)/\1/m,traits/
 --regex-rust=/[ \t]*impl[ \t]+([a-zA-Z0-9_]+)/\1/m,impls/
+--regex-rust=/[ \t]*impl[ \t]+of[ \t]([a-zA-Z0-9_]+)/\1/m,impls/

branches/snap-stage3/src/etc/vim/after/ftplugin/rust.vim

@@ -0,0 +1,5 @@
+"Highlight the 100th text column
+"Feature became available in v7.3
+if version >= 703
+    setlocal colorcolumn=100
+endif

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

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without ARC, a copy would have to be made for each task.
  *
- * ~~~ {.rust}
+ * ~~~
  * extern mod std;
  * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -370,10 +370,7 @@ pub impl<T:Const + Owned> RWARC<T> {
      * See sync::rwlock.write_downgrade(). The RWWriteMode token must be used
      * to obtain the &mut T, and can be transformed into a RWReadMode token by
      * calling downgrade(), after which a &T can be obtained instead.
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
+     * ~~~
      * do arc.write_downgrade |write_mode| {
      *     do (&write_mode).write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
@@ -510,6 +507,7 @@ mod tests {
     use core::prelude::*;
     use core::cell::Cell;
     use arc::*;
+    use arc;
 
     #[test]
     fn manually_share_arc() {