# automatically generated for all stage/host/target combinations.
################################################################################
-TARGET_CRATES := std green rustuv native flate arena glob term semver \
+TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
uuid serialize sync getopts collections num test time rand \
workcache url log
HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
TOOLS := compiletest rustdoc rustc
-DEPS_std := native:rustrt native:compiler-rt native:backtrace
+DEPS_std := libc native:rustrt native:compiler-rt native:backtrace
DEPS_green := std rand native:context_switch
DEPS_rustuv := std native:uv native:uv_support
DEPS_native := std
compile if snappy is installed:
~~~~ {.ignore}
-use std::libc::size_t;
+extern crate libc;
+use libc::size_t;
#[link(name = "snappy")]
extern {
The `extern` block can be extended to cover the entire snappy API:
~~~~ {.ignore}
-use std::libc::{c_int, size_t};
+extern crate libc;
+use libc::{c_int, size_t};
#[link(name = "snappy")]
extern {
blocks with the `static` keyword:
~~~{.ignore}
-use std::libc;
+extern crate libc;
#[link(name = "readline")]
extern {
them.
~~~{.ignore}
-use std::libc;
+extern crate libc;
use std::ptr;
#[link(name = "readline")]
conventions. Rust provides a way to tell the compiler which convention to use:
~~~~
+extern crate libc;
+
#[cfg(target_os = "win32", target_arch = "x86")]
#[link(name = "kernel32")]
extern "stdcall" {
- fn SetEnvironmentVariableA(n: *u8, v: *u8) -> std::libc::c_int;
+ fn SetEnvironmentVariableA(n: *u8, v: *u8) -> libc::c_int;
}
+
+# fn main() { }
~~~~
This applies to the entire `extern` block. The list of supported ABI constraints
reimplementation is as safe as the built-in `~` type.
```
-use std::libc::{c_void, size_t, malloc, free};
+extern crate libc;
+use libc::{c_void, size_t, malloc, free};
use std::mem;
use std::ptr;
* [The `glob` file path matching library](glob/index.html)
* [The `green` M:N runtime library](green/index.html)
* [The `hexfloat` library for hexadecimal floating-point literals](hexfloat/index.html)
+* [The `libc` bindings](libc/index.html)
* [The `native` 1:1 threading runtime](native/index.html)
* [The `num` arbitrary precision numerics library](num/index.html)
* [The `rand` library for random numbers and distributions](rand/index.html)
and are instead terminated by a semicolon.
~~~~
-# use std::libc::{c_char, FILE};
+extern crate libc;
+use libc::{c_char, FILE};
extern {
fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
}
+# fn main() {}
~~~~
Functions within external blocks may be called by Rust code,
)
_rustc_opts_lint=(
'attribute-usage[detects bad use of attributes]'
- 'ctypes[proper use of std::libc types in foreign modules]'
+ 'ctypes[proper use of libc types in foreign modules]'
'dead-assignment[detect assignments that will never be read]'
'dead-code[detect piece of code that will never be used]'
'default-type-param-usage[prevents explicitly setting a type parameter with a default]'
use std::slice::ImmutableVector;
mod table {
+ extern crate libc;
+
use std::clone::Clone;
use std::cmp::Eq;
use std::hash::{Hash, Hasher};
use std::kinds::marker;
- use std::libc;
use std::num::CheckedMul;
use std::option::{Option, Some, None};
use std::prelude::Drop;
#[cfg(test)] #[phase(syntax, link)] extern crate log;
-use std::libc::{c_void, size_t, c_int};
-use std::libc;
+extern crate libc;
+
use std::c_vec::CVec;
+use libc::{c_void, size_t, c_int};
-pub mod rustrt {
- use std::libc::{c_int, c_void, size_t};
+pub mod rustrt {
+ use libc::{c_void, size_t, c_int};
#[link(name = "miniz", kind = "static")]
extern {
pub fn tdefl_compress_mem_to_heap(psrc_buf: *c_void,
#[cfg(test)] #[phase(syntax, link)] extern crate log;
#[cfg(test)] extern crate rustuv;
extern crate rand;
+extern crate libc;
use std::mem::replace;
use std::os;
pub fn dumb_println(args: &fmt::Arguments) {
use std::io;
- use std::libc;
+ use libc;
struct Stderr;
impl io::Writer for Stderr {
}
#[cfg(unix)]
fn new_sched_rng() -> XorShiftRng {
- use std::libc;
+ use libc;
use std::mem;
use rand::SeedableRng;
use std::rt::env::max_cached_stacks;
use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
MapNonStandardFlags, MapVirtual};
-use std::libc;
+use libc;
/// A task's stack. The name "Stack" is a vestige of segmented stacks.
pub struct Stack {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[feature(globs)];
-#[crate_id = "libc#0.10-pre"];
-#[experimental];
+#![feature(globs)]
+#![crate_id = "libc#0.10-pre"]
+#![experimental]
+#![no_std] // we don't need std, and we can't have std, since it doesn't exist
+ // yet. std depends on us.
+#![crate_type = "rlib"]
+#![crate_type = "dylib"]
/*!
* Bindings for the C standard library and other platform libraries
*
-* This module contains bindings to the C standard library,
-* organized into modules by their defining standard.
-* Additionally, it contains some assorted platform-specific definitions.
-* For convenience, most functions and types are reexported from `libc`,
-* so `pub use std::*` will import the available
-* C bindings as appropriate for the target platform. The exact
-* set of functions available are platform specific.
+* **NOTE:** These are *architecture and libc* specific. On Linux, these
+* bindings are only correct for glibc.
*
-* *Note* Because these definitions are platform-specific, some may not appear in
-* the generated documentation.
+* This module contains bindings to the C standard library, organized into
+* modules by their defining standard. Additionally, it contains some assorted
+* platform-specific definitions. For convenience, most functions and types
+* are reexported, so `use libc::*` will import the available C bindings as
+* appropriate for the target platform. The exact set of functions available
+* are platform specific.
*
-* We consider the following specs reasonably normative with respect
-* to interoperating with the C standard library (libc/msvcrt):
+* *Note:* Because these definitions are platform-specific, some may not appear
+* in the generated documentation.
+*
+* We consider the following specs reasonably normative with respect to
+* interoperating with the C standard library (libc/msvcrt):
*
* * ISO 9899:1990 ('C95', 'ANSI C', 'Standard C'), NA1, 1995.
* * ISO 9899:1999 ('C99' or 'C9x').
* * ISO 9945:2001 / IEEE 1003.1-2001 ('POSIX:2001', 'SUSv3').
* * ISO 9945:2008 / IEEE 1003.1-2008 ('POSIX:2008', 'SUSv4').
*
-* Note that any reference to the 1996 revision of POSIX, or any revs
-* between 1990 (when '88 was approved at ISO) and 2001 (when the next
-* actual revision-revision happened), are merely additions of other
-* chapters (1b and 1c) outside the core interfaces.
+* Note that any reference to the 1996 revision of POSIX, or any revs between
+* 1990 (when '88 was approved at ISO) and 2001 (when the next actual
+* revision-revision happened), are merely additions of other chapters (1b and
+* 1c) outside the core interfaces.
*
* Despite having several names each, these are *reasonably* coherent
* point-in-time, list-of-definition sorts of specs. You can get each under a
* sanity while editing, filling-in-details and eliminating duplication) into
* definitions common-to-all (held in modules named c95, c99, posix88, posix01
* and posix08) and definitions that appear only on *some* platforms (named
-* 'extra'). This would be things like significant OSX foundation kit, or
-* win32 library kernel32.dll, or various fancy glibc, linux or BSD
-* extensions.
+* 'extra'). This would be things like significant OSX foundation kit, or win32
+* library kernel32.dll, or various fancy glibc, linux or BSD extensions.
*
* In addition to the per-platform 'extra' modules, we define a module of
* 'common BSD' libc routines that never quite made it into POSIX but show up
-* in multiple derived systems. This is the 4.4BSD r2 / 1995 release, the
-* final one from Berkeley after the lawsuits died down and the CSRG
-* dissolved.
+* in multiple derived systems. This is the 4.4BSD r2 / 1995 release, the final
+* one from Berkeley after the lawsuits died down and the CSRG dissolved.
*/
#![allow(non_camel_case_types)]
pub mod bsd44 {
}
pub mod extra {
- use ptr;
use consts::os::extra::{MAX_PROTOCOL_CHAIN,
WSAPROTOCOL_LEN};
use types::common::c95::c_void;
}
pub type LPSYSTEM_INFO = *mut SYSTEM_INFO;
- impl SYSTEM_INFO {
- pub fn new() -> SYSTEM_INFO {
- SYSTEM_INFO {
- wProcessorArchitecture: 0,
- wReserved: 0,
- dwPageSize: 0,
- lpMinimumApplicationAddress: ptr::mut_null(),
- lpMaximumApplicationAddress: ptr::mut_null(),
- dwActiveProcessorMask: 0,
- dwNumberOfProcessors: 0,
- dwProcessorType: 0,
- dwAllocationGranularity: 0,
- wProcessorLevel: 0,
- wProcessorRevision: 0
- }
- }
- }
-
pub struct MEMORY_BASIC_INFORMATION {
pub BaseAddress: LPVOID,
pub AllocationBase: LPVOID,
pub mod glob {
use types::os::arch::c95::{c_char, c_int};
use types::os::common::posix01::{glob_t};
- use Nullable;
extern {
pub fn glob(pattern: *c_char,
flags: c_int,
- errfunc: Nullable<extern "C" fn(epath: *c_char, errno: int) -> int>,
+ errfunc: ::Nullable<extern "C" fn(epath: *c_char, errno: int) -> int>,
pglob: *mut glob_t);
pub fn globfree(pglob: *mut glob_t);
}
use std::c_str::CString;
use std::cast;
use std::io::IoError;
-use std::libc;
-use std::libc::{c_char, c_int};
+use libc;
+use libc::{c_char, c_int};
use std::ptr::{null, mut_null};
use super::net::sockaddr_to_addr;
use std::c_str::CString;
use std::io::IoError;
use std::io;
-use std::libc::{c_int, c_void};
-use std::libc;
+use libc::{c_int, c_void};
+use libc;
use std::mem;
use std::rt::rtio;
use std::slice;
}
pub fn readdir(p: &CString) -> IoResult<~[Path]> {
- use std::libc::{dirent_t};
- use std::libc::{opendir, readdir_r, closedir};
+ use libc::{dirent_t};
+ use libc::{opendir, readdir_r, closedir};
fn prune(root: &CString, dirs: ~[Path]) -> ~[Path] {
let root = unsafe { CString::new(root.with_ref(|p| p), false) };
mod tests {
use super::{CFile, FileDesc};
use std::io;
- use std::libc;
+ use libc;
use std::os;
use std::rt::rtio::RtioFileStream;
use std::cast;
use std::io::IoError;
use std::io;
-use std::libc::{c_int, c_void};
-use std::libc;
+use libc::{c_int, c_void};
+use libc;
use std::mem;
use std::os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
use std::ptr;
use std::io::net::ip::SocketAddr;
use std::io::process::ProcessConfig;
use std::io::signal::Signum;
-use std::libc::c_int;
-use std::libc;
+use libc::c_int;
+use libc;
use std::os;
use std::rt::rtio;
use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket,
use std::cast;
use std::io::net::ip;
use std::io;
-use std::libc;
+use libc;
use std::mem;
use std::rt::rtio;
use std::sync::arc::UnsafeArc;
use std::c_str::CString;
use std::cast;
use std::io;
-use std::libc;
+use libc;
use std::mem;
use std::rt::rtio;
use std::sync::arc::UnsafeArc;
//! me!
use std::c_str::CString;
-use std::libc;
+use libc;
use std::os::win32::as_utf16_p;
use std::ptr;
use std::rt::rtio;
// except according to those terms.
use std::io;
-use std::libc::{pid_t, c_void, c_int};
-use std::libc;
+use libc::{pid_t, c_void, c_int};
+use libc;
use std::os;
use std::ptr;
use std::rt::rtio;
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int,
err_fd: c_int) -> IoResult<SpawnProcessResult> {
- use std::libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
- use std::libc::consts::os::extra::{
+ use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
+ use libc::consts::os::extra::{
TRUE, FALSE,
STARTF_USESTDHANDLES,
INVALID_HANDLE_VALUE,
DUPLICATE_SAME_ACCESS
};
- use std::libc::funcs::extra::kernel32::{
+ use libc::funcs::extra::kernel32::{
GetCurrentProcess,
DuplicateHandle,
CloseHandle,
CreateProcessA
};
- use std::libc::funcs::extra::msvcrt::get_osfhandle;
+ use libc::funcs::extra::msvcrt::get_osfhandle;
use std::mem;
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int,
err_fd: c_int) -> IoResult<SpawnProcessResult> {
- use std::libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
- use std::libc::funcs::bsd44::getdtablesize;
- use std::libc::c_ulong;
+ use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
+ use libc::funcs::bsd44::getdtablesize;
+ use libc::c_ulong;
mod rustrt {
extern {
#[cfg(windows)]
fn waitpid_os(pid: pid_t) -> p::ProcessExit {
- use std::libc::types::os::arch::extra::DWORD;
- use std::libc::consts::os::extra::{
+ use libc::types::os::arch::extra::DWORD;
+ use libc::consts::os::extra::{
SYNCHRONIZE,
PROCESS_QUERY_INFORMATION,
FALSE,
INFINITE,
WAIT_FAILED
};
- use std::libc::funcs::extra::kernel32::{
+ use libc::funcs::extra::kernel32::{
OpenProcess,
GetExitCodeProcess,
CloseHandle,
#[cfg(unix)]
fn waitpid_os(pid: pid_t) -> p::ProcessExit {
- use std::libc::funcs::posix01::wait;
+ use libc::funcs::posix01::wait;
let mut status = 0 as c_int;
match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
-1 => fail!("unknown waitpid error: {}", super::last_error()),
#[cfg(unix)]
fn waitpid_os(pid: pid_t) -> Option<p::ProcessExit> {
- use std::libc::funcs::posix01::wait;
+ use libc::funcs::posix01::wait;
let mut status = 0 as c_int;
match retry(|| unsafe {
wait::waitpid(pid, &mut status, libc::WNOHANG)
#[cfg(unix)]
mod imp {
- use std::libc;
+ use libc;
use std::os;
use io::file::FileDesc;
#[cfg(windows)]
mod imp {
- use std::libc::{BOOL, LPCSTR, HANDLE, LPSECURITY_ATTRIBUTES, CloseHandle};
+ use libc::{BOOL, LPCSTR, HANDLE, LPSECURITY_ATTRIBUTES, CloseHandle};
use std::ptr;
- use std::libc;
+ use libc;
pub type signal = HANDLE;
//! Note that all time units in this file are in *milliseconds*.
use std::comm::Data;
-use std::libc;
+use libc;
use std::mem;
use std::os;
use std::ptr;
#[cfg(target_os = "macos")]
mod imp {
- use std::libc;
+ use libc;
pub static FD_SETSIZE: uint = 1024;
#[cfg(target_os = "android")]
#[cfg(target_os = "freebsd")]
mod imp {
- use std::libc;
+ use libc;
pub static FD_SETSIZE: uint = 1024;
//! As with timer_other, all units in this file are in units of millseconds.
use std::comm::Data;
-use std::libc;
+use libc;
use std::ptr;
use std::os;
use std::rt::rtio;
#[allow(dead_code)]
mod imp {
- use std::libc;
+ use libc;
pub static CLOCK_MONOTONIC: libc::c_int = 1;
pub static EPOLL_CTL_ADD: libc::c_int = 1;
//! the other two implementations of timers with nothing *that* new showing up.
use std::comm::Data;
-use std::libc;
+use libc;
use std::ptr;
use std::rt::rtio;
}
mod imp {
- use std::libc::{LPSECURITY_ATTRIBUTES, BOOL, LPCSTR, HANDLE, LARGE_INTEGER,
+ use libc::{LPSECURITY_ATTRIBUTES, BOOL, LPCSTR, HANDLE, LARGE_INTEGER,
LONG, LPVOID, DWORD, c_void};
pub type PTIMERAPCROUTINE = *c_void;
// consider whether they're needed before adding that feature here (the
// answer is that you don't need them)
+extern crate libc;
+
use std::os;
use std::rt;
use std::str;
// prevent this problem.
#[cfg(windows)] fn ignore_sigpipe() {}
#[cfg(unix)] fn ignore_sigpipe() {
- use std::libc;
- use std::libc::funcs::posix01::signal::signal;
+ use libc;
+ use libc::funcs::posix01::signal::signal;
unsafe {
assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != -1);
}
#[cfg(windows)]
mod imp {
+ extern crate libc;
+
use Rng;
use std::cast;
use std::io::{IoResult, IoError};
- use std::libc::{c_ulong, DWORD, BYTE, LPCSTR, BOOL};
use std::os;
use std::rt::stack;
+ use self::libc::{c_ulong, DWORD, BYTE, LPCSTR, BOOL};
type HCRYPTPROV = c_ulong;
use std::cast;
use std::io;
use std::io::{fs, TempDir};
-use std::libc;
+use libc;
use std::os;
use std::io::process::{ProcessConfig, Process, ProcessOutput};
use std::str;
use std::c_str::ToCStr;
use std::io::Process;
- use std::libc::{c_uint, c_int};
+ use libc::{c_uint, c_int};
use std::str;
// On android, we by default compile for armv7 processors. This enables
use metadata::cstore;
use util::common::time;
-use std::libc;
+use libc;
use flate;
pub fn run(sess: &session::Session, llmod: ModuleRef,
extern crate getopts;
extern crate collections;
extern crate time;
+extern crate libc;
+
#[phase(syntax, link)]
extern crate log;
use std::c_str::ToCStr;
use std::cell::RefCell;
use collections::HashMap;
-use std::libc::{c_uint, c_ushort, c_void, free};
+use libc::{c_uint, c_ushort, c_void, free};
use std::str::raw::from_c_str;
use middle::trans::type_::Type;
use super::{ValueRef, TargetMachineRef, FileType, ArchiveRef};
use super::{CodeGenModel, RelocMode, CodeGenOptLevel};
use super::debuginfo::*;
- use std::libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong,
+ use libc::{c_char, c_int, c_longlong, c_ushort, c_uint, c_ulonglong,
size_t};
// Link to our native llvm bindings (things that we need to use the C++ api
use syntax::parse::token;
use syntax;
-use std::libc;
+use libc;
use std::cast;
use std::cell::RefCell;
use std::io::Seek;
("ctypes",
LintSpec {
lint: CTypes,
- desc: "proper use of std::libc types in foreign modules",
+ desc: "proper use of libc types in foreign modules",
default: warn
}),
*/
use std::container::Map;
-use std::libc::c_ulonglong;
+use libc::c_ulonglong;
use std::option::{Option, Some, None};
use std::num::{Bitwise};
use util::nodemap::NodeMap;
use arena::TypedArena;
+use libc::c_uint;
use std::c_str::ToCStr;
use std::cell::{Cell, RefCell};
-use std::libc::c_uint;
use std::local_data;
use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic};
use syntax::ast_util::{local_def, is_local};
use middle::trans::builder::Builder;
use middle::trans::type_::Type;
-use std::libc::{c_uint, c_ulonglong, c_char};
+use libc::{c_uint, c_ulonglong, c_char};
pub fn terminate(cx: &Block, _: &str) {
debug!("terminate({})", cx.to_str());
use middle::trans::common::*;
use middle::trans::machine::llalign_of_pref;
use middle::trans::type_::Type;
-
use collections::HashMap;
-use std::libc::{c_uint, c_ulonglong, c_char};
+use std::vec::Vec;
+use libc::{c_uint, c_ulonglong, c_char};
use syntax::codemap::Span;
pub struct Builder<'a> {
#![allow(non_uppercase_pattern_statics)]
-use std::libc::c_uint;
+use libc::c_uint;
use std::cmp;
use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
use lib::llvm::StructRetAttribute;
use arena::TypedArena;
use collections::HashMap;
+use libc::{c_uint, c_longlong, c_ulonglong, c_char};
use std::c_str::ToCStr;
use std::cell::{Cell, RefCell};
-use std::libc::{c_uint, c_longlong, c_ulonglong, c_char};
+use std::vec::Vec;
use syntax::ast::Ident;
use syntax::ast;
use syntax::ast_map::{PathElem, PathName};
use util::ppaux::{Repr, ty_to_str};
use std::c_str::ToCStr;
-use std::libc::c_uint;
use std::slice;
use std::vec::Vec;
+use libc::c_uint;
use syntax::{ast, ast_util};
pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit)
use util::sha2::Sha256;
use util::nodemap::{NodeMap, NodeSet, DefIdMap};
-use libc::c_uint;
use std::cell::{Cell, RefCell};
use std::c_str::ToCStr;
use std::ptr;
use std::cell::{Cell, RefCell};
use collections::HashMap;
use collections::HashSet;
-use std::libc::{c_uint, c_ulonglong, c_longlong};
+use libc::{c_uint, c_ulonglong, c_longlong};
use std::ptr;
use std::sync::atomics;
use std::slice;
use middle::ty::FnSig;
use middle::ty;
use std::cmp;
-use std::libc::c_uint;
+use libc::c_uint;
use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi};
use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall, System};
use syntax::codemap::Span;
use arena::TypedArena;
use std::c_str::ToCStr;
use std::cell::Cell;
-use std::libc::c_uint;
+use libc::c_uint;
use syntax::ast;
use syntax::parse::token;
use util::ppaux::ty_to_str;
use arena::TypedArena;
-use std::libc::c_uint;
+use libc::c_uint;
use syntax::ast::DefId;
use syntax::ast;
use syntax::ast_map;
use std::c_str::ToCStr;
use std::cast;
-use std::libc::{c_uint};
+use libc::{c_uint};
#[deriving(Clone, Eq, Show)]
pub struct Type {
use lib::llvm::{llvm, UseRef, ValueRef};
use middle::trans::basic_block::BasicBlock;
use middle::trans::common::Block;
-use std::libc::c_uint;
+use libc::c_uint;
pub struct Value(pub ValueRef);
pub use self::imp::Lock;
+
#[cfg(unix)]
mod imp {
- use std::libc;
+ use libc;
#[cfg(target_os = "linux")]
mod os {
- use std::libc;
+ use libc;
pub struct flock {
pub l_type: libc::c_short,
#[cfg(target_os = "freebsd")]
mod os {
- use std::libc;
+ use libc;
pub struct flock {
pub l_start: libc::off_t,
#[cfg(target_os = "macos")]
mod os {
- use std::libc;
+ use libc;
pub struct flock {
pub l_start: libc::off_t,
#[cfg(windows)]
mod imp {
- use std::libc;
+ use libc;
use std::mem;
use std::os::win32::as_utf16_p;
use std::os;
#![allow(non_camel_case_types)]
+use libc;
use std::cast;
use std::fmt;
use std::io;
-use std::libc;
use std::local_data;
use std::mem;
use std::str;
extern crate time;
#[phase(syntax, link)]
extern crate log;
+extern crate libc;
use std::local_data;
use std::io;
use ai = std::io::net::addrinfo;
use std::cast;
-use std::libc;
-use std::libc::c_int;
+use libc;
+use libc::c_int;
use std::ptr::null;
use std::rt::task::BlockedTask;
// except according to those terms.
use std::cast;
-use std::libc::c_int;
+use libc::c_int;
use std::rt::rtio::{Callback, RemoteCallback};
use std::unstable::sync::Exclusive;
use std::c_str;
use std::cast::transmute;
use std::cast;
-use std::libc::{c_int, c_char, c_void, size_t, ssize_t};
-use std::libc;
+use libc::{c_int, c_char, c_void, size_t, ssize_t};
+use libc;
use std::rt::task::BlockedTask;
use std::io::{FileStat, IoError};
use std::io;
self.base_write(buf, offset as i64)
}
fn seek(&mut self, pos: i64, whence: io::SeekStyle) -> Result<u64, IoError> {
- use std::libc::{SEEK_SET, SEEK_CUR, SEEK_END};
+ use libc::{SEEK_SET, SEEK_CUR, SEEK_END};
let whence = match whence {
io::SeekSet => SEEK_SET,
io::SeekCur => SEEK_CUR,
self.seek_common(pos, whence)
}
fn tell(&self) -> Result<u64, IoError> {
- use std::libc::SEEK_CUR;
+ use libc::SEEK_CUR;
// this is temporary
let self_ = unsafe { cast::transmute_mut(self) };
self_.seek_common(0, SEEK_CUR)
#[cfg(test)]
mod test {
- use std::libc::c_int;
- use std::libc::{O_CREAT, O_RDWR, O_RDONLY, S_IWUSR, S_IRUSR};
+ use libc::c_int;
+ use libc::{O_CREAT, O_RDWR, O_RDONLY, S_IWUSR, S_IRUSR};
use std::io;
use std::str;
use std::slice;
// except according to those terms.
use std::cast;
-use std::libc::{c_int, c_void};
+use libc::{c_int, c_void};
use uvll;
use super::{Loop, UvHandle};
#[cfg(test)] extern crate green;
#[cfg(test)] extern crate realrustuv = "rustuv";
+extern crate libc;
use std::cast;
use std::fmt;
use std::io::IoError;
use std::io;
-use std::libc::{c_int, c_void};
+use libc::{c_int, c_void};
use std::ptr::null;
use std::ptr;
use std::rt::local::Local;
pub fn dumb_println(args: &fmt::Arguments) {
use std::io;
- use std::libc;
+ use libc;
struct Stderr;
impl io::Writer for Stderr {
use std::cast;
use std::io::IoError;
use std::io::net::ip;
-use std::libc::{size_t, ssize_t, c_int, c_void, c_uint};
-use std::libc;
+use libc::{size_t, ssize_t, c_int, c_void, c_uint};
+use libc;
use std::mem;
use std::ptr;
use std::rt::rtio;
use std::c_str::CString;
use std::io::IoError;
-use std::libc;
+use libc;
use std::rt::rtio::{RtioPipe, RtioUnixListener, RtioUnixAcceptor};
use std::rt::task::BlockedTask;
use std::io::IoError;
use std::io::process;
-use std::libc::c_int;
-use std::libc;
+use libc::c_int;
+use libc;
use std::ptr;
use std::rt::rtio::RtioProcess;
use std::rt::task::BlockedTask;
#![allow(dead_code)]
use std::cast;
-use std::libc::{c_void, c_int};
+use libc::{c_void, c_int};
use std::rt::task::BlockedTask;
use std::unstable::mutex::NativeMutex;
use std::sync::arc::UnsafeArc;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc::c_int;
+use libc::c_int;
use std::io::signal::Signum;
use std::rt::rtio::RtioSignal;
// except according to those terms.
use std::cast;
-use std::libc::{c_int, size_t, ssize_t};
+use libc::{c_int, size_t, ssize_t};
use std::ptr;
use std::rt::task::BlockedTask;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc::c_int;
+use libc::c_int;
use std::mem;
use std::rt::rtio::RtioTimer;
use std::rt::task::BlockedTask;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use libc;
use std::io::IoError;
-use std::libc;
use std::ptr;
use std::rt::rtio::RtioTTY;
use std::io::{FileMode, FileAccess, Open, Append, Truncate, Read, Write,
ReadWrite, FileStat};
use std::io;
-use std::libc::c_int;
-use std::libc::{O_CREAT, O_APPEND, O_TRUNC, O_RDWR, O_RDONLY, O_WRONLY, S_IRUSR,
+use libc::c_int;
+use libc::{O_CREAT, O_APPEND, O_TRUNC, O_RDWR, O_RDONLY, O_WRONLY, S_IRUSR,
S_IWUSR};
-use std::libc;
+use libc;
use std::path::Path;
use std::rt::rtio;
use std::rt::rtio::IoFactory;
#![allow(non_camel_case_types)] // C types
-use std::libc::{size_t, c_int, c_uint, c_void, c_char, c_double};
-use std::libc::{ssize_t, sockaddr, free, addrinfo};
-use std::libc;
+use libc::{size_t, c_int, c_uint, c_void, c_char, c_double};
+use libc::{ssize_t, sockaddr, free, addrinfo};
+use libc;
use std::rt::global_heap::malloc_raw;
#[cfg(test)]
-use std::libc::uintptr_t;
+use libc::uintptr_t;
pub use self::errors::{EACCES, ECONNREFUSED, ECONNRESET, EPIPE, ECONNABORTED,
ECANCELED, EBADF, ENOTCONN, ENOENT, EADDRNOTAVAIL};
#[cfg(windows)]
pub mod errors {
- use std::libc::c_int;
+ use libc::c_int;
pub static EACCES: c_int = -4092;
pub static ECONNREFUSED: c_int = -4078;
}
#[cfg(not(windows))]
pub mod errors {
- use std::libc;
- use std::libc::c_int;
+ use libc;
+ use libc::c_int;
pub static EACCES: c_int = -libc::EACCES;
pub static ECONNREFUSED: c_int = -libc::ECONNREFUSED;
An example of creating and using a C string would be:
```rust
-use std::libc;
+extern crate libc;
+
extern {
fn puts(s: *libc::c_char);
}
-let my_string = "Hello, world!";
-
-// Allocate the C string with an explicit local that owns the string. The
-// `c_buffer` pointer will be deallocated when `my_c_string` goes out of scope.
-let my_c_string = my_string.to_c_str();
-my_c_string.with_ref(|c_buffer| {
- unsafe { puts(c_buffer); }
-});
-
-// Don't save off the allocation of the C string, the `c_buffer` will be
-// deallocated when this block returns!
-my_string.with_c_str(|c_buffer| {
- unsafe { puts(c_buffer); }
-});
+fn main() {
+ let my_string = "Hello, world!";
+
+ // Allocate the C string with an explicit local that owns the string. The
+ // `c_buffer` pointer will be deallocated when `my_c_string` goes out of scope.
+ let my_c_string = my_string.to_c_str();
+ my_c_string.with_ref(|c_buffer| {
+ unsafe { puts(c_buffer); }
+ });
+
+ // Don't save off the allocation of the C string, the `c_buffer` will be
+ // deallocated when this block returns!
+ my_string.with_c_str(|c_buffer| {
+ unsafe { puts(c_buffer); }
+ });
+}
```
*/
/// # Example
///
/// ```rust
- /// use std::libc;
+ /// extern crate libc;
///
- /// let s = "PATH".with_c_str(|path| unsafe {
- /// libc::getenv(path)
- /// });
+ /// fn main() {
+ /// let s = "PATH".with_c_str(|path| unsafe {
+ /// libc::getenv(path)
+ /// });
+ /// }
/// ```
///
/// # Failure
///
/// ```rust
/// # #[allow(unused_must_use)];
- /// use std::libc;
+ /// extern crate libc;
+ ///
/// use std::io::pipe::PipeStream;
///
- /// let mut pipe = PipeStream::open(libc::STDERR_FILENO);
- /// pipe.write(bytes!("Hello, stderr!"));
+ /// fn main() {
+ /// let mut pipe = PipeStream::open(libc::STDERR_FILENO);
+ /// pipe.write(bytes!("Hello, stderr!"));
+ /// }
/// ```
pub fn open(fd: libc::c_int) -> IoResult<PipeStream> {
LocalIo::maybe_raise(|io| {
/// Returns the page size of the current architecture in bytes.
#[cfg(windows)]
pub fn page_size() -> uint {
+ use mem;
unsafe {
- let mut info = libc::SYSTEM_INFO::new();
+ let mut info = mem::uninit();
libc::GetSystemInfo(&mut info);
return info.dwPageSize as uint;
/// Granularity of MapAddr() and MapOffset() parameter values.
/// This may be greater than the value returned by page_size().
pub fn granularity() -> uint {
+ use mem;
unsafe {
- let mut info = libc::SYSTEM_INFO::new();
+ let mut info = mem::uninit();
libc::GetSystemInfo(&mut info);
return info.dwAllocationGranularity as uint;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+extern crate libc;
+
use codemap::{Pos, Span};
use codemap;
#[cfg(test)] #[phase(syntax, link)] extern crate log;
extern crate serialize;
+extern crate libc;
use std::io::BufReader;
-use std::libc;
use std::num;
use std::str;
#[cfg(unix, not(target_os = "macos"))]
mod imp {
- use std::libc::{c_int, timespec};
+ use libc::{c_int, timespec};
// Apparently android provides this in some other library?
#[cfg(not(target_os = "android"))]
}
#[cfg(target_os = "macos")]
mod imp {
- use std::libc::{timeval, timezone, c_int, mach_timebase_info};
+ use libc::{timeval, timezone, c_int, mach_timebase_info};
extern {
pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int;
#[cfg(windows)]
fn set_time_zone() {
- use std::libc;
+ use libc;
// Windows crt doesn't see any environment variable set by
// `SetEnvironmentVariable`, which `os::setenv` internally uses.
// It is why we use `putenv` here.
#[crate_id="anonexternmod#0.1"];
-use std::libc;
+extern crate libc;
#[link(name="rustrt")]
extern {
#[crate_id="externcallback#0.1"];
#[crate_type = "lib"];
-use std::libc;
+extern crate libc;
pub mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
#[crate_id="foreign_lib"];
pub mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
#[crate_type = "lib"];
pub mod socket {
- use std::libc;
+ extern crate libc;
pub struct socket_handle {
sockfd: libc::c_int,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
extern "C" {
pub fn rand() -> libc::c_int;
// statics cannot. This ensures that there's some form of error if this is
// attempted.
-use std::libc;
+extern crate libc;
extern {
static mut rust_dbg_static_mut: libc::c_int;
#![deny(ctypes)]
-use std::libc;
+extern crate libc;
extern {
pub fn bare_type1(size: int); //~ ERROR: found rust type
#![crate_type="lib"]
+extern crate libc;
+
struct Foo; //~ ERROR: code is never used
impl Foo {
fn foo(&self) { //~ ERROR: code is never used
}
mod blah {
- use std::libc::size_t;
+ use libc::size_t;
// not warned because it's used in the parameter of `free` and return of
// `malloc` below, which are also used.
enum c_void {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
fn main() {
let x : *Vec<int> = &vec!(1,2,3);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
extern {
static mut a: libc::c_int;
// error-pattern:unsupported cast
-use std::libc;
+extern crate libc;
fn main() {
println!("{:?}", 1.0 as *libc::FILE); // Can't cast float to foreign.
// Testing that runtime failure doesn't cause callbacks to abort abnormally.
// Instead the failure will be delivered after the callbacks return.
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
extern {
pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t)
// See the hack in upcall_call_shim_on_c_stack where it messes
// with the stack limit.
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
extern {
pub fn rust_get_argc() -> libc::c_int;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
#[link(name = "rustrt")]
extern {
// except according to those terms.
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-mod libc {
- use std::libc::{c_char, c_long, c_longlong};
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
+
+mod mlibc {
+ use libc::{c_char, c_long, c_longlong};
extern {
pub fn atol(x: *c_char) -> c_long;
}
fn atol(s: ~str) -> int {
- s.with_c_str(|x| unsafe { libc::atol(x) as int })
+ s.with_c_str(|x| unsafe { mlibc::atol(x) as int })
}
fn atoll(s: ~str) -> i64 {
- s.with_c_str(|x| unsafe { libc::atoll(x) as i64 })
+ s.with_c_str(|x| unsafe { mlibc::atoll(x) as i64 })
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
extern fn foo() {}
// instead of in std.
#[feature(macro_rules)];
+extern crate libc;
extern crate native;
extern crate green;
#[allow(unused_imports)];
use std::io::timer;
- use std::libc;
+ use libc;
use std::str;
use std::io::process::{Process, ProcessOutput};
use native;
pub fn test_destroy_actually_kills(force: bool) {
use std::io::process::{Process, ProcessOutput, ExitStatus, ExitSignal};
use std::io::timer;
- use std::libc;
+ use libc;
use std::str;
#[cfg(unix,not(target_os="android"))]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// make sure the stack pointers are maintained properly in both
// directions
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// This creates a bunch of descheduling tasks that run concurrently
// while holding onto C stacks
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+extern crate libc;
+
use std::cast;
-use std::libc;
use std::unstable::run_in_bare_thread;
#[link(name = "rustrt")]
// calling pin_task and that's having wierd side-effects.
mod rustrt1 {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
}
mod rustrt2 {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-mod libc {
- use std::libc::{c_char, size_t};
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
+
+mod mlibc {
+ extern crate libc;
+ use self::libc::{c_char, size_t};
extern {
#[link_name = "strlen"]
// C string is terminated with a zero
str.with_c_str(|buf| {
unsafe {
- libc::my_strlen(buf) as uint
+ mlibc::my_strlen(buf) as uint
}
})
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
+
mod foo {
- use std::libc::c_int;
+ use libc::c_int;
extern {
pub static errno: c_int;
// ABI is cdecl by default
mod rustrt {
- use std::libc;
+ extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
+
mod bar {
extern {}
}
extern {}
}
-mod libc {
- use std::libc::{c_int, c_void, size_t, ssize_t};
+mod mlibc {
+ use libc::{c_int, c_void, size_t, ssize_t};
extern {
pub fn write(fd: c_int, buf: *c_void, count: size_t) -> ssize_t;
#[crate_id="rust_get_test_int"];
mod rustrt {
- use std::libc;
+ extern crate libc;
extern {
pub fn rust_get_test_int() -> libc::intptr_t;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+extern crate libc;
+
use std::cast;
-use std::libc::{c_double, c_int};
+use libc::{c_double, c_int};
fn to_c_int(v: &mut int) -> &mut c_int {
unsafe {
}
mod m {
- use std::libc::{c_double, c_int};
+ use libc::{c_double, c_int};
#[link_name = "m"]
extern {
#[feature(managed_boxes)];
extern crate socketlib;
+extern crate libc;
use socketlib::socket;
-use std::libc;
pub fn main() {
let fd: libc::c_int = 1 as libc::c_int;
// Incorrect struct size computation in the FFI, because of not taking
// the alignment of elements into account.
-use std::libc::{c_uint, uint32_t, c_void};
+extern crate libc;
+use libc::{c_uint, uint32_t, c_void};
struct KEYGEN {
hash_algorithm: [c_uint, ..2],
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
use std::cast::transmute;
-use std::libc::c_void;
+use libc::c_void;
struct NonCopyable(*c_void);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
extern {
#[link_name = "malloc"]
mod test_foreign_items {
pub mod rustrt {
- use std::libc;
+ extern crate libc;
extern {
#[attr];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
extern {
fn rust_get_test_int() -> libc::intptr_t;
use std::task;
mod rustrt {
- use std::libc;
+ extern crate libc;
extern {
pub fn debug_get_stk_seg() -> *u8;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc::c_int;
-use std::libc;
+// ignore-fast doesn't like extern crate
+
+extern crate libc;
+use libc::c_int;
pub struct Fd(c_int);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
#[cfg(target_os = "macos")]
#[link(name = "CoreFoundation", kind = "framework")]
extern crate green;
extern crate rustuv;
+extern crate libc;
-use std::libc;
use std::io::process;
use std::io::signal::{Listener, Interrupt};
extern crate arena;
extern crate collections;
+extern crate libc;
use arena::Arena;
use collections::HashMap;
use std::cast;
-use std::libc;
use std::mem;
type Type<'tcx> = &'tcx TypeStructure<'tcx>;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+extern crate libc;
use std::cast;
-use std::libc;
use std::mem;
struct arena(());
// ignore-fast
+extern crate libc;
+
use std::io::TempDir;
use std::os;
-use std::libc;
use std::io;
use std::io::fs;
// statics cannot. This ensures that there's some form of error if this is
// attempted.
-use std::libc;
+extern crate libc;
#[link(name = "rustrt")]
extern {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
+extern crate libc;
pub fn main() {
let f = 1 as *libc::FILE;
#[feature(phase)];
#[phase(syntax, link)]
extern crate log;
+extern crate libc;
-use std::libc;
use std::io::net::ip::{Ipv4Addr, SocketAddr};
use std::io::net::tcp::{TcpListener, TcpStream};
use std::io::{Acceptor, Listener};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+extern crate libc;
use std::c_str::CString;
-use std::libc::{c_char, c_int};
+use libc::{c_char, c_int};
+
+// ignore-fast doesn't like extern crate
extern {
fn sprintf(s: *mut c_char, format: *c_char, ...) -> c_int;
projects / rust.git / commitdiff