---

yaml
---
r: 143839
b: refs/heads/try2
c: 828bfb2
h: refs/heads/master
i:
  143837: 2b98411
  143835: ca40576
  143831: 9de0edb
  143823: c0058f8
  143807: 8f39b1c
v: v3

Author: stepancheg

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 09f4c9af13e8dcd9d0bee69db61291f0ad85f266
+refs/heads/try2: 828bfb2c61aaac93325b00737362769d045b6438
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -744,7 +744,7 @@ There are several kinds of view item:
 ##### Extern mod declarations
 
 ~~~~~~~~ {.ebnf .gram}
-extern_mod_decl : "extern" "mod" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
+extern_mod_decl : "extern" "mod" ident [ '(' link_attrs ')' ] ? ;
 link_attrs : link_attr [ ',' link_attrs ] + ;
 link_attr : ident '=' literal ;
 ~~~~~~~~
@@ -755,34 +755,20 @@ as the `ident` provided in the `extern_mod_decl`.
 
 The external crate is resolved to a specific `soname` at compile time,
 and a runtime linkage requirement to that `soname` is passed to the linker for
-loading at runtime.
-The `soname` is resolved at compile time by scanning the compiler's library path
-and matching the `link_attrs` provided in the `use_decl` against any `#link` attributes that
-were declared on the external crate when it was compiled.
-If no `link_attrs` are provided,
-a default `name` attribute is assumed,
-equal to the `ident` given in the `use_decl`.
-
-Optionally, an identifier in an `extern mod` declaration may be followed by an equals sign,
-then a string literal denoting a relative path on the filesystem.
-This path should exist in one of the directories in the Rust path,
-which by default contains the `.rust` subdirectory of the current directory and each of its parents,
-as well as any directories in the colon-separated (or semicolon-separated on Windows)
-list of paths that is the `RUST_PATH` environment variable.
-The meaning of `extern mod a = "b/c/d";`, supposing that `/a` is in the RUST_PATH,
-is that the name `a` should be taken as a reference to the crate whose absolute location is
-`/a/b/c/d`.
-
-Four examples of `extern mod` declarations:
+loading at runtime. The `soname` is resolved at compile time by scanning the
+compiler's library path and matching the `link_attrs` provided in the
+`use_decl` against any `#link` attributes that were declared on the external
+crate when it was compiled. If no `link_attrs` are provided, a default `name`
+attribute is assumed, equal to the `ident` given in the `use_decl`.
+
+Three examples of `extern mod` declarations:
 
 ~~~~~~~~{.xfail-test}
 extern mod pcre (uuid = "54aba0f8-a7b1-4beb-92f1-4cf625264841");
 
 extern mod extra; // equivalent to: extern mod extra ( name = "extra" );
 
 extern mod rustextra (name = "extra"); // linking to 'extra' under another name
-
-extern mod complicated_mod = "some-file/in/the-rust/path";
 ~~~~~~~~
 
 ##### Use declarations

branches/try2/doc/tutorial-ffi.md

@@ -228,48 +228,6 @@ unsafe fn kaboom(ptr: *int) -> int { *ptr }
 
 This function can only be called from an `unsafe` block or another `unsafe` function.
 
-# Accessing foreign globals
-
-Foreign APIs often export a global variable which could do something like track
-global state. In order to access these variables, you declare them in `extern`
-blocks with the `static` keyword:
-
-~~~{.xfail-test}
-use std::libc;
-
-#[link_args = "-lreadline"]
-extern {
-    static rl_readline_version: libc::c_int;
-}
-
-fn main() {
-    println(fmt!("You have readline version %d installed.",
-                 rl_readline_version as int));
-}
-~~~
-
-Alternatively, you may need to alter global state provided by a foreign
-interface. To do this, statics can be declared with `mut` so rust can mutate
-them.
-
-~~~{.xfail-test}
-use std::libc;
-use std::ptr;
-
-#[link_args = "-lreadline"]
-extern {
-    static mut rl_prompt: *libc::c_char;
-}
-
-fn main() {
-    do "[my-awesome-shell] $".as_c_str |buf| {
-        unsafe { rl_prompt = buf; }
-        // get a line, process it
-        unsafe { rl_prompt = ptr::null(); }
-    }
-}
-~~~
-
 # Foreign calling conventions
 
 Most foreign code exposes a C ABI, and Rust uses the platform's C calling convention by default when

