---

yaml
---
r: 96916
b: refs/heads/dist-snap
c: 6aadc9d
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 49e5493587162d53a693ba7e7833edd8f1718e94
+refs/heads/dist-snap: 6aadc9d18856f8e7ea8038e2c4b2ba0f9507e26a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/io/native/file.rs renamed to branches/dist-snap/src/libnative/io/file.rs

@@ -10,28 +10,21 @@
 
 //! Blocking posix-based file I/O
 
-#[allow(non_camel_case_types)];
-
-use c_str::CString;
-use io::IoError;
-use io;
-use libc::c_int;
-use libc;
-use ops::Drop;
-use option::{Some, None, Option};
-use os;
-use path::{Path, GenericPath};
-use ptr::RawPtr;
-use result::{Result, Ok, Err};
-use rt::rtio;
+use std::c_str::CString;
+use std::io::IoError;
+use std::io;
+use std::libc::c_int;
+use std::libc;
+use std::os;
+use std::rt::rtio;
+use std::unstable::intrinsics;
+use std::vec;
+
 use super::IoResult;
-use unstable::intrinsics;
-use vec::ImmutableVector;
-use vec;
 
-#[cfg(windows)] use os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
-#[cfg(windows)] use ptr;
-#[cfg(windows)] use str;
+#[cfg(windows)] use std::os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
+#[cfg(windows)] use std::ptr;
+#[cfg(windows)] use std::str;
 
 fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
     #[cfg(windows)] static eintr: int = 0; // doesn't matter
