---

yaml
---
r: 81662
b: refs/heads/master
c: cb7756a
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9621156fc3814edaef6acafc06827e5aa87c9bdd
+refs/heads/master: cb7756a81d3cbc48e79ffaa1a1f9d4934b581166
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/src/librustc/middle/trans/base.rs

@@ -2442,6 +2442,11 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
         unsafe {
             llvm::LLVMPositionBuilderAtEnd(bld, llbb);
 
+            let crate_map = ccx.crate_map;
+            let opaque_crate_map = do "crate_map".with_c_str |buf| {
+                llvm::LLVMBuildPointerCast(bld, crate_map, Type::i8p().to_ref(), buf)
+            };
+
             let (start_fn, args) = if use_start_lang_item {
                 let start_def_id = match ccx.tcx.lang_items.require(StartFnLangItem) {
                     Ok(id) => id,
@@ -2464,7 +2469,8 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
                         C_null(Type::opaque_box(ccx).ptr_to()),
                         opaque_rust_main,
                         llvm::LLVMGetParam(llfn, 0),
-                        llvm::LLVMGetParam(llfn, 1)
+                        llvm::LLVMGetParam(llfn, 1),
+                        opaque_crate_map
                      ]
                 };
                 (start_fn, args)
@@ -2473,7 +2479,8 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
                 let args = ~[
                     C_null(Type::opaque_box(ccx).ptr_to()),
                     llvm::LLVMGetParam(llfn, 0 as c_uint),
-                    llvm::LLVMGetParam(llfn, 1 as c_uint)
+                    llvm::LLVMGetParam(llfn, 1 as c_uint),
+                    opaque_crate_map
                 ];
 
                 (rust_main, args)
@@ -2652,8 +2659,6 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                             let path = vec::append((*pth).clone(), [path_name(ni.ident)]);
                             foreign::register_foreign_item_fn(ccx, abis, &path, ni)
                         }
-                        ast::foreign_item_static(*) if attr::contains_name(ni.attrs, "crate_map")
-                            => ccx.crate_map,
                         ast::foreign_item_static(*) => {
                             let ident = foreign::link_name(ccx, ni);
                             let g = do ident.with_c_str |buf| {

trunk/src/librustc/middle/typeck/mod.rs

@@ -402,7 +402,8 @@ fn check_start_fn_ty(ccx: &CrateCtxt,
                     bound_lifetime_names: opt_vec::Empty,
                     inputs: ~[
                         ty::mk_int(),
-                        ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8()))
+                        ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8())),
+                        ty::mk_imm_ptr(tcx, ty::mk_u8())
                     ],
                     output: ty::mk_int()
                 }

trunk/src/libstd/rt/crate_map.rs

@@ -16,13 +16,7 @@ use vec;
 use hashmap::HashSet;
 use container::MutableSet;
 
-extern {
-    #[cfg(not(stage0))]
-    #[crate_map]
-    static CRATE_MAP: CrateMap;
-}
-
-pub struct ModEntry {
+pub struct ModEntry{
     name: *c_char,
     log_level: *mut u32
 }
@@ -40,11 +34,6 @@ struct CrateMap {
     children: [*CrateMap, ..1]
 }
 
-#[cfg(not(stage0))]
-pub fn get_crate_map() -> *CrateMap {
-    &'static CRATE_MAP as *CrateMap
-}
-
 unsafe fn version(crate_map: *CrateMap) -> i32 {
     match (*crate_map).version {
         1 => return 1,

trunk/src/libstd/rt/io/mod.rs

@@ -260,6 +260,9 @@ pub use self::net::ip::IpAddr;
 pub use self::net::tcp::TcpListener;
 pub use self::net::tcp::TcpStream;
 pub use self::net::udp::UdpStream;
+pub use self::pipe::PipeStream;
+pub use self::pipe::UnboundPipeStream;
+pub use self::process::Process;
 
 // Some extension traits that all Readers and Writers get.
 pub use self::extensions::ReaderUtil;
@@ -269,6 +272,12 @@ pub use self::extensions::WriterByteConversions;
 /// Synchronous, non-blocking file I/O.
 pub mod file;
 
+/// Synchronous, in-memory I/O.
+pub mod pipe;
+
+/// Child process management.
+pub mod process;
+
 /// Synchronous, non-blocking network I/O.
 pub mod net;
 

trunk/src/libstd/rt/io/pipe.rs

@@ -0,0 +1,76 @@
+// 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.
+
+//! Synchronous, in-memory pipes.
+//!
+//! Currently these aren't particularly useful, there only exists bindings
+//! enough so that pipes can be created to child processes.
+
+use prelude::*;
+use super::{Reader, Writer};
+use rt::io::{io_error, read_error, EndOfFile};
+use rt::local::Local;
+use rt::rtio::{RtioPipe, RtioPipeObject, IoFactoryObject, IoFactory};
+use rt::rtio::RtioUnboundPipeObject;
+
+pub struct PipeStream(RtioPipeObject);
+pub struct UnboundPipeStream(~RtioUnboundPipeObject);
+
+impl PipeStream {
+    /// Creates a new pipe initialized, but not bound to any particular
+    /// source/destination
+    pub fn new() -> Option<UnboundPipeStream> {
+        let pipe = unsafe {
+            let io: *mut IoFactoryObject = Local::unsafe_borrow();
+            (*io).pipe_init(false)
+        };
+        match pipe {
+            Ok(p) => Some(UnboundPipeStream(p)),
+            Err(ioerr) => {
+                io_error::cond.raise(ioerr);
+                None
+            }
+        }
+    }
+
+    pub fn bind(inner: RtioPipeObject) -> PipeStream {
+        PipeStream(inner)
+    }
+}
+
+impl Reader for PipeStream {
+    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        match (**self).read(buf) {
+            Ok(read) => Some(read),
+            Err(ioerr) => {
+                // EOF is indicated by returning None
+                if ioerr.kind != EndOfFile {
+                    read_error::cond.raise(ioerr);
+                }
+                return None;
+            }
+        }
+    }
+
+    fn eof(&mut self) -> bool { fail!() }
+}
+
+impl Writer for PipeStream {
+    fn write(&mut self, buf: &[u8]) {
+        match (**self).write(buf) {
+            Ok(_) => (),
+            Err(ioerr) => {
+                io_error::cond.raise(ioerr);
+            }
+        }
+    }
+
+    fn flush(&mut self) { fail!() }
+}