branches/try2/doc/tutorial-tasks.md

@@ -424,7 +424,7 @@ there is no way to "catch" the exception.
 All tasks are, by default, _linked_ to each other. That means that the fates
 of all tasks are intertwined: if one fails, so do all the others.
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::task::spawn;
 # use std::task;
 # fn do_some_work() { loop { task::yield() } }
@@ -447,7 +447,7 @@ pattern-match on a result to check whether it's an `Ok` result with an `int`
 field (representing a successful result) or an `Err` result (representing
 termination with an error).
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
@@ -490,10 +490,9 @@ proceed). Hence, you will need different _linked failure modes_.
 By default, task failure is _bidirectionally linked_, which means that if
 either task fails, it kills the other one.
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::task;
-# use std::comm::oneshot;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
+# fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 do spawn {
     do spawn {
@@ -512,12 +511,11 @@ function `task::try`, which we saw previously, uses `spawn_supervised`
 internally, with additional logic to wait for the child task to finish
 before returning. Hence:
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::comm::{stream, Chan, Port};
-# use std::comm::oneshot;
 # use std::task::{spawn, try};
 # use std::task;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
+# fn sleep_forever() { loop { task::yield() } }
 # do task::try {
 let (receiver, sender): (Port<int>, Chan<int>) = stream();
 do spawn {  // Bidirectionally linked
@@ -543,11 +541,10 @@ also fail.
 Supervised task failure propagates across multiple generations even if
 an intermediate generation has already exited:
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::task;
-# use std::comm::oneshot;
-# fn sleep_forever() { loop { let (p, c) = oneshot::<()>(); p.recv(); } }
-# fn wait_for_a_while() { for _ in range(0, 1000u) { task::yield() } }
+# fn sleep_forever() { loop { task::yield() } }
+# fn wait_for_a_while() { do 1000.times { task::yield() } }
 # do task::try::<int> {
 do task::spawn_supervised {
     do task::spawn_supervised {
@@ -563,10 +560,10 @@ fail!();  // Will kill grandchild even if child has already exited
 Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
-~~~{.xfail-test .linked-failure}
+~~~
 # use std::task;
 # fn random() -> uint { 100 }
-# fn sleep_for(i: uint) { for _ in range(0, i) { task::yield() } }
+# fn sleep_for(i: uint) { do i.times { task::yield() } }
 # do task::try::<()> {
 let (time1, time2) = (random(), random());
 do task::spawn_unlinked {
@@ -591,7 +588,7 @@ that repeatedly receives a `uint` message, converts it to a string, and sends
 the string in response.  The child terminates when it receives `0`.
 Here is the function that implements the child task:
 
-~~~{.xfail-test .linked-failure}
+~~~~
 # use extra::comm::DuplexStream;
 # use std::uint;
 fn stringifier(channel: &DuplexStream<~str, uint>) {
@@ -614,7 +611,7 @@ response itself is simply the stringified version of the received value,
 
 Here is the code for the parent task:
 
-~~~{.xfail-test .linked-failure}
+~~~~
 # use std::task::spawn;
 # use std::uint;
 # use extra::comm::DuplexStream;

branches/try2/doc/tutorial.md

@@ -1305,7 +1305,7 @@ match crayons[0] {
 A vector can be destructured using pattern matching:
 
 ~~~~
-let numbers: [int, ..3] = [1, 2, 3];
+let numbers: &[int] = &[1, 2, 3];
 let score = match numbers {
     [] => 0,
     [a] => a * 10,
@@ -1894,7 +1894,7 @@ struct TimeBomb {
 
 impl Drop for TimeBomb {
     fn drop(&self) {
-        for _ in range(0, self.explosivity) {
+        do self.explosivity.times {
             println("blam!");
         }
     }
@@ -2288,8 +2288,8 @@ pub mod farm {
     }
 
     impl Farm {
-        fn feed_chickens(&self) { ... }
-        fn feed_cows(&self) { ... }
+        priv fn feed_chickens(&self) { ... }
+        priv fn feed_cows(&self) { ... }
         pub fn add_chicken(&self, c: Chicken) { ... }
     }
 

branches/try2/mk/install.mk

@@ -199,7 +199,7 @@ endef
 $(foreach target,$(CFG_TARGET_TRIPLES), \
   $(if $(findstring $(target),"arm-linux-androideabi"), \
     $(if $(findstring adb,$(CFG_ADB)), \
-      $(if $(findstring device,$(shell $(CFG_ADB) devices 2>/dev/null | grep -E '^[_A-Za-z0-9-]+[[:blank:]]+device')), \
+      $(if $(findstring device,$(shell adb devices 2>/dev/null | grep -E '^[_A-Za-z0-9-]+[[:blank:]]+device')), \
         $(info install: install-runtime-target for $(target) enabled \
           $(info install: android device attached) \
           $(eval $(call DEF_ADB_DEVICE_STATUS, true))), \

branches/try2/mk/rt.mk

@@ -66,21 +66,30 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/timer.cpp \
               rt/sync/lock_and_signal.cpp \
               rt/sync/rust_thread.cpp \
+              rt/rust.cpp \
               rt/rust_builtin.cpp \
               rt/rust_run_program.cpp \
               rt/rust_env.cpp \
               rt/rust_rng.cpp \
+              rt/rust_sched_loop.cpp \
+              rt/rust_sched_launcher.cpp \
+              rt/rust_sched_driver.cpp \
+              rt/rust_scheduler.cpp \
+              rt/rust_sched_reaper.cpp \
+              rt/rust_task.cpp \
               rt/rust_stack.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
               rt/rust_crate_map.cpp \
+              rt/rust_log.cpp \
               rt/rust_gc_metadata.cpp \
               rt/rust_util.cpp \
-              rt/rust_log.cpp \
               rt/rust_exchange_alloc.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
+              rt/rust_kernel.cpp \
               rt/rust_abi.cpp \
+              rt/rust_debug.cpp \
               rt/memory_region.cpp \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \

branches/try2/mk/tests.mk

@@ -123,7 +123,7 @@ endef
 $(foreach target,$(CFG_TARGET_TRIPLES), \
   $(if $(findstring $(target),"arm-linux-androideabi"), \
     $(if $(findstring adb,$(CFG_ADB)), \
-      $(if $(findstring device,$(shell $(CFG_ADB) devices 2>/dev/null | grep -E '^[_A-Za-z0-9-]+[[:blank:]]+device')), \
+      $(if $(findstring device,$(shell adb devices 2>/dev/null | grep -E '^[_A-Za-z0-9-]+[[:blank:]]+device')), \
         $(info check: $(target) test enabled \
           $(info check: android device attached) \
           $(eval $(call DEF_ADB_DEVICE_STATUS, true))), \
@@ -348,9 +348,7 @@ $(3)/stage$(1)/test/rustpkgtest-$(2)$$(X_$(2)):					\
 		$$(RUSTPKG_LIB) $$(RUSTPKG_INPUTS)		\
 		$$(SREQ$(1)_T_$(2)_H_$(3)) \
 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX_$(2)) \
-		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2)) \
-		$$(TBIN$(1)_T_$(2)_H_$(3))/rustpkg$$(X_$(2)) \
-		$$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X_$(2))
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 

branches/try2/src/compiletest/compiletest.rs

@@ -109,8 +109,8 @@ pub fn parse_config(args: ~[~str]) -> config {
         compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
         run_lib_path: getopts::opt_str(matches, "run-lib-path"),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: getopts::opt_maybe_str(matches, "clang-path").map_move(|s| Path(s)),
-        llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map_move(|s| Path(s)),
+        clang_path: getopts::opt_maybe_str(matches, "clang-path").map(|s| Path(*s)),
+        llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map(|s| Path(*s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
@@ -123,14 +123,14 @@ pub fn parse_config(args: ~[~str]) -> config {
             } else {
                 None
             },
-        logfile: getopts::opt_maybe_str(matches, "logfile").map_move(|s| Path(s)),
-        save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map_move(|s| Path(s)),
+        logfile: getopts::opt_maybe_str(matches, "logfile").map(|s| Path(*s)),
+        save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map(|s| Path(*s)),
         ratchet_metrics:
-            getopts::opt_maybe_str(matches, "ratchet-metrics").map_move(|s| Path(s)),
+            getopts::opt_maybe_str(matches, "ratchet-metrics").map(|s| Path(*s)),
         ratchet_noise_percent:
             getopts::opt_maybe_str(matches,
-                                   "ratchet-noise-percent").map_move(|s|
-                                                                     f64::from_str(s).unwrap()),
+                                   "ratchet-noise-percent").map(|s|
+                                                                f64::from_str(*s).unwrap()),
         runtool: getopts::opt_maybe_str(matches, "runtool"),
         rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
         jit: getopts::opt_present(matches, "jit"),

branches/try2/src/compiletest/header.rs

@@ -142,7 +142,7 @@ fn parse_check_line(line: &str) -> Option<~str> {
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
     do parse_name_value_directive(line, ~"exec-env").map |nv| {
         // nv is either FOO or FOO=BAR
-        let mut strs: ~[~str] = nv.splitn_iter('=', 1).map(|s| s.to_owned()).collect();
+        let mut strs: ~[~str] = nv.splitn_iter('=', 1).transform(|s| s.to_owned()).collect();
 
         match strs.len() {
           1u => (strs.pop(), ~""),

branches/try2/src/compiletest/runtest.rs

@@ -162,8 +162,9 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
         round += 1;
     }
 
-    let mut expected = match props.pp_exact {
-        Some(ref file) => {
+    let mut expected =
+        match props.pp_exact {
+          Some(ref file) => {
             let filepath = testfile.dir_path().push_rel(file);
             io::read_whole_file_str(&filepath).unwrap()
           }
@@ -350,13 +351,13 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         fatal(~"process did not return an error status");
     }
 
-    let prefixes = expected_errors.iter().map(|ee| {
+    let prefixes = expected_errors.iter().transform(|ee| {
         fmt!("%s:%u:", testfile.to_str(), ee.line)
     }).collect::<~[~str]>();
 
     fn to_lower( s : &str ) -> ~str {
         let i = s.iter();
-        let c : ~[char] = i.map( |c| {
+        let c : ~[char] = i.transform( |c| {
             if c.is_ascii() {
                 c.to_ascii().to_lower().to_char()
             } else {
@@ -412,8 +413,8 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         }
     }
 
-    for (i, &flag) in found_flags.iter().enumerate() {
-        if !flag {
+    for i in range(0u, found_flags.len()) {
+        if !found_flags[i] {
             let ee = &expected_errors[i];
             fatal_ProcRes(fmt!("expected %s on line %u not found: %s",
                                ee.kind, ee.line, ee.msg), ProcRes);
@@ -760,7 +761,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     let cmdline = make_cmdline("", args.prog, args.args);
 
     // get bare program string
-    let mut tvec: ~[~str] = args.prog.split_iter('/').map(|ts| ts.to_owned()).collect();
+    let mut tvec: ~[~str] = args.prog.split_iter('/').transform(|ts| ts.to_owned()).collect();
     let prog_short = tvec.pop();
 
     // copy to target
@@ -938,7 +939,7 @@ fn disassemble_extract(config: &config, _props: &TestProps,
 
 fn count_extracted_lines(p: &Path) -> uint {
     let x = io::read_whole_file_str(&p.with_filetype("ll")).unwrap();
-    x.line_iter().len()
+    x.line_iter().len_()
 }
 
 

branches/try2/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -50,7 +50,6 @@
 		<keyword>for</keyword>
 		<keyword>if</keyword>
 		<keyword>impl</keyword>
-		<keyword>in</keyword>
 		<keyword>let</keyword>
 		<keyword>log</keyword>
 		<keyword>loop</keyword>