@@ -490,8 +483,8 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
     unsafe {
         #[cfg(not(windows))]
         unsafe fn get_list(p: &CString) -> IoResult<~[Path]> {
-            use libc::{dirent_t};
-            use libc::{opendir, readdir, closedir};
+            use std::libc::{dirent_t};
+            use std::libc::{opendir, readdir, closedir};
             extern {
                 fn rust_list_dir_val(ptr: *dirent_t) -> *libc::c_char;
             }
@@ -517,14 +510,14 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
 
         #[cfg(windows)]
         unsafe fn get_list(p: &CString) -> IoResult<~[Path]> {
-            use libc::consts::os::extra::INVALID_HANDLE_VALUE;
-            use libc::{wcslen, free};
-            use libc::funcs::extra::kernel32::{
+            use std::libc::consts::os::extra::INVALID_HANDLE_VALUE;
+            use std::libc::{wcslen, free};
+            use std::libc::funcs::extra::kernel32::{
                 FindFirstFileW,
                 FindNextFileW,
                 FindClose,
             };
-            use libc::types::os::arch::extra::HANDLE;
+            use std::libc::types::os::arch::extra::HANDLE;
             use os::win32::{
                 as_utf16_p
             };
@@ -906,12 +899,12 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
 
 #[cfg(test)]
 mod tests {
-    use io::native::file::{CFile, FileDesc};
-    use io;
-    use libc;
-    use os;
-    use result::Ok;
-    use rt::rtio::RtioFileStream;
+    use std::io::native::file::{CFile, FileDesc};
+    use std::io::fs;
+    use std::io;
+    use std::libc;
+    use std::os;
+    use std::rt::rtio::RtioFileStream;
 
     #[ignore(cfg(target_os = "freebsd"))] // hmm, maybe pipes have a tiny buffer
     #[test]

branches/dist-snap/src/libstd/io/native/mod.rs renamed to branches/dist-snap/src/libnative/io/mod.rs

@@ -21,24 +21,21 @@
 //! play. The only dependencies of these modules are the normal system libraries
 //! that you would find on the respective platform.
 
-use c_str::CString;
-use comm::SharedChan;
-use libc::c_int;
-use libc;
-use option::{Option, None, Some};
-use os;
-use path::Path;
-use result::{Result, Ok, Err};
-use rt::rtio;
-use rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket, RtioUnixListener,
-               RtioPipe, RtioFileStream, RtioProcess, RtioSignal, RtioTTY,
-               CloseBehavior, RtioTimer};
-use io;
-use io::IoError;
-use io::net::ip::SocketAddr;
-use io::process::ProcessConfig;
-use io::signal::Signum;
-use ai = io::net::addrinfo;
+use std::c_str::CString;
+use std::comm::SharedChan;
+use std::libc::c_int;
+use std::libc;
+use std::os;
+use std::rt::rtio;
+use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket,
+                    RtioUnixListener, RtioPipe, RtioFileStream, RtioProcess,
+                    RtioSignal, RtioTTY, CloseBehavior, RtioTimer};
+use std::io;
+use std::io::IoError;
+use std::io::net::ip::SocketAddr;
+use std::io::process::ProcessConfig;
+use std::io::signal::Signum;
+use ai = std::io::net::addrinfo;
 
 // Local re-exports
 pub use self::file::FileDesc;
@@ -114,6 +111,9 @@ fn mkerr_winbool(ret: libc::c_int) -> IoResult<()> {
 pub struct IoFactory;
 
 impl rtio::IoFactory for IoFactory {
+    // all native io factories are the same
+    fn id(&self) -> uint { 0 }
+
     // networking
     fn tcp_connect(&mut self, _addr: SocketAddr) -> IoResult<~RtioTcpStream> {
         Err(unimpl())
@@ -223,6 +223,3 @@ impl rtio::IoFactory for IoFactory {
         Err(unimpl())
     }
 }
-
-pub static mut NATIVE_IO_FACTORY: IoFactory = IoFactory;
-

branches/dist-snap/src/libstd/io/native/process.rs renamed to branches/dist-snap/src/libnative/io/process.rs

@@ -8,18 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use io;
-use libc::{pid_t, c_void, c_int};
-use libc;
-use os;
-use prelude::*;
-use ptr;
-use rt::rtio;
-use super::file;
-#[cfg(windows)]
-use cast;
+use std::cast;
+use std::io;
+use std::libc::{pid_t, c_void, c_int};
+use std::libc;
+use std::os;
+use std::ptr;
+use std::rt::rtio;
+use p = std::io::process;
 
-use p = io::process;
+use super::file;
 
 /**
  * A value representing a child process.
@@ -179,22 +177,22 @@ fn spawn_process_os(prog: &str, args: &[~str],
                     env: Option<~[(~str, ~str)]>,
                     dir: Option<&Path>,
                     in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
-    use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
-    use libc::consts::os::extra::{
+    use std::libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
+    use std::libc::consts::os::extra::{
         TRUE, FALSE,
         STARTF_USESTDHANDLES,
         INVALID_HANDLE_VALUE,
         DUPLICATE_SAME_ACCESS
     };
-    use libc::funcs::extra::kernel32::{
+    use std::libc::funcs::extra::kernel32::{
         GetCurrentProcess,
         DuplicateHandle,
         CloseHandle,
         CreateProcessA
     };
-    use libc::funcs::extra::msvcrt::get_osfhandle;
+    use std::libc::funcs::extra::msvcrt::get_osfhandle;
 
-    use mem;
+    use std::mem;
 
     unsafe {
 
@@ -256,10 +254,10 @@ fn spawn_process_os(prog: &str, args: &[~str],
             fail!("failure in CreateProcess: {}", *msg);
         }
 
-        // We close the thread handle because we don't care about keeping the
+        // We close the thread handle because std::we don't care about keeping the
         // thread id valid, and we aren't keeping the thread handle around to be
         // able to close it later. We don't close the process handle however
-        // because we want the process id to stay valid at least until the
+        // because std::we want the process id to stay valid at least until the
         // calling code closes the process handle.
         CloseHandle(pi.hThread);
 
@@ -362,8 +360,8 @@ fn spawn_process_os(prog: &str, args: &[~str],
                     env: Option<~[(~str, ~str)]>,
                     dir: Option<&Path>,
                     in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
-    use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
-    use libc::funcs::bsd44::getdtablesize;
+    use std::libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
+    use std::libc::funcs::bsd44::getdtablesize;
 
     mod rustrt {
         extern {
@@ -433,7 +431,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
 
 #[cfg(unix)]
 fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T {
-    use vec;
+    use std::vec;
 
     // We can't directly convert `str`s into `*char`s, as someone needs to hold
     // a reference to the intermediary byte buffers. So first build an array to
@@ -459,7 +457,7 @@ fn with_argv<T>(prog: &str, args: &[~str], cb: |**libc::c_char| -> T) -> T {
 
 #[cfg(unix)]
 fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: |*c_void| -> T) -> T {
-    use vec;
+    use std::vec;
 
     // On posixy systems we can pass a char** for envp, which is a
     // null-terminated array of "k=v\n" strings. Like `with_argv`, we have to
@@ -540,16 +538,16 @@ fn waitpid(pid: pid_t) -> int {
 
     #[cfg(windows)]
     fn waitpid_os(pid: pid_t) -> int {
-        use libc::types::os::arch::extra::DWORD;
-        use libc::consts::os::extra::{
+        use std::libc::types::os::arch::extra::DWORD;
+        use std::libc::consts::os::extra::{
             SYNCHRONIZE,
             PROCESS_QUERY_INFORMATION,
             FALSE,
             STILL_ACTIVE,
             INFINITE,
             WAIT_FAILED
         };
-        use libc::funcs::extra::kernel32::{
+        use std::libc::funcs::extra::kernel32::{
             OpenProcess,
             GetExitCodeProcess,
             CloseHandle,
@@ -585,7 +583,7 @@ fn waitpid(pid: pid_t) -> int {
 
     #[cfg(unix)]
     fn waitpid_os(pid: pid_t) -> int {
-        use libc::funcs::posix01::wait::*;
+        use std::libc::funcs::posix01::wait;
 
         #[cfg(target_os = "linux")]
         #[cfg(target_os = "android")]
@@ -612,7 +610,7 @@ fn waitpid(pid: pid_t) -> int {
         }
 
         let mut status = 0 as c_int;
-        if unsafe { waitpid(pid, &mut status, 0) } == -1 {
+        if unsafe { wait::waitpid(pid, &mut status, 0) } == -1 {
             fail!("failure in waitpid: {}", os::last_os_error());
         }
 

branches/dist-snap/src/libnative/lib.rs

@@ -0,0 +1,61 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The native runtime crate
+//!
+//! This crate contains an implementation of 1:1 scheduling for a "native"
+//! runtime. In addition, all I/O provided by this crate is the thread blocking
+//! version of I/O.
+
+#[link(name = "native",
+       package_id = "native",
+       vers = "0.9-pre",
+       uuid = "535344a7-890f-5a23-e1f3-e0d118805141",
+       url = "https://github.com/mozilla/rust/tree/master/src/native")];
+
+#[license = "MIT/ASL2"];
+#[crate_type = "rlib"];
+#[crate_type = "dylib"];
+
+// NB this crate explicitly does *not* allow glob imports, please seriously
+//    consider whether they're needed before adding that feature here.
+
+use std::cast;
+use std::os;
+use std::rt;
+use std::task::try;
+
+pub mod io;
+pub mod task;
+
+// XXX: this should not exist here
+#[cfg(stage0)]
+#[lang = "start"]
+pub fn start(main: *u8, argc: int, argv: **u8) -> int {
+    rt::init(argc, argv);
+
+    // Bootstrap ourselves by installing a local Task and then immediately
+    // spawning a thread to run 'main'. Always spawn a new thread for main so
+    // the stack size of 'main' is known (and the bounds can be set
+    // appropriately).
+    //
+    // Once the main task has completed, then we wait for everyone else to exit.
+    task::run(task::new(), proc() {
+        let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
+        match do try { main() } {
+            Ok(()) => { os::set_exit_status(0); }
+            Err(..) => { os::set_exit_status(rt::DEFAULT_ERROR_CODE); }
+        }
+    });
+    task::wait_for_completion();
+
+    unsafe { rt::cleanup(); }
+    os::get_exit_status()
+}