---

yaml
---
r: 50941
b: refs/heads/try
c: 057c40d
h: refs/heads/master
i:
  50939: dbcb710
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: ef282dbe2af9c6afc89776df177a750a1784853a
+refs/heads/try: 057c40d5bd3dc700af7d99a2dfeba0fe6c2ba119
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/Makefile.in

@@ -238,7 +238,7 @@ $(foreach target,$(CFG_TARGET_TRIPLES),\
 
 CORELIB_CRATE := $(S)src/libcore/core.rc
 CORELIB_INPUTS := $(wildcard $(addprefix $(S)src/libcore/,        \
-                                           core.rc *.rs */*.rs */*/*rs))
+                                           core.rc *.rs */*.rs))
 
 ######################################################################
 # Standard library variables

branches/try/mk/tests.mk

@@ -244,29 +244,21 @@ $(foreach host,$(CFG_HOST_TRIPLES), \
 
 define TEST_RUNNER
 
-# If NO_REBUILD is set then break the dependencies on std so we can
-# test crates without rebuilding core and std first
-ifeq ($(NO_REBUILD),)
-STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
-else
-STDTESTDEP_$(1)_$(2)_$(3) =
-endif
-
 $(3)/test/coretest.stage$(1)-$(2)$$(X_$(2)):			\
 		$$(CORELIB_CRATE) $$(CORELIB_INPUTS)	\
-		$$(STDTESTDEP_$(1)_$(2)_$(3))
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
 $(3)/test/stdtest.stage$(1)-$(2)$$(X_$(2)):			\
 		$$(STDLIB_CRATE) $$(STDLIB_INPUTS)	\
-		$$(STDTESTDEP_$(1)_$(2)_$(3))
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
 $(3)/test/syntaxtest.stage$(1)-$(2)$$(X_$(2)):			\
 		$$(LIBSYNTAX_CRATE) $$(LIBSYNTAX_INPUTS)	\
-		$$(STDTESTDEP_$(1)_$(2)_$(3))
+		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 

branches/try/src/compiletest/common.rs

@@ -63,9 +63,6 @@ pub struct config {
     // Run tests using the JIT
     jit: bool,
 
-    // Run tests using the new runtime
-    newrt: bool,
-
     // Explain what's going on
     verbose: bool
 

branches/try/src/compiletest/compiletest.rc

@@ -61,8 +61,7 @@ pub fn parse_config(args: ~[~str]) -> config {
           getopts::optopt(~"runtool"), getopts::optopt(~"rustcflags"),
           getopts::optflag(~"verbose"),
           getopts::optopt(~"logfile"),
-          getopts::optflag(~"jit"),
-          getopts::optflag(~"newrt")];
+          getopts::optflag(~"jit")];
 
     fail_unless!(!args.is_empty());
     let args_ = vec::tail(args);
@@ -96,7 +95,6 @@ pub fn parse_config(args: ~[~str]) -> config {
         runtool: getopts::opt_maybe_str(matches, ~"runtool"),
         rustcflags: getopts::opt_maybe_str(matches, ~"rustcflags"),
         jit: getopts::opt_present(matches, ~"jit"),
-        newrt: getopts::opt_present(matches, ~"newrt"),
         verbose: getopts::opt_present(matches, ~"verbose")
     }
 }
@@ -116,7 +114,6 @@ pub fn log_config(config: config) {
     logv(c, fmt!("runtool: %s", opt_str(config.runtool)));
     logv(c, fmt!("rustcflags: %s", opt_str(config.rustcflags)));
     logv(c, fmt!("jit: %b", config.jit));
-    logv(c, fmt!("newrt: %b", config.newrt));
     logv(c, fmt!("verbose: %b", config.verbose));
     logv(c, fmt!("\n"));
 }

branches/try/src/compiletest/runtest.rs

@@ -484,17 +484,9 @@ fn compile_test_(config: config, props: TestProps,
 
 fn exec_compiled_test(config: config, props: TestProps,
                       testfile: &Path) -> ProcRes {
-
-    // If testing the new runtime then set the RUST_NEWRT env var
-    let env = if config.newrt {
-        props.exec_env + ~[(~"RUST_NEWRT", ~"1")]
-    } else {
-        props.exec_env
-    };
-
     compose_and_run(config, testfile,
                     make_run_args(config, props, testfile),
-                    env,
+                    props.exec_env,
                     config.run_lib_path, None)
 }
 

branches/try/src/libcore/rt/context.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use option::*;
 use super::stack::StackSegment;
 use libc::c_void;
 use cast::{transmute, transmute_mut_unsafe,
@@ -17,30 +16,17 @@ use cast::{transmute, transmute_mut_unsafe,
 // XXX: Registers is boxed so that it is 16-byte aligned, for storing
 // SSE regs.  It would be marginally better not to do this. In C++ we
 // use an attribute on a struct.
-// XXX: It would be nice to define regs as `~Option<Registers>` since
-// the registers are sometimes empty, but the discriminant would
-// then misalign the regs again.
-pub struct Context {
-    /// The context entry point, saved here for later destruction
-    start: Option<~~fn()>,
-    /// Hold the registers while the task or scheduler is suspended
-    regs: ~Registers
-}
+pub struct Context(~Registers);
 
 pub impl Context {
     fn empty() -> Context {
-        Context {
-            start: None,
-            regs: new_regs()
-        }
+        Context(new_regs())
     }
 
     /// Create a new context that will resume execution by running ~fn()
-    fn new(start: ~fn(), stack: &mut StackSegment) -> Context {
-        // XXX: Putting main into a ~ so it's a thin pointer and can
-        // be passed to the spawn function.  Another unfortunate
-        // allocation
-        let start = ~start;
+    /// # Safety Note
+    /// The `start` closure must remain valid for the life of the Task
+    fn new(start: &~fn(), stack: &mut StackSegment) -> Context {
 
         // The C-ABI function that is the task entry point
         extern fn task_start_wrapper(f: &~fn()) { (*f)() }
@@ -54,29 +40,21 @@ pub impl Context {
         // which we will then modify to call the given function when restored
         let mut regs = new_regs();
         unsafe {
-            swap_registers(transmute_mut_region(&mut *regs), transmute_region(&*regs))
+            swap_registers(transmute_mut_region(&mut *regs),
+                           transmute_region(&*regs))
         };
 
         initialize_call_frame(&mut *regs, fp, argp, sp);
 
-        return Context {
-            start: Some(start),
-            regs: regs
-        }
+        return Context(regs);
     }
 
-    /* Switch contexts
-
-    Suspend the current execution context and resume another by
-    saving the registers values of the executing thread to a Context
-    then loading the registers from a previously saved Context.
-    */
     fn swap(out_context: &mut Context, in_context: &Context) {
         let out_regs: &mut Registers = match out_context {
-            &Context { regs: ~ref mut r, _ } => r
+            &Context(~ref mut r) => r
         };
         let in_regs: &Registers = match in_context {
-            &Context { regs: ~ref r, _ } => r
+            &Context(~ref r) => r
         };
 
         unsafe { swap_registers(out_regs, in_regs) };
@@ -106,10 +84,11 @@ fn new_regs() -> ~Registers {
 }
 
 #[cfg(target_arch = "x86")]
-fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers,
+                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
 
     let sp = align_down(sp);
-    let sp = mut_offset(sp, -4);
+    let sp = mut_offset(sp, -4); // XXX: -4 words? Needs this be done at all?
 
     unsafe { *sp = arg as uint; }
     let sp = mut_offset(sp, -1);
@@ -129,7 +108,8 @@ type Registers = [uint * 22];
 fn new_regs() -> ~Registers { ~[0, .. 22] }
 
 #[cfg(target_arch = "x86_64")]
-fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers,
+                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
 
     // Redefinitions from regs.h
     static RUSTRT_ARG0: uint = 3;
@@ -163,7 +143,8 @@ type Registers = [uint * 32];
 fn new_regs() -> ~Registers { ~[0, .. 32] }
 
 #[cfg(target_arch = "arm")]
-fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers,
+                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
     let sp = mut_offset(sp, -1);
 
     // The final return address. 0 indicates the bottom of the stack
@@ -181,7 +162,8 @@ type Registers = [uint * 32];
 fn new_regs() -> ~Registers { ~[0, .. 32] }
 
 #[cfg(target_arch = "mips")]
-fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {
+fn initialize_call_frame(regs: &mut Registers,
+                         fptr: *c_void, arg: *c_void, sp: *mut uint) {
     let sp = mut_offset(sp, -1);
 
     // The final return address. 0 indicates the bottom of the stack

branches/try/src/libcore/rt/rtio.rs renamed to branches/try/src/libcore/rt/io.rs

@@ -8,18 +8,23 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use libc::c_char;
 
 // Some basic logging
 macro_rules! rtdebug_ (
     ($( $arg:expr),+) => ( {
         dumb_println(fmt!( $($arg),+ ));
 
         fn dumb_println(s: &str) {
-            use io::WriterUtil;
-            let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
-            dbg.write_str(s);
-            dbg.write_str("\n");
+            use str::as_c_str;
+            use libc::c_char;
+
+            extern {
+                fn printf(s: *c_char);
+            }
+
+            do as_c_str(s.to_str() + "\n") |s| {
+                unsafe { printf(s); }
+            }
         }
 
     } )
@@ -31,37 +36,13 @@ macro_rules! rtdebug (
 )
 
 mod sched;
-mod rtio;
-pub mod uvll;
+mod io;
 mod uvio;
-#[path = "uv/mod.rs"]
 mod uv;
-#[path = "io/mod.rs"]
-mod io;
 // FIXME #5248: The import in `sched` doesn't resolve unless this is pub!
 pub mod thread_local_storage;
 mod work_queue;
 mod stack;
 mod context;
 mod thread;
 pub mod env;
-
-pub fn start(main: *u8, _argc: int, _argv: *c_char, _crate_map: *u8) -> int {
-    use self::sched::{Scheduler, Task};
-    use self::uvio::UvEventLoop;
-
-    let loop_ = ~UvEventLoop::new();
-    let mut sched = ~Scheduler::new(loop_);
-    let main_task = ~do Task::new(&mut sched.stack_pool) {
-        // XXX: Can't call a C function pointer from Rust yet
-        unsafe { rust_call_nullary_fn(main) };
-    };
-    sched.task_queue.push_back(main_task);
-    sched.run();
-    return 0;
-
-    extern {
-        fn rust_call_nullary_fn(f: *u8);
-    }
-}
-