---

yaml
---
r: 11390
b: refs/heads/master
c: 9691ce1
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3c95fa22daf157d8e2d07b20e66f9888de60681a
+refs/heads/master: 9691ce18a2674e322be4b2e8f2e44888eb957170
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/tutorial.md

@@ -2375,10 +2375,10 @@ module `task`.  Let's begin with the simplest one, `task::spawn()`:
 
 ~~~~
 let some_value = 22;
-let child_task = task::spawn {||
+task::spawn {||
     std::io::println("This executes in the child task.");
     std::io::println(#fmt("%d", some_value));
-};
+}
 ~~~~
 
 The argument to `task::spawn()` is a [unique
@@ -2456,70 +2456,66 @@ let result = comm::recv(port);
 ## Creating a task with a bi-directional communication path
 
 A very common thing to do is to spawn a child task where the parent
-and child both need to exchange messages with each other. The function
-`task::spawn_connected()` supports this pattern. We'll look briefly at
-how it is used.
+and child both need to exchange messages with each
+other. The function `task::spawn_listener()` supports this pattern. We'll look
+briefly at how it is used.
 
-To see how `spawn_connected()` works, we will create a child task
+To see how `spawn_listener()` works, we will create a child task
 which receives `uint` messages, converts them to a string, and sends
 the string in response.  The child terminates when `0` is received.
 Here is the function which implements the child task:
 
 ~~~~
-fn stringifier(from_par: comm::port<uint>,
-               to_par: comm::chan<str>) {
+fn stringifier(from_parent: comm::port<uint>,
+               to_parent: comm::chan<str>) {
     let value: uint;
     do {
-        value = comm::recv(from_par);
-        comm::send(to_par, uint::to_str(value, 10u));
+        value = comm::recv(from_parent);
+        comm::send(to_parent, uint::to_str(value, 10u));
     } while value != 0u;
 }
 
 ~~~~
+
 You can see that the function takes two parameters.  The first is a
 port used to receive messages from the parent, and the second is a
 channel used to send messages to the parent.  The body itself simply
 loops, reading from the `from_par` port and then sending its response
 to the `to_par` channel.  The actual response itself is simply the
 strified version of the received value, `uint::to_str(value)`.
-
+ 
 Here is the code for the parent task:
+
 ~~~~
-# fn stringifier(from_par: comm::port<uint>,
-#                to_par: comm::chan<str>) {
-#     comm::send(to_par, "22");
-#     comm::send(to_par, "23");
-#     comm::send(to_par, "0");
+# fn stringifier(from_parent: comm::port<uint>,
+#                to_parent: comm::chan<str>) {
+#     comm::send(to_parent, "22");
+#     comm::send(to_parent, "23");
+#     comm::send(to_parent, "0");
 # }
 fn main() {
-    let t = task::spawn_connected(stringifier);
-    comm::send(t.to_child, 22u);
-    assert comm::recv(t.from_child) == "22";
-    comm::send(t.to_child, 23u);
-    assert comm::recv(t.from_child) == "23";
-    comm::send(t.to_child, 0u);
-    assert comm::recv(t.from_child) == "0";
-}
-~~~~
-
-The call to `spawn_connected()` on the first line will instantiate the
-various ports and channels and startup the child task.  The returned
-value, `t`, is a record of type `task::connected_task<uint,str>`.  In
-addition to the task id of the child, this record defines two fields,
-`from_child` and `to_child`, which contain the port and channel
-respectively for communicating with the child.  Those fields are used
-here to send and receive three messages from the child task.
-
-## Joining a task
-
-The function `spawn_joinable()` is used to spawn a task that can later
-be joined. This is implemented by having the child task send a message
-when it has completed (either successfully or by failing). Therefore,
-`spawn_joinable()` returns a structure containing both the task ID and
-the port where this message will be sent---this structure type is
-called `task::joinable_task`. The structure can be passed to
-`task::join()`, which simply blocks on the port, waiting to receive
-the message from the child task.
+    let from_child = comm::port();
+    let to_parent = comm::chan(from_child);
+    let to_child = task::spawn_listener {|from_parent|
+        stringifier(from_parent, to_parent);
+    };
+    comm::send(to_child, 22u);
+    assert comm::recv(from_child) == "22";
+    comm::send(to_child, 23u);
+    assert comm::recv(from_child) == "23";
+    comm::send(to_child, 0u);
+    assert comm::recv(from_child) == "0";
+}
+~~~~
+
+The parent first sets up a port to receive data from and a channel
+that the child can use to send data to that port. The call to
+`spawn_listener()` will spawn the child task, providing it with a port
+on which to receive data from its parent, and returning to the parent
+the associated channel. Finally, the closure passed to
+`spawn_listener()` that forms the body of the child task captures the
+`to_parent` channel in its environment, so both parent and child
+can send and receive data to and from the other.
 
 ## The supervisor relationship
 

trunk/mk/tests.mk

@@ -104,7 +104,7 @@ endif
 # Extracting tests for docs
 ######################################################################
 
-EXTRACT_TESTS := "$(CFG_PYTHON)" $(S)src/etc/extract-tests.py
+EXTRACT_TESTS := $(CFG_PYTHON) $(S)src/etc/extract-tests.py
 
 define DEF_DOC_TEST_HOST
 

trunk/src/cargo/cargo.rs

@@ -6,7 +6,7 @@ use std;
 import rustc::syntax::{ast, codemap};
 import rustc::syntax::parse::parser;
 import rustc::util::filesearch::{get_cargo_root, get_cargo_root_nearest,
-                                 get_cargo_sysroot};
+                                 get_cargo_sysroot, libdir};
 import rustc::driver::diagnostic;
 
 import std::fs;
@@ -346,39 +346,35 @@ fn build_cargo_options(argv: [str]) -> options {
     };
 
     let test = opt_present(match, "test");
-    let mode = if opt_present(match, "G") {
-        if opt_present(match, "mode") { fail "--mode and -G both provided"; }
-        if opt_present(match, "g") { fail "-G and -g both provided"; }
-        system_mode
-    } else if opt_present(match, "g") {
-        if opt_present(match, "mode") { fail "--mode and -g both provided"; }
-        if opt_present(match, "G") { fail "-G and -g both provided"; }
-        user_mode
-    } else if opt_present(match, "mode") {
-        alt getopts::opt_str(match, "mode") {
-            "system" { system_mode }
-            "user" { user_mode }
-            "local" { local_mode }
-            _ { fail "argument to `mode` must be one of `system`" +
-                ", `user`, or `normal`";
+    let G = opt_present(match, "G");
+    let g = opt_present(match, "g");
+    let m = opt_present(match, "mode");
+    let is_install = vec::len(match.free) > 1u && match.free[1] == "install";
+
+    if G && g { fail "-G and -g both provided"; }
+    if g && m { fail "--mode and -g both provided"; }
+    if G && m { fail "--mode and -G both provided"; }
+
+    let mode = if is_install {
+        if G { system_mode }
+        else if g { user_mode }
+        else if m {
+            alt getopts::opt_str(match, "mode") {
+                "system" { system_mode }
+                "user" { user_mode }
+                "local" { local_mode }
+                _ { fail "argument to `mode` must be one of `system`" +
+                    ", `user`, or `local`";
+                }
             }
-        }
-    } else {
-        local_mode
-    };
-
-    if mode == system_mode {
-        // FIXME: Per discussion on #1760, we need to think about how
-        // system mode works. It should install files to the normal
-        // sysroot paths, but it also needsd an area to place various
-        // cargo configuration and work files.
-        fail "system mode does not exist yet";
-    }
+        } else { local_mode }
+    } else { system_mode };
 
     {test: test, mode: mode, free: match.free}
 }
 
 fn configure(opts: options) -> cargo {
+    let syscargo = result::get(get_cargo_sysroot());
     let get_cargo_dir = alt opts.mode {
         system_mode { get_cargo_sysroot }
         user_mode { get_cargo_root }
@@ -391,15 +387,15 @@ fn configure(opts: options) -> cargo {
     };
 
     let sources = map::new_str_hash::<source>();
-    try_parse_sources(fs::connect(p, "sources.json"), sources);
-    try_parse_sources(fs::connect(p, "local-sources.json"), sources);
+    try_parse_sources(fs::connect(syscargo, "sources.json"), sources);
+    try_parse_sources(fs::connect(syscargo, "local-sources.json"), sources);
     let c = {
         pgp: pgp::supported(),
         root: p,
         bindir: fs::connect(p, "bin"),
         libdir: fs::connect(p, "lib"),
         workdir: fs::connect(p, "work"),
-        sourcedir: fs::connect(p, "sources"),
+        sourcedir: fs::connect(syscargo, "sources"),
         sources: sources,
         opts: opts
     };
@@ -471,10 +467,31 @@ fn install_one_crate(c: cargo, _path: str, cf: str, _p: pkg) {
             #debug("  bin: %s", ct);
             // FIXME: need libstd fs::copy or something
             run::run_program("cp", [ct, c.bindir]);
+            if c.opts.mode == system_mode {
+                install_one_crate_to_sysroot(ct, "bin");
+            }
         } else {
             #debug("  lib: %s", ct);
             run::run_program("cp", [ct, c.libdir]);
+            if c.opts.mode == system_mode {
+                install_one_crate_to_sysroot(ct, libdir());
+            }
+        }
+    }
+}
+
+fn install_one_crate_to_sysroot(ct: str, target: str) {
+    alt os::get_exe_path() {
+        some(_path) {
+            let path = [_path, "..", target];
+            check vec::is_not_empty(path);
+            let target_dir = fs::normalize(fs::connect_many(path));
+            let p = run::program_output("cp", [ct, target_dir]);
+            if p.status != 0 {
+                warn(#fmt["Copying %s to %s is failed", ct, target_dir]);
+            }
         }
+        none { }
     }
 }
 
@@ -831,23 +848,25 @@ fn cmd_usage() {
           "
 
     init                                          Set up .cargo
-    install [--test] [source/]package-name        Install by name
-    install [--test] uuid:[source/]package-uuid   Install by uuid
+    install [options] [source/]package-name       Install by name
+    install [options] uuid:[source/]package-uuid  Install by uuid
     list [source]                                 List packages
     search <name | '*'> [tags...]                 Search packages
     sync                                          Sync all sources
     usage                                         This
 
 Options:
 
+  cargo install
+
     --mode=[system,user,local]   change mode as (system/user/local)
     -g                           equivalent to --mode=user
     -G                           equivalent to --mode=system
 
 NOTE:
-This command creates/uses local-level .cargo by default.
-To create/use user-level .cargo, use option -g/--mode=user.
-To create/use system-level .cargo, use option -G/--mode=system.
+\"cargo install\" installs bin/libs to local-level .cargo by default.
+To install them into user-level .cargo,  use option -g/--mode=user.
+To install them into bin/lib on sysroot, use option -G/--mode=system.
 ");
 }
 

trunk/src/comp/driver/rustc.rs

@@ -143,8 +143,6 @@ fn monitor(f: fn~(diagnostic::emitter)) {
 
     alt task::try  {||
 
-        task::unsupervise();
-
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
         let demitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>,