fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}
-#[fixed_stack_segment]
fn main() {
let x = unsafe { snappy_max_compressed_length(100) };
- println(fmt!("max compressed length of a 100 byte buffer: %?", x));
+ println!("max compressed length of a 100 byte buffer: {}", x);
}
~~~~
valid for all possible inputs since the pointer could be dangling, and raw pointers fall outside of
Rust's safe memory model.
-Finally, the `#[fixed_stack_segment]` annotation that appears on
-`main()` instructs the Rust compiler that when `main()` executes, it
-should request a "very large" stack segment. More details on
-stack management can be found in the following sections.
-
When declaring the argument types to a foreign function, the Rust compiler will not check if the
declaration is correct, so specifying it correctly is part of keeping the binding correct at
runtime.
the allocated memory. The length is less than or equal to the capacity.
~~~~ {.xfail-test}
-#[fixed_stack_segment]
-#[inline(never)]
pub fn validate_compressed_buffer(src: &[u8]) -> bool {
unsafe {
snappy_validate_compressed_buffer(vec::raw::to_ptr(src), src.len() as size_t) == 0
guarantee that calling it is safe for all inputs by leaving off `unsafe` from the function
signature.
-The `validate_compressed_buffer` wrapper is also annotated with two
-attributes `#[fixed_stack_segment]` and `#[inline(never)]`. The
-purpose of these attributes is to guarantee that there will be
-sufficient stack for the C function to execute. This is necessary
-because Rust, unlike C, does not assume that the stack is allocated in
-one continuous chunk. Instead, we rely on a *segmented stack* scheme,
-in which the stack grows and shrinks as necessary. C code, however,
-expects one large stack, and so callers of C functions must request a
-large stack segment to ensure that the C routine will not run off the
-end of the stack.
-
-The compiler includes a lint mode that will report an error if you
-call a C function without a `#[fixed_stack_segment]` attribute. More
-details on the lint mode are given in a later section.
-
-You may be wondering why we include a `#[inline(never)]` directive.
-This directive informs the compiler never to inline this function.
-While not strictly necessary, it is usually a good idea to use an
-`#[inline(never)]` directive in concert with `#[fixed_stack_segment]`.
-The reason is that if a fn annotated with `fixed_stack_segment` is
-inlined, then its caller also inherits the `fixed_stack_segment`
-annotation. This means that rather than requesting a large stack
-segment only for the duration of the call into C, the large stack
-segment would be used for the entire duration of the caller. This is
-not necessarily *bad* -- it can for example be more efficient,
-particularly if `validate_compressed_buffer()` is called multiple
-times in a row -- but it does work against the purpose of the
-segmented stack scheme, which is to keep stacks small and thus
-conserve address space.
-
The `snappy_compress` and `snappy_uncompress` functions are more complex, since a buffer has to be
allocated to hold the output too.
~~~~ {.xfail-test}
pub fn compress(src: &[u8]) -> ~[u8] {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
~~~~ {.xfail-test}
pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
For reference, the examples used here are also available as an [library on
GitHub](https://github.com/thestinger/rust-snappy).
-# Automatic wrappers
-
-Sometimes writing Rust wrappers can be quite tedious. For example, if
-function does not take any pointer arguments, often there is no need
-for translating types. In such cases, it is usually still a good idea
-to have a Rust wrapper so as to manage the segmented stacks, but you
-can take advantage of the (standard) `externfn!` macro to remove some
-of the tedium.
-
-In the initial section, we showed an extern block that added a call
-to a specific snappy API:
-
-~~~~ {.xfail-test}
-use std::libc::size_t;
-
-#[link_args = "-lsnappy"]
-extern {
- fn snappy_max_compressed_length(source_length: size_t) -> size_t;
-}
-
-#[fixed_stack_segment]
-fn main() {
- let x = unsafe { snappy_max_compressed_length(100) };
- println(fmt!("max compressed length of a 100 byte buffer: %?", x));
-}
-~~~~
-
-To avoid the need to create a wrapper fn for `snappy_max_compressed_length()`,
-and also to avoid the need to think about `#[fixed_stack_segment]`, we
-could simply use the `externfn!` macro instead, as shown here:
-
-~~~~ {.xfail-test}
-use std::libc::size_t;
-
-externfn!(#[link_args = "-lsnappy"]
- fn snappy_max_compressed_length(source_length: size_t) -> size_t)
-
-fn main() {
- let x = unsafe { snappy_max_compressed_length(100) };
- println(fmt!("max compressed length of a 100 byte buffer: %?", x));
-}
-~~~~
-
-As you can see from the example, `externfn!` replaces the extern block
-entirely. After macro expansion, it will create something like this:
-
-~~~~ {.xfail-test}
-use std::libc::size_t;
-
-// Automatically generated by
-// externfn!(#[link_args = "-lsnappy"]
-// fn snappy_max_compressed_length(source_length: size_t) -> size_t)
-unsafe fn snappy_max_compressed_length(source_length: size_t) -> size_t {
- #[fixed_stack_segment]; #[inline(never)];
- return snappy_max_compressed_length(source_length);
-
- #[link_args = "-lsnappy"]
- extern {
- fn snappy_max_compressed_length(source_length: size_t) -> size_t;
- }
-}
-
-fn main() {
- let x = unsafe { snappy_max_compressed_length(100) };
- println(fmt!("max compressed length of a 100 byte buffer: %?", x));
-}
-~~~~
-
-# Segmented stacks and the linter
-
-By default, whenever you invoke a non-Rust fn, the `cstack` lint will
-check that one of the following conditions holds:
-
-1. The call occurs inside of a fn that has been annotated with
- `#[fixed_stack_segment]`;
-2. The call occurs inside of an `extern fn`;
-3. The call occurs within a stack closure created by some other
- safe fn.
-
-All of these conditions ensure that you are running on a large stack
-segment. However, they are sometimes too strict. If your application
-will be making many calls into C, it is often beneficial to promote
-the `#[fixed_stack_segment]` attribute higher up the call chain. For
-example, the Rust compiler actually labels main itself as requiring a
-`#[fixed_stack_segment]`. In such cases, the linter is just an
-annoyance, because all C calls that occur from within the Rust
-compiler are made on a large stack. Another situation where this
-frequently occurs is on a 64-bit architecture, where large stacks are
-the default. In cases, you can disable the linter by including a
-`#[allow(cstack)]` directive somewhere, which permits violations of
-the "cstack" rules given above (you can also use `#[warn(cstack)]` to
-convert the errors into warnings, if you prefer).
+# Stack management
+
+Rust tasks by default run on a "large stack". This is actually implemented as a
+reserving a large segment of the address space and then lazily mapping in pages
+as they are needed. When calling an external C function, the code is invoked on
+the same stack as the rust stack. This means that there is no extra
+stack-switching mechanism in place because it is assumed that the large stack
+for the rust task is plenty for the C function to have.
+
+A planned future improvement (net yet implemented at the time of this writing)
+is to have a guard page at the end of every rust stack. No rust function will
+hit this guard page (due to rust's usage of LLVM's __morestack). The intention
+for this unmapped page is to prevent infinite recursion in C from overflowing
+onto other rust stacks. If the guard page is hit, then the process will be
+terminated with a message saying that the guard page was hit.
+
+For normal external function usage, this all means that there shouldn't be any
+need for any extra effort on a user's perspective. The C stack naturally
+interleaves with the rust stack, and it's "large enough" for both to
+interoperate. If, however, it is determined that a larger stack is necessary,
+there are appropriate functions in the task spawning API to control the size of
+the stack of the task which is spawned.
# Destructors
impl<T: Send> Unique<T> {
pub fn new(value: T) -> Unique<T> {
- #[fixed_stack_segment];
- #[inline(never)];
-
unsafe {
let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;
assert!(!ptr::is_null(ptr));
#[unsafe_destructor]
impl<T: Send> Drop for Unique<T> {
fn drop(&mut self) {
- #[fixed_stack_segment];
- #[inline(never)];
-
unsafe {
let x = intrinsics::init(); // dummy value to swap in
// moving the object out is needed to call the destructor
}
fn main() {
- println(fmt!("You have readline version %d installed.",
- rl_readline_version as int));
+ println!("You have readline version {} installed.",
+ rl_readline_version as int);
}
~~~
}
impl Runnable for LibcFree {
- #[fixed_stack_segment]
fn run(~self) {
unsafe {
libc::free(self.mem)
}
fn malloc(n: size_t) -> CVec<u8> {
- #[fixed_stack_segment];
- #[inline(never)];
-
unsafe {
let mem = libc::malloc(n);
static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum
fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
- #[fixed_stack_segment]; #[inline(never)];
-
do bytes.as_imm_buf |b, len| {
unsafe {
let mut outsz : size_t = 0;
}
fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
- #[fixed_stack_segment]; #[inline(never)];
-
do bytes.as_imm_buf |b, len| {
unsafe {
let mut outsz : size_t = 0;
#[deny(non_camel_case_types)];
#[deny(missing_doc)];
+#[allow(unrecognized_lint)]; // NOTE: remove after the next snapshot
+#[allow(cstack)]; // NOTE: remove after the next snapshot.
use std::str::{StrSlice, OwnedStr};
}
fn usage(binary: &str, helpstr: &str) {
- #[fixed_stack_segment]; #[inline(never)];
-
let message = format!("Usage: {} [OPTIONS] [FILTER]", binary);
println(groups::usage(message, optgroups()));
println("");
* nanoseconds since 1970-01-01T00:00:00Z.
*/
pub fn get_time() -> Timespec {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let mut sec = 0i64;
let mut nsec = 0i32;
* in nanoseconds since an unspecified epoch.
*/
pub fn precise_time_ns() -> u64 {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let mut ns = 0u64;
rustrt::precise_time_ns(&mut ns);
}
pub fn tzset() {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
rustrt::rust_tzset();
}
/// Returns the specified time in UTC
pub fn at_utc(clock: Timespec) -> Tm {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let Timespec { sec, nsec } = clock;
let mut tm = empty_tm();
/// Returns the specified time in the local timezone
pub fn at(clock: Timespec) -> Tm {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let Timespec { sec, nsec } = clock;
let mut tm = empty_tm();
impl Tm {
/// Convert time to the seconds from January 1, 1970
pub fn to_timespec(&self) -> Timespec {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let sec = match self.tm_gmtoff {
0_i32 => rustrt::rust_timegm(self),
use std::libc;
#[cfg(windows)]
- #[fixed_stack_segment]
fn set_time_zone() {
// Windows crt doesn't see any environment variable set by
// `SetEnvironmentVariable`, which `os::setenv` internally uses.
time(time_passes, "loop checking", (), |_|
middle::check_loop::check_crate(ty_cx, crate));
- time(time_passes, "stack checking", (), |_|
- middle::stack_check::stack_check_crate(ty_cx, crate));
-
let middle::moves::MoveMaps {moves_map, moved_variables_set,
capture_map} =
time(time_passes, "compute moves", (), |_|
return false;
}
-#[fixed_stack_segment]
pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
outdir: &Option<Path>, output: &Option<Path>) {
// We need nested scopes here, because the intermediate results can keep
}
if debugging_opts & session::debug_llvm != 0 {
- set_llvm_debug();
-
- fn set_llvm_debug() {
- #[fixed_stack_segment]; #[inline(never)];
- unsafe { llvm::LLVMSetDebug(1); }
- }
+ unsafe { llvm::LLVMSetDebug(1); }
}
let output_type =
#[crate_type = "lib"];
#[feature(macro_rules, globs, struct_variant, managed_boxes)];
-
-// Rustc tasks always run on a fixed_stack_segment, so code in this
-// module can call C functions (in particular, LLVM functions) with
-// impunity.
-#[allow(cstack)];
+#[allow(unrecognized_lint)]; // NOTE: remove after the next snapshot
+#[allow(cstack)]; // NOTE: remove after the next snapshot.
extern mod extra;
extern mod syntax;
pub mod reachable;
pub mod graph;
pub mod cfg;
- pub mod stack_check;
}
pub mod front {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// LLVM wrappers are intended to be called from trans,
-// which already runs in a #[fixed_stack_segment]
-#[allow(cstack)];
#[allow(non_uppercase_pattern_statics)];
use std::c_str::ToCStr;
#[deriving(Clone, Eq)]
pub enum lint {
ctypes,
- cstack,
unused_imports,
unnecessary_qualification,
while_true,
default: warn
}),
- ("cstack",
- LintSpec {
- lint: cstack,
- desc: "only invoke foreign functions from fixedstacksegment fns",
- default: deny
- }),
-
("unused_imports",
LintSpec {
lint: unused_imports,
+++ /dev/null
-// Copyright 2012-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.
-
-/*!
-
-Lint mode to detect cases where we call non-Rust fns, which do not
-have a stack growth check, from locations not annotated to request
-large stacks.
-
-*/
-
-use middle::lint;
-use middle::ty;
-use syntax::ast;
-use syntax::ast_map;
-use syntax::attr;
-use syntax::codemap::Span;
-use syntax::visit;
-use syntax::visit::Visitor;
-use util::ppaux::Repr;
-
-#[deriving(Clone)]
-struct Context {
- safe_stack: bool
-}
-
-struct StackCheckVisitor {
- tcx: ty::ctxt,
-}
-
-impl Visitor<Context> for StackCheckVisitor {
- fn visit_item(&mut self, i:@ast::item, e:Context) {
- stack_check_item(self, i, e);
- }
- fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
- b:&ast::Block, s:Span, n:ast::NodeId, e:Context) {
- stack_check_fn(self, fk, fd, b, s, n, e);
- }
- fn visit_expr(&mut self, ex:@ast::Expr, e:Context) {
- stack_check_expr(self, ex, e);
- }
-}
-
-pub fn stack_check_crate(tcx: ty::ctxt,
- crate: &ast::Crate) {
- let new_cx = Context { safe_stack: false };
- let mut visitor = StackCheckVisitor { tcx: tcx };
- visit::walk_crate(&mut visitor, crate, new_cx);
-}
-
-fn stack_check_item(v: &mut StackCheckVisitor,
- item: @ast::item,
- in_cx: Context) {
- match item.node {
- ast::item_fn(_, ast::extern_fn, _, _, _) => {
- // an extern fn is already being called from C code...
- let new_cx = Context {safe_stack: true};
- visit::walk_item(v, item, new_cx);
- }
- ast::item_fn(*) => {
- let safe_stack = fixed_stack_segment(item.attrs);
- let new_cx = Context {safe_stack: safe_stack};
- visit::walk_item(v, item, new_cx);
- }
- ast::item_impl(_, _, _, ref methods) => {
- // visit_method() would make this nicer
- for &method in methods.iter() {
- let safe_stack = fixed_stack_segment(method.attrs);
- let new_cx = Context {safe_stack: safe_stack};
- visit::walk_method_helper(v, method, new_cx);
- }
- }
- ast::item_trait(_, _, ref methods) => {
- for method in methods.iter() {
- match *method {
- ast::provided(@ref method) => {
- let safe_stack = fixed_stack_segment(method.attrs);
- let new_cx = Context {safe_stack: safe_stack};
- visit::walk_method_helper(v, method, new_cx);
- }
- ast::required(*) => ()
- }
- }
- }
- _ => {
- visit::walk_item(v, item, in_cx);
- }
- }
-
- fn fixed_stack_segment(attrs: &[ast::Attribute]) -> bool {
- attr::contains_name(attrs, "fixed_stack_segment")
- }
-}
-
-fn stack_check_fn<'a>(v: &mut StackCheckVisitor,
- fk: &visit::fn_kind,
- decl: &ast::fn_decl,
- body: &ast::Block,
- sp: Span,
- id: ast::NodeId,
- in_cx: Context) {
- let safe_stack = match *fk {
- visit::fk_method(*) | visit::fk_item_fn(*) => {
- in_cx.safe_stack // see stack_check_item above
- }
- visit::fk_anon(*) | visit::fk_fn_block => {
- match ty::get(ty::node_id_to_type(v.tcx, id)).sty {
- ty::ty_bare_fn(*) |
- ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, _}) => {
- false
- }
- _ => {
- in_cx.safe_stack
- }
- }
- }
- };
- let new_cx = Context {safe_stack: safe_stack};
- debug!("stack_check_fn(safe_stack={}, id={:?})", safe_stack, id);
- visit::walk_fn(v, fk, decl, body, sp, id, new_cx);
-}
-
-fn stack_check_expr<'a>(v: &mut StackCheckVisitor,
- expr: @ast::Expr,
- cx: Context) {
- debug!("stack_check_expr(safe_stack={}, expr={})",
- cx.safe_stack, expr.repr(v.tcx));
- if !cx.safe_stack {
- match expr.node {
- ast::ExprCall(callee, _, _) => {
- let callee_ty = ty::expr_ty(v.tcx, callee);
- debug!("callee_ty={}", callee_ty.repr(v.tcx));
- match ty::get(callee_ty).sty {
- ty::ty_bare_fn(ref fty) => {
- if !fty.abis.is_rust() && !fty.abis.is_intrinsic() {
- call_to_extern_fn(v, callee);
- }
- }
- _ => {}
- }
- }
- _ => {}
- }
- }
- visit::walk_expr(v, expr, cx);
-}
-
-fn call_to_extern_fn(v: &mut StackCheckVisitor, callee: @ast::Expr) {
- // Permit direct calls to extern fns that are annotated with
- // #[rust_stack]. This is naturally a horrible pain to achieve.
- match callee.node {
- ast::ExprPath(*) => {
- match v.tcx.def_map.find(&callee.id) {
- Some(&ast::DefFn(id, _)) if id.crate == ast::LOCAL_CRATE => {
- match v.tcx.items.find(&id.node) {
- Some(&ast_map::node_foreign_item(item, _, _, _)) => {
- if attr::contains_name(item.attrs, "rust_stack") {
- return;
- }
- }
- _ => {}
- }
- }
- _ => {}
- }
- }
- _ => {}
- }
-
- v.tcx.sess.add_lint(lint::cstack,
- callee.id,
- callee.span,
- format!("invoking non-Rust fn in fn without \
- \\#[fixed_stack_segment]"));
-}
lib::llvm::SetFunctionAttribute(f, lib::llvm::AlwaysInlineAttribute)
}
-pub fn set_fixed_stack_segment(f: ValueRef) {
- do "fixed-stack-segment".with_c_str |buf| {
- unsafe { llvm::LLVMAddFunctionAttrString(f, buf); }
- }
-}
-
pub fn set_no_split_stack(f: ValueRef) {
do "no-split-stack".with_c_str |buf| {
unsafe { llvm::LLVMAddFunctionAttrString(f, buf); }
self_arg: self_arg,
param_substs: Option<@param_substs>,
id: ast::NodeId,
- attributes: &[ast::Attribute],
+ _attributes: &[ast::Attribute],
output_type: ty::t,
maybe_load_env: &fn(@mut FunctionContext)) {
ccx.stats.n_closures += 1;
let arg_tys = ty::ty_fn_args(node_id_type(bcx, id));
let raw_llargs = create_llargs_for_fn_args(fcx, self_arg, decl.inputs);
- // Set the fixed stack segment flag if necessary.
- if attr::contains_name(attributes, "fixed_stack_segment") {
- set_no_inline(fcx.llfn);
- set_fixed_stack_segment(fcx.llfn);
- }
-
bcx = copy_args_to_allocas(fcx, bcx, decl.inputs, raw_llargs, arg_tys);
maybe_load_env(fcx);
use middle::ty;
use syntax::ast;
use syntax::ast_map;
-use syntax::attr;
use util::ppaux::ty_to_str;
use middle::trans::machine::llsize_of;
use middle::trans::type_::Type;
item: &ast::foreign_item,
path: ast_map::path,
substs: @param_substs,
- attributes: &[ast::Attribute],
+ _attributes: &[ast::Attribute],
ref_id: Option<ast::NodeId>) {
debug!("trans_intrinsic(item.ident={})", ccx.sess.str_of(item.ident));
set_always_inline(fcx.llfn);
- // Set the fixed stack segment flag if necessary.
- if attr::contains_name(attributes, "fixed_stack_segment") {
- set_fixed_stack_segment(fcx.llfn);
- }
-
let mut bcx = fcx.entry_bcx.unwrap();
let first_real_arg = fcx.arg_pos(0u);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[allow(cstack)]; // each rendering task runs on a fixed stack segment.
-
//! Markdown formatting for rustdoc
//!
//! This module implements markdown formatting through the sundown C-library
port: &SharedPort<Work>,
chan: &SharedChan<Work>,
prog_chan: &SharedChan<Progress>) {
- #[fixed_stack_segment]; // we hit markdown FFI *a lot*
local_data::set(cache_key, cache);
loop {
#[cfg(target_os = "win32")]
pub fn chmod_read_only(p: &Path) -> bool {
- #[fixed_stack_segment];
unsafe {
do p.with_c_str |src_buf| {
libc::chmod(src_buf, S_IRUSR as libc::c_int) == 0 as libc::c_int
#[cfg(not(target_os = "win32"))]
pub fn chmod_read_only(p: &Path) -> bool {
- #[fixed_stack_segment];
unsafe {
do p.with_c_str |src_buf| {
libc::chmod(src_buf, S_IRUSR as libc::mode_t) == 0
let dir = dir.path();
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
- \n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
+ \nfn main() { unsafe { f(); } }");
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
debug!("dir = {}", dir.display());
let dir = dir.path();
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
- \n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
+ \nfn main() { unsafe { f(); } }");
writeFile(&dir.join_many(["src", "cdep-0.1", "foo.c"]), "void f() {}");
debug!("dir = {}", dir.display());
let dir = dir.path();
writeFile(&dir.join_many(["src", "cdep-0.1", "main.rs"]),
"#[link_args = \"-lfoo\"]\nextern { fn f(); } \
- \n#[fixed_stack_segment]\nfn main() { unsafe { f(); } }");
+ \nfn main() { unsafe { f(); } }");
let c_file_name = dir.join_many(["src", "cdep-0.1", "foo.c"]);
writeFile(&c_file_name, "void f() {}");
}
fn seek_common(&mut self, pos: i64, whence: c_int) ->
Result<u64, IoError>{
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
match libc::lseek(self.fd, pos as libc::off_t, whence) {
-1 => {
#[crate_type = "lib"];
#[feature(macro_rules, globs)];
+#[allow(unrecognized_lint)]; // NOTE: remove after the next snapshot
+#[allow(cstack)]; // NOTE: remove after the next snapshot.
use std::cast::transmute;
use std::cast;
/// Generic functions related to dealing with sockaddr things
////////////////////////////////////////////////////////////////////////////////
-#[fixed_stack_segment]
fn socket_addr_as_sockaddr<T>(addr: SocketAddr, f: &fn(*sockaddr) -> T) -> T {
let malloc = match addr.ip {
Ipv4Addr(*) => uvll::rust_malloc_ip4_addr,
}
}
-#[fixed_stack_segment]
pub fn sockaddr_to_socket_addr(addr: *sockaddr) -> SocketAddr {
unsafe {
let ip_size = if uvll::rust_is_ipv4_sockaddr(addr) == 1 {
Udp
}
-#[fixed_stack_segment]
fn socket_name(sk: SocketNameKind, handle: *c_void) -> Result<SocketAddr, IoError> {
unsafe {
let getsockname = match sk {
}
pub unsafe fn malloc_handle(handle: uv_handle_type) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
assert!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX);
let size = uv_handle_size(handle);
let p = malloc(size);
}
pub unsafe fn free_handle(v: *c_void) {
- #[fixed_stack_segment]; #[inline(never)];
-
free(v)
}
pub unsafe fn malloc_req(req: uv_req_type) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
assert!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX);
let size = uv_req_size(req);
let p = malloc(size);
}
pub unsafe fn free_req(v: *c_void) {
- #[fixed_stack_segment]; #[inline(never)];
-
free(v)
}
#[test]
fn handle_sanity_check() {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
assert_eq!(UV_HANDLE_TYPE_MAX as uint, rust_uv_handle_type_max());
}
#[test]
fn request_sanity_check() {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
assert_eq!(UV_REQ_TYPE_MAX as uint, rust_uv_req_type_max());
}
// XXX Event loops ignore SIGPIPE by default.
pub unsafe fn loop_new() -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_loop_new();
}
-pub unsafe fn get_udp_handle_from_send_req(send_req: *uv_udp_send_t) -> *uv_udp_t {
- #[fixed_stack_segment]; #[inline(never)];
-
- return rust_uv_get_udp_handle_from_send_req(send_req);
-}
-
pub unsafe fn uv_write(req: *uv_write_t,
stream: *uv_stream_t,
buf_in: &[uv_buf_t],
cb: uv_write_cb) -> c_int {
- externfn!(fn uv_write(req: *uv_write_t, stream: *uv_stream_t,
- buf_in: *uv_buf_t, buf_cnt: c_int,
- cb: uv_write_cb) -> c_int)
+ extern {
+ fn uv_write(req: *uv_write_t, stream: *uv_stream_t,
+ buf_in: *uv_buf_t, buf_cnt: c_int,
+ cb: uv_write_cb) -> c_int;
+ }
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return uv_write(req, stream, buf_ptr, buf_cnt, cb);
}
+pub unsafe fn uv_udp_send(req: *uv_udp_send_t,
+ handle: *uv_udp_t,
+ buf_in: &[uv_buf_t],
+ addr: *sockaddr,
+ cb: uv_udp_send_cb) -> c_int {
+ extern {
+ fn uv_udp_send(req: *uv_write_t, stream: *uv_stream_t,
+ buf_in: *uv_buf_t, buf_cnt: c_int, addr: *sockaddr,
+ cb: uv_udp_send_cb) -> c_int;
+ }
+
+ let buf_ptr = vec::raw::to_ptr(buf_in);
+ let buf_cnt = buf_in.len() as i32;
+ return uv_udp_send(req, handle, buf_ptr, buf_cnt, addr, cb);
+}
+
+pub unsafe fn get_udp_handle_from_send_req(send_req: *uv_udp_send_t) -> *uv_udp_t {
+ return rust_uv_get_udp_handle_from_send_req(send_req);
+}
+
pub unsafe fn process_pid(p: *uv_process_t) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_process_pid(p);
}
pub unsafe fn set_stdio_container_flags(c: *uv_stdio_container_t,
flags: libc::c_int) {
- #[fixed_stack_segment]; #[inline(never)];
+
rust_set_stdio_container_flags(c, flags);
}
pub unsafe fn set_stdio_container_fd(c: *uv_stdio_container_t,
fd: libc::c_int) {
- #[fixed_stack_segment]; #[inline(never)];
+
rust_set_stdio_container_fd(c, fd);
}
pub unsafe fn set_stdio_container_stream(c: *uv_stdio_container_t,
stream: *uv_stream_t) {
- #[fixed_stack_segment]; #[inline(never)];
rust_set_stdio_container_stream(c, stream);
}
// data access helpers
pub unsafe fn get_result_from_fs_req(req: *uv_fs_t) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_result_from_fs_req(req)
}
pub unsafe fn get_ptr_from_fs_req(req: *uv_fs_t) -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_ptr_from_fs_req(req)
}
pub unsafe fn get_path_from_fs_req(req: *uv_fs_t) -> *c_char {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_path_from_fs_req(req)
}
pub unsafe fn get_loop_from_fs_req(req: *uv_fs_t) -> *uv_loop_t {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_loop_from_fs_req(req)
}
pub unsafe fn get_loop_from_getaddrinfo_req(req: *uv_getaddrinfo_t) -> *uv_loop_t {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_loop_from_getaddrinfo_req(req)
}
pub unsafe fn get_loop_for_uv_handle<T>(handle: *T) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_get_loop_for_uv_handle(handle as *c_void);
}
pub unsafe fn get_stream_handle_from_connect_req(connect: *uv_connect_t) -> *uv_stream_t {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_get_stream_handle_from_connect_req(connect);
}
pub unsafe fn get_stream_handle_from_write_req(write_req: *uv_write_t) -> *uv_stream_t {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_get_stream_handle_from_write_req(write_req);
}
pub unsafe fn get_data_for_uv_loop(loop_ptr: *c_void) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_get_data_for_uv_loop(loop_ptr)
}
pub unsafe fn set_data_for_uv_loop(loop_ptr: *c_void, data: *c_void) {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_set_data_for_uv_loop(loop_ptr, data);
}
pub unsafe fn get_data_for_uv_handle<T>(handle: *T) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_get_data_for_uv_handle(handle as *c_void);
}
pub unsafe fn set_data_for_uv_handle<T, U>(handle: *T, data: *U) {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_set_data_for_uv_handle(handle as *c_void, data as *c_void);
}
pub unsafe fn get_data_for_req<T>(req: *T) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_get_data_for_req(req as *c_void);
}
pub unsafe fn set_data_for_req<T, U>(req: *T, data: *U) {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_set_data_for_req(req as *c_void, data as *c_void);
}
pub unsafe fn populate_stat(req_in: *uv_fs_t, stat_out: *uv_stat_t) {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_populate_uv_stat(req_in, stat_out)
}
pub unsafe fn guess_handle(handle: c_int) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
-
rust_uv_guess_handle(handle)
}
stream: *uv_stream_t);
fn rust_uv_process_pid(p: *uv_process_t) -> c_int;
fn rust_uv_guess_handle(fd: c_int) -> c_int;
-}
-
-// generic uv functions
-externfn!(fn uv_loop_delete(l: *uv_loop_t))
-externfn!(fn uv_handle_size(ty: uv_handle_type) -> size_t)
-externfn!(fn uv_req_size(ty: uv_req_type) -> size_t)
-externfn!(fn uv_run(l: *uv_loop_t, mode: uv_run_mode) -> c_int)
-externfn!(fn uv_close(h: *uv_handle_t, cb: uv_close_cb))
-externfn!(fn uv_walk(l: *uv_loop_t, cb: uv_walk_cb, arg: *c_void))
-externfn!(fn uv_buf_init(base: *c_char, len: c_uint) -> uv_buf_t)
-externfn!(fn uv_strerror(err: c_int) -> *c_char)
-externfn!(fn uv_err_name(err: c_int) -> *c_char)
-externfn!(fn uv_listen(s: *uv_stream_t, backlog: c_int,
- cb: uv_connection_cb) -> c_int)
-externfn!(fn uv_accept(server: *uv_stream_t, client: *uv_stream_t) -> c_int)
-externfn!(fn uv_read_start(stream: *uv_stream_t,
- on_alloc: uv_alloc_cb,
- on_read: uv_read_cb) -> c_int)
-externfn!(fn uv_read_stop(stream: *uv_stream_t) -> c_int)
-
-// idle bindings
-externfn!(fn uv_idle_init(l: *uv_loop_t, i: *uv_idle_t) -> c_int)
-externfn!(fn uv_idle_start(i: *uv_idle_t, cb: uv_idle_cb) -> c_int)
-externfn!(fn uv_idle_stop(i: *uv_idle_t) -> c_int)
-
-// async bindings
-externfn!(fn uv_async_init(l: *uv_loop_t, a: *uv_async_t,
- cb: uv_async_cb) -> c_int)
-externfn!(fn uv_async_send(a: *uv_async_t))
-
-// tcp bindings
-externfn!(fn uv_tcp_init(l: *uv_loop_t, h: *uv_tcp_t) -> c_int)
-externfn!(fn uv_tcp_connect(c: *uv_connect_t, h: *uv_tcp_t,
- addr: *sockaddr, cb: uv_connect_cb) -> c_int)
-externfn!(fn uv_tcp_bind(t: *uv_tcp_t, addr: *sockaddr) -> c_int)
-externfn!(fn uv_ip4_name(src: *sockaddr, dst: *c_char,
- size: size_t) -> c_int)
-externfn!(fn uv_ip6_name(src: *sockaddr, dst: *c_char,
- size: size_t) -> c_int)
-externfn!(fn uv_tcp_nodelay(h: *uv_tcp_t, enable: c_int) -> c_int)
-externfn!(fn uv_tcp_keepalive(h: *uv_tcp_t, enable: c_int,
- delay: c_uint) -> c_int)
-externfn!(fn uv_tcp_simultaneous_accepts(h: *uv_tcp_t, enable: c_int) -> c_int)
-externfn!(fn uv_tcp_getsockname(h: *uv_tcp_t, name: *sockaddr,
- len: *mut c_int) -> c_int)
-externfn!(fn uv_tcp_getpeername(h: *uv_tcp_t, name: *sockaddr,
- len: *mut c_int) -> c_int)
-externfn!(fn uv_ip4_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int)
-externfn!(fn uv_ip6_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int)
-
-// udp bindings
-externfn!(fn uv_udp_init(l: *uv_loop_t, h: *uv_udp_t) -> c_int)
-externfn!(fn uv_udp_bind(h: *uv_udp_t, addr: *sockaddr, flags: c_uint) -> c_int)
-externfn!(fn uv_udp_recv_start(server: *uv_udp_t,
- on_alloc: uv_alloc_cb,
- on_recv: uv_udp_recv_cb) -> c_int)
-externfn!(fn uv_udp_set_membership(handle: *uv_udp_t, multicast_addr: *c_char,
- interface_addr: *c_char,
- membership: uv_membership) -> c_int)
-externfn!(fn uv_udp_recv_stop(server: *uv_udp_t) -> c_int)
-externfn!(fn uv_udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int)
-externfn!(fn uv_udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int)
-externfn!(fn uv_udp_set_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int)
-externfn!(fn uv_udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int)
-externfn!(fn uv_udp_getsockname(h: *uv_udp_t, name: *sockaddr,
- len: *mut c_int) -> c_int)
-
-pub unsafe fn uv_udp_send(req: *uv_udp_send_t,
- handle: *uv_udp_t,
- buf_in: &[uv_buf_t],
- addr: *sockaddr,
- cb: uv_udp_send_cb) -> c_int {
- externfn!(fn uv_udp_send(req: *uv_write_t, stream: *uv_stream_t,
- buf_in: *uv_buf_t, buf_cnt: c_int, addr: *sockaddr,
- cb: uv_udp_send_cb) -> c_int)
- let buf_ptr = vec::raw::to_ptr(buf_in);
- let buf_cnt = buf_in.len() as i32;
- return uv_udp_send(req, handle, buf_ptr, buf_cnt, addr, cb);
+ // generic uv functions
+ pub fn uv_loop_delete(l: *uv_loop_t);
+ pub fn uv_handle_size(ty: uv_handle_type) -> size_t;
+ pub fn uv_req_size(ty: uv_req_type) -> size_t;
+ pub fn uv_run(l: *uv_loop_t, mode: uv_run_mode) -> c_int;
+ pub fn uv_close(h: *uv_handle_t, cb: uv_close_cb);
+ pub fn uv_walk(l: *uv_loop_t, cb: uv_walk_cb, arg: *c_void);
+ pub fn uv_buf_init(base: *c_char, len: c_uint) -> uv_buf_t;
+ pub fn uv_strerror(err: c_int) -> *c_char;
+ pub fn uv_err_name(err: c_int) -> *c_char;
+ pub fn uv_listen(s: *uv_stream_t, backlog: c_int,
+ cb: uv_connection_cb) -> c_int;
+ pub fn uv_accept(server: *uv_stream_t, client: *uv_stream_t) -> c_int;
+ pub fn uv_read_start(stream: *uv_stream_t,
+ on_alloc: uv_alloc_cb,
+ on_read: uv_read_cb) -> c_int;
+ pub fn uv_read_stop(stream: *uv_stream_t) -> c_int;
+
+ // idle bindings
+ pub fn uv_idle_init(l: *uv_loop_t, i: *uv_idle_t) -> c_int;
+ pub fn uv_idle_start(i: *uv_idle_t, cb: uv_idle_cb) -> c_int;
+ pub fn uv_idle_stop(i: *uv_idle_t) -> c_int;
+
+ // async bindings
+ pub fn uv_async_init(l: *uv_loop_t, a: *uv_async_t,
+ cb: uv_async_cb) -> c_int;
+ pub fn uv_async_send(a: *uv_async_t);
+
+ // tcp bindings
+ pub fn uv_tcp_init(l: *uv_loop_t, h: *uv_tcp_t) -> c_int;
+ pub fn uv_tcp_connect(c: *uv_connect_t, h: *uv_tcp_t,
+ addr: *sockaddr, cb: uv_connect_cb) -> c_int;
+ pub fn uv_tcp_bind(t: *uv_tcp_t, addr: *sockaddr) -> c_int;
+ pub fn uv_ip4_name(src: *sockaddr, dst: *c_char,
+ size: size_t) -> c_int;
+ pub fn uv_ip6_name(src: *sockaddr, dst: *c_char,
+ size: size_t) -> c_int;
+ pub fn uv_tcp_nodelay(h: *uv_tcp_t, enable: c_int) -> c_int;
+ pub fn uv_tcp_keepalive(h: *uv_tcp_t, enable: c_int,
+ delay: c_uint) -> c_int;
+ pub fn uv_tcp_simultaneous_accepts(h: *uv_tcp_t, enable: c_int) -> c_int;
+ pub fn uv_tcp_getsockname(h: *uv_tcp_t, name: *sockaddr,
+ len: *mut c_int) -> c_int;
+ pub fn uv_tcp_getpeername(h: *uv_tcp_t, name: *sockaddr,
+ len: *mut c_int) -> c_int;
+ pub fn uv_ip4_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int;
+ pub fn uv_ip6_addr(ip: *c_char, port: c_int, addr: *sockaddr) -> c_int;
+
+ // udp bindings
+ pub fn uv_udp_init(l: *uv_loop_t, h: *uv_udp_t) -> c_int;
+ pub fn uv_udp_bind(h: *uv_udp_t, addr: *sockaddr, flags: c_uint) -> c_int;
+ pub fn uv_udp_recv_start(server: *uv_udp_t,
+ on_alloc: uv_alloc_cb,
+ on_recv: uv_udp_recv_cb) -> c_int;
+ pub fn uv_udp_set_membership(handle: *uv_udp_t, multicast_addr: *c_char,
+ interface_addr: *c_char,
+ membership: uv_membership) -> c_int;
+ pub fn uv_udp_recv_stop(server: *uv_udp_t) -> c_int;
+ pub fn uv_udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int;
+ pub fn uv_udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int;
+ pub fn uv_udp_set_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int;
+ pub fn uv_udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int;
+ pub fn uv_udp_getsockname(h: *uv_udp_t, name: *sockaddr,
+ len: *mut c_int) -> c_int;
+
+ // timer bindings
+ pub fn uv_timer_init(l: *uv_loop_t, t: *uv_timer_t) -> c_int;
+ pub fn uv_timer_start(t: *uv_timer_t, cb: uv_timer_cb,
+ timeout: libc::uint64_t,
+ repeat: libc::uint64_t) -> c_int;
+ pub fn uv_timer_stop(handle: *uv_timer_t) -> c_int;
+
+ // fs operations
+ pub fn uv_fs_open(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ flags: c_int, mode: c_int, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_unlink(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_write(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
+ len: size_t, offset: i64, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_read(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
+ len: size_t, offset: i64, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_close(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_stat(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_fstat(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_mkdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ mode: c_int, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_rmdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_readdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ flags: c_int, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_req_cleanup(req: *uv_fs_t);
+ pub fn uv_fs_fsync(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_fdatasync(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_ftruncate(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
+ offset: i64, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_readlink(handle: *uv_loop_t, req: *uv_fs_t, file: *c_char,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_symlink(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
+ dst: *c_char, flags: c_int, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_rename(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
+ dst: *c_char, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_utime(handle: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ atime: c_double, mtime: c_double,
+ cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_link(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
+ dst: *c_char, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_chown(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
+ uid: uv_uid_t, gid: uv_gid_t, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_chmod(handle: *uv_loop_t, req: *uv_fs_t, path: *c_char,
+ mode: c_int, cb: uv_fs_cb) -> c_int;
+ pub fn uv_fs_lstat(handle: *uv_loop_t, req: *uv_fs_t, file: *c_char,
+ cb: uv_fs_cb) -> c_int;
+
+ // getaddrinfo
+ pub fn uv_getaddrinfo(loop_: *uv_loop_t, req: *uv_getaddrinfo_t,
+ getaddrinfo_cb: uv_getaddrinfo_cb,
+ node: *c_char, service: *c_char,
+ hints: *addrinfo) -> c_int;
+ pub fn uv_freeaddrinfo(ai: *addrinfo);
+
+ // process spawning
+ pub fn uv_spawn(loop_ptr: *uv_loop_t, outptr: *uv_process_t,
+ options: *uv_process_options_t) -> c_int;
+ pub fn uv_process_kill(p: *uv_process_t, signum: c_int) -> c_int;
+
+ // pipes
+ pub fn uv_pipe_init(l: *uv_loop_t, p: *uv_pipe_t, ipc: c_int) -> c_int;
+ pub fn uv_pipe_open(pipe: *uv_pipe_t, file: c_int) -> c_int;
+ pub fn uv_pipe_bind(pipe: *uv_pipe_t, name: *c_char) -> c_int;
+ pub fn uv_pipe_connect(req: *uv_connect_t, handle: *uv_pipe_t,
+ name: *c_char, cb: uv_connect_cb);
+
+ // tty
+ pub fn uv_tty_init(l: *uv_loop_t, tty: *uv_tty_t, fd: c_int,
+ readable: c_int) -> c_int;
+ pub fn uv_tty_set_mode(tty: *uv_tty_t, mode: c_int) -> c_int;
+ pub fn uv_tty_get_winsize(tty: *uv_tty_t, width: *c_int,
+ height: *c_int) -> c_int;
+
+ // signals
+ pub fn uv_signal_init(loop_: *uv_loop_t, handle: *uv_signal_t) -> c_int;
+ pub fn uv_signal_start(h: *uv_signal_t, cb: uv_signal_cb,
+ signum: c_int) -> c_int;
+ pub fn uv_signal_stop(handle: *uv_signal_t) -> c_int;
}
-// timer bindings
-externfn!(fn uv_timer_init(l: *uv_loop_t, t: *uv_timer_t) -> c_int)
-externfn!(fn uv_timer_start(t: *uv_timer_t, cb: uv_timer_cb,
- timeout: libc::uint64_t,
- repeat: libc::uint64_t) -> c_int)
-externfn!(fn uv_timer_stop(handle: *uv_timer_t) -> c_int)
-
-// fs operations
-externfn!(fn uv_fs_open(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- flags: c_int, mode: c_int, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_unlink(loop_ptr: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_write(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
- len: size_t, offset: i64, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_read(l: *uv_loop_t, req: *uv_fs_t, fd: c_int, buf: *c_void,
- len: size_t, offset: i64, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_close(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_stat(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_fstat(l: *uv_loop_t, req: *uv_fs_t, fd: c_int,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_mkdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- mode: c_int, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_rmdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_readdir(l: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- flags: c_int, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_req_cleanup(req: *uv_fs_t))
-externfn!(fn uv_fs_fsync(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_fdatasync(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_ftruncate(handle: *uv_loop_t, req: *uv_fs_t, file: c_int,
- offset: i64, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_readlink(handle: *uv_loop_t, req: *uv_fs_t, file: *c_char,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_symlink(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
- dst: *c_char, flags: c_int, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_rename(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
- dst: *c_char, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_utime(handle: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- atime: c_double, mtime: c_double,
- cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_link(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
- dst: *c_char, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_chown(handle: *uv_loop_t, req: *uv_fs_t, src: *c_char,
- uid: uv_uid_t, gid: uv_gid_t, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_chmod(handle: *uv_loop_t, req: *uv_fs_t, path: *c_char,
- mode: c_int, cb: uv_fs_cb) -> c_int)
-externfn!(fn uv_fs_lstat(handle: *uv_loop_t, req: *uv_fs_t, file: *c_char,
- cb: uv_fs_cb) -> c_int)
-
-// getaddrinfo
-externfn!(fn uv_getaddrinfo(loop_: *uv_loop_t, req: *uv_getaddrinfo_t,
- getaddrinfo_cb: uv_getaddrinfo_cb,
- node: *c_char, service: *c_char,
- hints: *addrinfo) -> c_int)
-externfn!(fn uv_freeaddrinfo(ai: *addrinfo))
-
-// process spawning
-externfn!(fn uv_spawn(loop_ptr: *uv_loop_t, outptr: *uv_process_t,
- options: *uv_process_options_t) -> c_int)
-externfn!(fn uv_process_kill(p: *uv_process_t, signum: c_int) -> c_int)
-
-// pipes
-externfn!(fn uv_pipe_init(l: *uv_loop_t, p: *uv_pipe_t, ipc: c_int) -> c_int)
-externfn!(fn uv_pipe_open(pipe: *uv_pipe_t, file: c_int) -> c_int)
-externfn!(fn uv_pipe_bind(pipe: *uv_pipe_t, name: *c_char) -> c_int)
-externfn!(fn uv_pipe_connect(req: *uv_connect_t, handle: *uv_pipe_t,
- name: *c_char, cb: uv_connect_cb))
-
-// tty
-externfn!(fn uv_tty_init(l: *uv_loop_t, tty: *uv_tty_t, fd: c_int,
- readable: c_int) -> c_int)
-externfn!(fn uv_tty_set_mode(tty: *uv_tty_t, mode: c_int) -> c_int)
-externfn!(fn uv_tty_get_winsize(tty: *uv_tty_t, width: *c_int,
- height: *c_int) -> c_int)
-
-// signals
-externfn!(fn uv_signal_init(loop_: *uv_loop_t, handle: *uv_signal_t) -> c_int)
-externfn!(fn uv_signal_start(h: *uv_signal_t, cb: uv_signal_cb,
- signum: c_int) -> c_int)
-externfn!(fn uv_signal_stop(handle: *uv_signal_t) -> c_int)
-
// libuv requires various system libraries to successfully link on some
// platforms
#[cfg(target_os = "linux")]
```rust
use std::libc;
-externfn!(fn puts(s: *libc::c_char))
+extern {
+ fn puts(s: *libc::c_char);
+}
let my_string = "Hello, world!";
impl Drop for CString {
fn drop(&mut self) {
- #[fixed_stack_segment]; #[inline(never)];
if self.owns_buffer_ {
unsafe {
libc::free(self.buf as *libc::c_void)
impl<'self> ToCStr for &'self [u8] {
fn to_c_str(&self) -> CString {
- #[fixed_stack_segment]; #[inline(never)];
let mut cs = unsafe { self.to_c_str_unchecked() };
do cs.with_mut_ref |buf| {
check_for_null(*self, buf);
}
unsafe fn to_c_str_unchecked(&self) -> CString {
- #[fixed_stack_segment]; #[inline(never)];
do self.as_imm_buf |self_buf, self_len| {
let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
if buf.is_null() {
#[test]
fn test_unwrap() {
- #[fixed_stack_segment]; #[inline(never)];
-
let c_str = "hello".to_c_str();
unsafe { libc::free(c_str.unwrap() as *libc::c_void) }
}
#[test]
fn test_with_ref() {
- #[fixed_stack_segment]; #[inline(never)];
-
let c_str = "hello".to_c_str();
let len = unsafe { c_str.with_ref(|buf| libc::strlen(buf)) };
assert!(!c_str.is_null());
#[deny(non_camel_case_types)];
#[deny(missing_doc)];
+#[allow(unrecognized_lint)]; // NOTE: remove after the next snapshot
+#[allow(cstack)]; // NOTE: remove after the next snapshot.
// When testing libstd, bring in libuv as the I/O backend so tests can print
// things and all of the std::rt::io tests have an I/O interface to run on top
// These are fine to execute on the Rust stack. They must be,
// in fact, because LLVM generates calls to them!
- #[rust_stack]
- #[inline]
pub fn memcmp(cx: *c_void, ct: *c_void, n: size_t) -> c_int;
- #[rust_stack]
- #[inline]
pub fn memchr(cx: *c_void, c: c_int, n: size_t) -> *c_void;
}
}
// doesn't link it correctly on i686, so we're going
// through a C function that mysteriously does work.
pub unsafe fn opendir(dirname: *c_char) -> *DIR {
- #[fixed_stack_segment]; #[inline(never)];
rust_opendir(dirname)
}
pub unsafe fn readdir(dirp: *DIR) -> *dirent_t {
- #[fixed_stack_segment]; #[inline(never)];
rust_readdir(dirp)
}
}
fn abort() -> ! {
- #[fixed_stack_segment]; #[inline(never)];
unsafe { libc::abort() }
}
use unstable::intrinsics;
$(
- #[inline] #[fixed_stack_segment] #[inline(never)]
+ #[inline]
pub fn $name($( $arg : $arg_ty ),*) -> $rv {
unsafe {
$bound_name($( $arg ),*)
use unstable::intrinsics;
$(
- #[inline] #[fixed_stack_segment] #[inline(never)]
+ #[inline]
pub fn $name($( $arg : $arg_ty ),*) -> $rv {
unsafe {
$bound_name($( $arg ),*)
/// Delegates to the libc close() function, returning the same return value.
pub fn close(fd: c_int) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::close(fd)
}
#[cfg(unix)]
pub fn getcwd() -> Path {
- #[fixed_stack_segment]; #[inline(never)];
let mut buf = [0 as libc::c_char, ..BUF_BYTES];
do buf.as_mut_buf |buf, len| {
unsafe {
#[cfg(windows)]
pub fn getcwd() -> Path {
- #[fixed_stack_segment]; #[inline(never)];
use libc::DWORD;
use libc::GetCurrentDirectoryW;
let mut buf = [0 as u16, ..BUF_BYTES];
pub fn fill_utf16_buf_and_decode(f: &fn(*mut u16, DWORD) -> DWORD)
-> Option<~str> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
let mut n = TMPBUF_SZ as DWORD;
};
}
- externfn!(fn rust_take_env_lock());
- externfn!(fn rust_drop_env_lock());
+ extern {
+ fn rust_take_env_lock();
+ fn rust_drop_env_lock();
+ }
}
/// Returns a vector of (variable, value) pairs for all the environment
unsafe {
#[cfg(windows)]
unsafe fn get_env_pairs() -> ~[~str] {
- #[fixed_stack_segment]; #[inline(never)];
use c_str;
use str::StrSlice;
}
#[cfg(unix)]
unsafe fn get_env_pairs() -> ~[~str] {
- #[fixed_stack_segment]; #[inline(never)];
-
extern {
fn rust_env_pairs() -> **libc::c_char;
}
/// Fetches the environment variable `n` from the current process, returning
/// None if the variable isn't set.
pub fn getenv(n: &str) -> Option<~str> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
let s = do n.with_c_str |buf| {
/// Fetches the environment variable `n` from the current process, returning
/// None if the variable isn't set.
pub fn getenv(n: &str) -> Option<~str> {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
do with_env_lock {
use os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
/// Sets the environment variable `n` to the value `v` for the currently running
/// process
pub fn setenv(n: &str, v: &str) {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
do n.with_c_str |nbuf| {
/// Sets the environment variable `n` to the value `v` for the currently running
/// process
pub fn setenv(n: &str, v: &str) {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
do with_env_lock {
use os::win32::as_utf16_p;
pub fn unsetenv(n: &str) {
#[cfg(unix)]
fn _unsetenv(n: &str) {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
do n.with_c_str |nbuf| {
}
#[cfg(windows)]
fn _unsetenv(n: &str) {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
use os::win32::as_utf16_p;
#[cfg(unix)]
pub fn pipe() -> Pipe {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
let mut fds = Pipe {input: 0 as c_int,
out: 0 as c_int };
#[cfg(windows)]
pub fn pipe() -> Pipe {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
}
fn dup2(src: c_int, dst: c_int) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::dup2(src, dst)
}
#[cfg(target_os = "freebsd")]
fn load_self() -> Option<~[u8]> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::bsd44::*;
use libc::consts::os::extra::*;
#[cfg(target_os = "macos")]
fn load_self() -> Option<~[u8]> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::extra::_NSGetExecutablePath;
use vec;
#[cfg(windows)]
fn load_self() -> Option<~[u8]> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::fill_utf16_buf_and_decode;
do fill_utf16_buf_and_decode() |buf, sz| {
#[cfg(windows)]
fn chdir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.as_str().unwrap()) |buf| {
#[cfg(unix)]
fn chdir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::chdir(buf) == (0 as c_int)
#[cfg(target_os = "macos")]
#[cfg(target_os = "freebsd")]
fn errno_location() -> *c_int {
- #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __error() -> *c_int;
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
fn errno_location() -> *c_int {
- #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __errno_location() -> *c_int;
#[cfg(windows)]
/// Returns the platform-specific value of errno
pub fn errno() -> uint {
- #[fixed_stack_segment]; #[inline(never)];
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
#[cfg(target_os = "freebsd")]
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
-> c_int {
- #[fixed_stack_segment]; #[inline(never)];
-
#[nolink]
extern {
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
// So we just use __xpg_strerror_r which is always POSIX compliant
#[cfg(target_os = "linux")]
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t) -> c_int {
- #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __xpg_strerror_r(errnum: c_int,
#[cfg(windows)]
fn strerror() -> ~str {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPWSTR;
use libc::types::os::arch::extra::LPVOID;
*/
#[cfg(target_os = "macos")]
fn real_args() -> ~[~str] {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let (argc, argv) = (*_NSGetArgc() as c_int,
*_NSGetArgv() as **c_char);
#[cfg(windows)]
fn real_args() -> ~[~str] {
- #[fixed_stack_segment]; #[inline(never)];
use vec;
let mut nArgs: c_int = 0;
#[cfg(unix)]
pub fn page_size() -> uint {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
libc::sysconf(libc::_SC_PAGESIZE) as uint
}
#[cfg(windows)]
pub fn page_size() -> uint {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let mut info = libc::SYSTEM_INFO::new();
libc::GetSystemInfo(&mut info);
impl MemoryMap {
/// Create a new mapping with the given `options`, at least `min_len` bytes long.
pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::off_t;
let mut addr: *c_void = ptr::null();
impl Drop for MemoryMap {
/// Unmap the mapping. Fails the task if `munmap` fails.
fn drop(&mut self) {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
match libc::munmap(self.data as *c_void, self.len) {
0 => (),
impl MemoryMap {
/// Create a new mapping with the given `options`, at least `min_len` bytes long.
pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE};
let mut lpAddress: LPVOID = ptr::mut_null();
/// Granularity of MapAddr() and MapOffset() parameter values.
/// This may be greater than the value returned by page_size().
pub fn granularity() -> uint {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
let mut info = libc::SYSTEM_INFO::new();
libc::GetSystemInfo(&mut info);
/// Unmap the mapping. Fails the task if any of `VirtualFree`, `UnmapViewOfFile`, or
/// `CloseHandle` fail.
fn drop(&mut self) {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::types::os::arch::extra::{LPCVOID, HANDLE};
use libc::consts::os::extra::FALSE;
#[test]
fn memory_map_file() {
- #[fixed_stack_segment]; #[inline(never)];
-
use result::{Ok, Err};
use os::*;
use libc::*;
use rt::io::fs;
#[cfg(unix)]
- #[fixed_stack_segment]
- #[inline(never)]
fn lseek_(fd: c_int, size: uint) {
unsafe {
assert!(lseek(fd, size as off_t, SEEK_SET) == size as off_t);
}
}
#[cfg(windows)]
- #[fixed_stack_segment]
- #[inline(never)]
fn lseek_(fd: c_int, size: uint) {
unsafe {
assert!(lseek(fd, size as c_long, SEEK_SET) == size as c_long);
/// Create a new `OSRng`.
#[cfg(windows)]
pub fn new() -> OSRng {
- externfn!(fn rust_win32_rand_acquire(phProv: *mut HCRYPTPROV))
+ extern { fn rust_win32_rand_acquire(phProv: *mut HCRYPTPROV); }
let mut hcp = 0;
unsafe {rust_win32_rand_acquire(&mut hcp)};
unsafe { cast::transmute(v) }
}
fn fill_bytes(&mut self, v: &mut [u8]) {
- externfn!(fn rust_win32_rand_gen(hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: *mut BYTE))
+ extern {
+ fn rust_win32_rand_gen(hProv: HCRYPTPROV, dwLen: DWORD,
+ pbBuffer: *mut BYTE);
+ }
do v.as_mut_buf |ptr, len| {
unsafe {rust_win32_rand_gen(self.hcryptprov, len as DWORD, ptr)}
#[cfg(windows)]
fn drop(&mut self) {
- externfn!(fn rust_win32_rand_release(hProv: HCRYPTPROV))
+ extern { fn rust_win32_rand_release(hProv: HCRYPTPROV); }
unsafe {rust_win32_rand_release(self.hcryptprov)}
}
}
}
- externfn!(fn rust_take_global_args_lock())
- externfn!(fn rust_drop_global_args_lock())
- externfn!(fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>)
+ extern {
+ fn rust_take_global_args_lock();
+ fn rust_drop_global_args_lock();
+ fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>;
+ }
#[cfg(test)]
mod tests {
}
fn time() -> Time {
- #[fixed_stack_segment]; #[inline(never)];
extern {
fn get_time(sec: &mut i64, nsec: &mut i32);
}
}
extern {
- #[rust_stack]
fn swap_registers(out_regs: *mut Registers, in_regs: *Registers);
}
unsafe fn target_record_sp_limit(limit: uint) {
return record_sp_limit(limit as *c_void);
extern {
- #[rust_stack]
fn record_sp_limit(limit: *c_void);
}
}
unsafe fn target_get_sp_limit() -> uint {
return get_sp_limit() as uint;
extern {
- #[rust_stack]
fn get_sp_limit() -> *c_void;
}
}
}
#[cfg(windows)]
-#[fixed_stack_segment]
-#[inline(never)]
pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
use cast::transmute;
use c_str::ToCStr;
use mem::size_of;
extern {
- #[rust_stack]
fn abort();
}
/// A wrapper around libc::malloc, aborting on out-of-memory
pub unsafe fn malloc_raw(size: uint) -> *c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
let p = malloc(size as size_t);
if p.is_null() {
// we need a non-allocating way to print an error here
/// A wrapper around libc::realloc, aborting on out-of-memory
pub unsafe fn realloc_raw(ptr: *mut c_void, size: uint) -> *mut c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
let p = realloc(ptr, size as size_t);
if p.is_null() {
// we need a non-allocating way to print an error here
}
pub unsafe fn exchange_free(ptr: *c_char) {
- #[fixed_stack_segment]; #[inline(never)];
-
free(ptr as *c_void);
}
}
impl Reader for FileDesc {
- #[fixed_stack_segment] #[inline(never)]
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
#[cfg(windows)] type rlen = libc::c_uint;
#[cfg(not(windows))] type rlen = libc::size_t;
}
impl Writer for FileDesc {
- #[fixed_stack_segment] #[inline(never)]
fn write(&mut self, buf: &[u8]) {
#[cfg(windows)] type wlen = libc::c_uint;
#[cfg(not(windows))] type wlen = libc::size_t;
}
impl Drop for FileDesc {
- #[fixed_stack_segment] #[inline(never)]
fn drop(&mut self) {
if self.close_on_drop {
unsafe { libc::close(self.fd); }
}
impl Reader for CFile {
- #[fixed_stack_segment] #[inline(never)]
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
let ret = do keep_going(buf) |buf, len| {
unsafe {
}
}
- #[fixed_stack_segment] #[inline(never)]
fn eof(&mut self) -> bool {
unsafe { libc::feof(self.file) != 0 }
}
}
impl Writer for CFile {
- #[fixed_stack_segment] #[inline(never)]
fn write(&mut self, buf: &[u8]) {
let ret = do keep_going(buf) |buf, len| {
unsafe {
}
}
- #[fixed_stack_segment] #[inline(never)]
fn flush(&mut self) {
if unsafe { libc::fflush(self.file) } < 0 {
raise_error();
}
impl Seek for CFile {
- #[fixed_stack_segment] #[inline(never)]
fn tell(&self) -> u64 {
let ret = unsafe { libc::ftell(self.file) };
if ret < 0 {
return ret as u64;
}
- #[fixed_stack_segment] #[inline(never)]
fn seek(&mut self, pos: i64, style: SeekStyle) {
let whence = match style {
SeekSet => libc::SEEK_SET,
}
impl Drop for CFile {
- #[fixed_stack_segment] #[inline(never)]
fn drop(&mut self) {
unsafe { libc::fclose(self.file); }
}
use rt::io::{io_error, SeekSet};
use super::*;
- #[test] #[fixed_stack_segment]
#[ignore(cfg(target_os = "freebsd"))] // hmm, maybe pipes have a tiny buffer
fn test_file_desc() {
// Run this test with some pipes so we don't have to mess around with
}
}
- #[test] #[fixed_stack_segment]
#[ignore(cfg(windows))] // apparently windows doesn't like tmpfile
fn test_cfile() {
unsafe {
#[cfg(unix)]
/// Indicates whether a path represents a directory
pub fn path_is_dir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
rustrt::rust_path_is_dir(buf) != 0 as c_int
#[cfg(windows)]
pub fn path_is_dir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do os::win32::as_utf16_p(p.as_str().unwrap()) |buf| {
rustrt::rust_path_is_dir_u16(buf) != 0 as c_int
#[cfg(unix)]
/// Indicates whether a path exists
pub fn path_exists(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
rustrt::rust_path_exists(buf) != 0 as c_int
#[cfg(windows)]
pub fn path_exists(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do os::win32::as_utf16_p(p.as_str().unwrap()) |buf| {
rustrt::rust_path_exists_u16(buf) != 0 as c_int
#[cfg(windows)]
fn mkdir(p: &Path, _mode: c_int) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
// FIXME: turn mode into something useful? #2623
#[cfg(unix)]
fn mkdir(p: &Path, mode: c_int) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::mkdir(buf, mode as libc::mode_t) == (0 as c_int)
#[cfg(target_os = "freebsd")]
#[cfg(target_os = "macos")]
unsafe fn get_list(p: &Path) -> ~[Path] {
- #[fixed_stack_segment]; #[inline(never)];
use libc::{dirent_t};
use libc::{opendir, readdir, closedir};
extern {
}
#[cfg(windows)]
unsafe fn get_list(p: &Path) -> ~[Path] {
- #[fixed_stack_segment]; #[inline(never)];
use libc::consts::os::extra::INVALID_HANDLE_VALUE;
use libc::{wcslen, free};
use libc::funcs::extra::kernel32::{
#[cfg(windows)]
fn rmdir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.as_str().unwrap()) |buf| {
#[cfg(unix)]
fn rmdir(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::rmdir(buf) == (0 as c_int)
#[cfg(windows)]
fn unlink(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.as_str().unwrap()) |buf| {
#[cfg(unix)]
fn unlink(p: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
libc::unlink(buf) == (0 as c_int)
/// Renames an existing file or directory
pub fn rename_file(old: &Path, new: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do old.with_c_str |old_buf| {
do new.with_c_str |new_buf| {
#[cfg(windows)]
fn do_copy_file(from: &Path, to: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(from.as_str().unwrap()) |fromp| {
#[cfg(unix)]
fn do_copy_file(from: &Path, to: &Path) -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
let istream = do from.with_c_str |fromp| {
do "rb".with_c_str |modebuf| {
stdin: Option<file::fd_t>,
stdout: Option<file::fd_t>,
stderr: Option<file::fd_t>) -> Process {
- #[fixed_stack_segment]; #[inline(never)];
-
let (in_pipe, in_fd) = match stdin {
None => {
let pipe = os::pipe();
#[cfg(windows)]
unsafe fn killpid(pid: pid_t, signal: int) -> Result<(), io::IoError> {
- #[fixed_stack_segment]; #[inline(never)];
match signal {
io::process::PleaseExitSignal |
io::process::MustDieSignal => {
#[cfg(not(windows))]
unsafe fn killpid(pid: pid_t, signal: int) -> Result<(), io::IoError> {
- #[fixed_stack_segment]; #[inline(never)];
libc::funcs::posix88::signal::kill(pid, signal as c_int);
Ok(())
}
env: Option<~[(~str, ~str)]>,
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
use libc::consts::os::extra::{
TRUE, FALSE,
env: Option<~[(~str, ~str)]>,
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
use libc::funcs::bsd44::getdtablesize;
unsafe fn set_environ(_envp: *c_void) {}
#[cfg(target_os = "macos")]
unsafe fn set_environ(envp: *c_void) {
- externfn!(fn _NSGetEnviron() -> *mut *c_void);
+ extern { fn _NSGetEnviron() -> *mut *c_void; }
*_NSGetEnviron() = envp;
}
#[cfg(windows)]
fn free_handle(handle: *()) {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::funcs::extra::kernel32::CloseHandle(cast::transmute(handle));
}
#[cfg(windows)]
fn waitpid_os(pid: pid_t) -> int {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::types::os::arch::extra::DWORD;
use libc::consts::os::extra::{
SYNCHRONIZE,
#[cfg(unix)]
fn waitpid_os(pid: pid_t) -> int {
- #[fixed_stack_segment]; #[inline(never)];
-
use libc::funcs::posix01::wait::*;
#[cfg(target_os = "linux")]
// kill is only available on Unixes
#[cfg(unix)]
- #[fixed_stack_segment]
fn sigint() {
unsafe {
libc::funcs::posix88::signal::kill(libc::getpid(), libc::SIGINT);
File(~RtioFileStream),
}
-#[fixed_stack_segment] #[inline(never)]
fn src<T>(fd: libc::c_int, readable: bool, f: &fn(StdSource) -> T) -> T {
do with_local_io |io| {
let fd = unsafe { libc::dup(fd) };
/// Creates a new non-blocking handle to the stdin of the current process.
///
/// See `stdout()` for notes about this function.
-#[fixed_stack_segment] #[inline(never)]
pub fn stdin() -> StdReader {
do src(libc::STDIN_FILENO, true) |src| { StdReader { inner: src } }
}
static mut RT_TLS_KEY: tls::Key = -1;
/// Initialize the TLS key. Other ops will fail if this isn't executed first.
-#[fixed_stack_segment]
-#[inline(never)]
pub fn init_tls_key() {
unsafe {
rust_initialize_rt_tls_key(&mut RT_TLS_KEY);
if longest_match >= 0 { return 1; } else { return 0; }
}
-#[fixed_stack_segment] #[inline(never)]
/// Set log level for every entry in crate_map according to the sepecification
/// in settings
fn update_log_settings(crate_map: &CrateMap, settings: ~str) {
}
pub fn new_event_loop() -> ~rtio::EventLoop {
- #[fixed_stack_segment]; #[allow(cstack)];
-
match crate_map::get_crate_map() {
None => {}
Some(map) => {
XorShiftRng::new()
}
#[cfg(unix)]
-#[fixed_stack_segment] #[inline(never)]
fn new_sched_rng() -> XorShiftRng {
use libc;
use mem;
impl StackSegment {
pub fn new(size: uint) -> StackSegment {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
// Crate a block of uninitialized values
let mut stack = vec::with_capacity(size);
impl Drop for StackSegment {
fn drop(&mut self) {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
// XXX: Using the FFI to call a C macro. Slow
rust_valgrind_stack_deregister(self.valgrind_id);
}
extern {
- #[rust_stack]
fn rust_try(f: extern "C" fn(*c_void, *c_void),
code: *c_void,
data: *c_void) -> uintptr_t;
}
pub fn begin_unwind(&mut self, cause: ~Any) -> ! {
- #[fixed_stack_segment]; #[inline(never)];
-
self.unwinding = true;
self.cause = Some(cause);
unsafe {
/// truly consider it to be stack overflow rather than allocating a new stack.
#[no_mangle] // - this is called from C code
#[no_split_stack] // - it would be sad for this function to trigger __morestack
-#[doc(hidden)] // XXX: this function shouldn't have to be `pub` to get exported
- // so it can be linked against, we should have a better way
- // of specifying that.
+#[doc(hidden)] // - Function must be `pub` to get exported, but it's
+ // irrelevant for documentation purposes.
pub extern "C" fn rust_stack_exhausted() {
use rt::in_green_task_context;
use rt::task::Task;
static RLIMIT_NOFILE: libc::c_int = 8;
pub unsafe fn raise_fd_limit() {
- #[fixed_stack_segment]; #[inline(never)];
-
// The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
// sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null};
}
/// Get a port number, starting at 9600, for use in tests
-#[fixed_stack_segment] #[inline(never)]
pub fn next_test_port() -> u16 {
unsafe {
return rust_dbg_next_port(base_port() as libc::uintptr_t) as u16;
}
/// Get a temporary path which could be the location of a unix socket
-#[fixed_stack_segment] #[inline(never)]
pub fn next_test_unix() -> Path {
if cfg!(unix) {
os::tmpdir().join(rand::task_rng().gen_ascii_str(20))
#[cfg(windows)]
fn native_thread_create(thread_start: extern "C" fn(*libc::c_void) -> rust_thread_return,
tramp: ~~fn()) -> rust_thread {
- #[fixed_stack_segment];
-
unsafe {
let ptr: *mut libc::c_void = cast::transmute(tramp);
CreateThread(ptr::mut_null(), DEFAULT_STACK_SIZE, thread_start, ptr, 0, ptr::mut_null())
#[cfg(windows)]
fn native_thread_join(native: rust_thread) {
- #[fixed_stack_segment];
use libc::consts::os::extra::INFINITE;
unsafe { WaitForSingleObject(native, INFINITE); }
}
#[cfg(unix)]
fn native_thread_create(thread_start: extern "C" fn(*libc::c_void) -> rust_thread_return,
tramp: ~~fn()) -> rust_thread {
- #[fixed_stack_segment];
-
use unstable::intrinsics;
let mut native: libc::pthread_t = unsafe { intrinsics::uninit() };
#[cfg(unix)]
fn native_thread_join(native: rust_thread) {
- #[fixed_stack_segment];
unsafe { assert!(pthread_join(native, ptr::null()) == 0) }
}
impl Drop for Thread {
fn drop(&mut self) {
- #[fixed_stack_segment]; #[inline(never)];
assert!(self.joined);
}
}
pub type Key = pthread_key_t;
#[cfg(unix)]
-#[fixed_stack_segment]
-#[inline(never)]
pub unsafe fn create(key: &mut Key) {
assert_eq!(0, pthread_key_create(key, null()));
}
#[cfg(unix)]
extern {
fn pthread_key_create(key: *mut pthread_key_t, dtor: *u8) -> c_int;
-
- // This function is a very cheap operation on both osx and unix. On osx, it
- // turns out it's just three instructions, and on unix it's a cheap function
- // which only uses a very small amount of stack.
- //
- // This is not marked as such because we think it has a small stack, but
- // rather we would like to be able to fetch information from
- // thread-local-storage when a task is running very low on its stack budget.
- // For example, this is invoked whenever stack overflow is detected, and we
- // obviously have very little budget to deal with (certainly not anything
- // close to a fixed_stack_segment)
- #[rust_stack]
fn pthread_getspecific(key: pthread_key_t) -> *mut c_void;
- #[rust_stack]
fn pthread_setspecific(key: pthread_key_t, value: *mut c_void) -> c_int;
}
pub type Key = DWORD;
#[cfg(windows)]
-#[fixed_stack_segment]
-#[inline(never)]
pub unsafe fn create(key: &mut Key) {
static TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
*key = TlsAlloc();
#[cfg(windows)]
extern "system" {
fn TlsAlloc() -> DWORD;
-
- // See the reasoning in pthread_getspecific as to why this has the
- // 'rust_stack' attribute, as this function was also verified to only
- // require a small amount of stack.
- #[rust_stack]
fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID;
- #[rust_stack]
fn TlsSetValue(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL;
}
/// Get the number of cores available
pub fn num_cpus() -> uint {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
return rust_get_num_cpus();
}
abort();
fn abort() -> ! {
- #[fixed_stack_segment]; #[inline(never)];
unsafe { libc::abort() }
}
}
*
* The process's exit code
*/
-#[fixed_stack_segment] #[inline(never)]
pub fn process_status(prog: &str, args: &[~str]) -> int {
let mut prog = Process::new(prog, args, ProcessOptions {
env: None,
mod testrt {
use libc;
- externfn!(fn rust_dbg_lock_create() -> *libc::c_void)
- externfn!(fn rust_dbg_lock_destroy(lock: *libc::c_void))
- externfn!(fn rust_dbg_lock_lock(lock: *libc::c_void))
- externfn!(fn rust_dbg_lock_unlock(lock: *libc::c_void))
- externfn!(fn rust_dbg_lock_wait(lock: *libc::c_void))
- externfn!(fn rust_dbg_lock_signal(lock: *libc::c_void))
+ extern {
+ pub fn rust_dbg_lock_create() -> *libc::c_void;
+ pub fn rust_dbg_lock_destroy(lock: *libc::c_void);
+ pub fn rust_dbg_lock_lock(lock: *libc::c_void);
+ pub fn rust_dbg_lock_unlock(lock: *libc::c_void);
+ pub fn rust_dbg_lock_wait(lock: *libc::c_void);
+ pub fn rust_dbg_lock_signal(lock: *libc::c_void);
+ }
}
#[test]
use result::*;
pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
do filename.with_c_str |raw_name| {
dlopen(raw_name, Lazy as libc::c_int)
}
}
pub unsafe fn open_internal() -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
dlopen(ptr::null(), Lazy as libc::c_int)
}
pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
- #[fixed_stack_segment]; #[inline(never)];
-
unsafe {
// dlerror isn't thread safe, so we need to lock around this entire
// sequence. `atomically` asserts that we don't do anything that
}
pub unsafe fn symbol(handle: *libc::c_void, symbol: *libc::c_char) -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
-
dlsym(handle, symbol)
}
pub unsafe fn close(handle: *libc::c_void) {
- #[fixed_stack_segment]; #[inline(never)];
-
dlclose(handle); ()
}
use result::*;
pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
do os::win32::as_utf16_p(filename.as_str().unwrap()) |raw_name| {
LoadLibraryW(raw_name)
}
}
pub unsafe fn open_internal() -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
let handle = ptr::null();
GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &handle as **libc::c_void);
handle
}
pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
- #[fixed_stack_segment]; #[inline(never)];
unsafe {
do atomically {
SetLastError(0);
}
pub unsafe fn symbol(handle: *libc::c_void, symbol: *libc::c_char) -> *libc::c_void {
- #[fixed_stack_segment]; #[inline(never)];
GetProcAddress(handle, symbol)
}
pub unsafe fn close(handle: *libc::c_void) {
- #[fixed_stack_segment]; #[inline(never)];
FreeLibrary(handle); ()
}
pub fn powif32(a: f32, x: i32) -> f32;
pub fn powif64(a: f64, x: i32) -> f64;
- // the following kill the stack canary without
- // `fixed_stack_segment`. This possibly only affects the f64
- // variants, but it's hard to be sure since it seems to only
- // occur with fairly specific arguments.
- #[fixed_stack_segment]
pub fn sinf32(x: f32) -> f32;
- #[fixed_stack_segment]
pub fn sinf64(x: f64) -> f64;
- #[fixed_stack_segment]
pub fn cosf32(x: f32) -> f32;
- #[fixed_stack_segment]
pub fn cosf64(x: f64) -> f64;
- #[fixed_stack_segment]
pub fn powf32(a: f32, x: f32) -> f32;
- #[fixed_stack_segment]
pub fn powf64(a: f64, x: f64) -> f64;
- #[fixed_stack_segment]
pub fn expf32(x: f32) -> f32;
- #[fixed_stack_segment]
pub fn expf64(x: f64) -> f64;
pub fn exp2f32(x: f32) -> f32;
/// can't run correctly un-altered. Valgrind is there to help
/// you notice weirdness in normal, un-doctored code paths!
pub fn running_on_valgrind() -> bool {
- #[fixed_stack_segment]; #[inline(never)];
unsafe { rust_running_on_valgrind() != 0 }
}
}
}
-externfn!(fn rust_create_little_lock() -> rust_little_lock)
-externfn!(fn rust_destroy_little_lock(lock: rust_little_lock))
-externfn!(fn rust_lock_little_lock(lock: rust_little_lock))
-externfn!(fn rust_unlock_little_lock(lock: rust_little_lock))
-externfn!(fn rust_signal_little_lock(lock: rust_little_lock))
-externfn!(fn rust_wait_little_lock(lock: rust_little_lock))
+extern {
+ fn rust_create_little_lock() -> rust_little_lock;
+ fn rust_destroy_little_lock(lock: rust_little_lock);
+ fn rust_lock_little_lock(lock: rust_little_lock);
+ fn rust_unlock_little_lock(lock: rust_little_lock);
+ fn rust_signal_little_lock(lock: rust_little_lock);
+ fn rust_wait_little_lock(lock: rust_little_lock);
+}
#[cfg(test)]
mod tests {
let stderr = @mut io::stderr() as @mut io::Writer;
fn is_stderr_screen() -> bool {
- #[fixed_stack_segment];
use std::libc;
unsafe { libc::isatty(libc::STDERR_FILENO) != 0 }
}
pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key;
)
)
-
- /// externfn! declares a wrapper for an external function.
- /// It is intended to be used like:
- ///
- /// externfn!(#[nolink]
- /// fn memcmp(cx: *u8, ct: *u8, n: u32) -> u32)
- ///
- /// Due to limitations in the macro parser, this pattern must be
- /// implemented with 4 distinct patterns (with attrs / without
- /// attrs CROSS with args / without ARGS).
- ///
- /// Also, this macro grammar allows for any number of return types
- /// because I couldn't figure out the syntax to specify at most one.
- macro_rules! externfn(
- (fn $name:ident () $(-> $ret_ty:ty),*) => (
- pub unsafe fn $name() $(-> $ret_ty),* {
- // Note: to avoid obscure bug in macros, keep these
- // attributes *internal* to the fn
- #[fixed_stack_segment];
- #[inline(never)];
- #[allow(missing_doc)];
-
- return $name();
-
- extern {
- fn $name() $(-> $ret_ty),*;
- }
- }
- );
- (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
- pub unsafe fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),* {
- // Note: to avoid obscure bug in macros, keep these
- // attributes *internal* to the fn
- #[fixed_stack_segment];
- #[inline(never)];
- #[allow(missing_doc)];
-
- return $name($($arg_name),*);
-
- extern {
- fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
- }
- }
- );
- ($($attrs:attr)* fn $name:ident () $(-> $ret_ty:ty),*) => (
- pub unsafe fn $name() $(-> $ret_ty),* {
- // Note: to avoid obscure bug in macros, keep these
- // attributes *internal* to the fn
- #[fixed_stack_segment];
- #[inline(never)];
- #[allow(missing_doc)];
-
- return $name();
-
- $($attrs)*
- extern {
- fn $name() $(-> $ret_ty),*;
- }
- }
- );
- ($($attrs:attr)* fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
- pub unsafe fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),* {
- // Note: to avoid obscure bug in macros, keep these
- // attributes *internal* to the fn
- #[fixed_stack_segment];
- #[inline(never)];
- #[allow(missing_doc)];
-
- return $name($($arg_name),*);
-
- $($attrs)*
- extern {
- fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
- }
- }
- )
- )
-
}"#
}
#[crate_type = "lib"];
#[feature(macro_rules, globs, managed_boxes)];
+#[allow(unrecognized_lint)]; // NOTE: remove after the next snapshot
+#[allow(cstack)]; // NOTE: remove after the next snapshot.
extern mod extra;
}
}
-#[fixed_stack_segment] #[inline(never)]
pub fn fact(n: uint) -> uint {
unsafe {
info!("n = {}", n);
}
}
-#[fixed_stack_segment]
fn main() {
let args = os::args();
let n_keys = {
}
}
-#[fixed_stack_segment]
fn main() {
let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
println!("Pfannkuchen({}) = {}", n as int, fannkuch_redux(n) as int);
}
}
-#[fixed_stack_segment]
fn main() {
let n: uint = FromStr::from_str(os::args()[1]).unwrap();
}
}
-#[inline(never)]
-#[fixed_stack_segment]
fn generate_frequencies(frequencies: &mut Table,
mut input: &[u8],
frame: i32) {
}
}
-#[inline(never)]
-#[fixed_stack_segment]
fn print_frequencies(frequencies: &Table, frame: i32) {
let mut vector = ~[];
for frequencies.each |entry| {
frequencies.lookup(Code::pack(occurrence), PrintCallback(occurrence))
}
-#[fixed_stack_segment]
fn main() {
let input = read_stdin();
static ITER: uint = 50;
static LIMIT: f64 = 2.0;
-#[fixed_stack_segment]
fn main() {
unsafe {
let w: i32 = FromStr::from_str(os::args()[1]).unwrap();
}
}
-#[fixed_stack_segment]
fn main() {
let n: u32 = FromStr::from_str(os::args()[1]).get();
pidigits(n);
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
];
-#[fixed_stack_segment]
fn main() {
unsafe {
let mode = "r";
mult_Atv(tmp, out);
}
-#[fixed_stack_segment]
fn main() {
let n: uint = FromStr::from_str(os::args()[1]).unwrap();
let mut u = vec::from_elem(n, 1f64);
+++ /dev/null
-// Copyright 2012 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.
-
-extern fn f() {
-}
-
-extern fn call1() {
- f(); // OK from another extern fn!
-}
-
-fn call2() {
- f(); //~ ERROR invoking non-Rust fn
-}
-
-
-fn main() {}
+++ /dev/null
-// 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.
-
-extern {
- fn rust_get_test_int() -> std::libc::intptr_t;
-}
-
-trait A {
- fn foo() {
- unsafe {
- rust_get_test_int(); //~ ERROR invoking non-Rust fn
- }
- }
-}
-
-fn main() {
-}
// Exercise the unused_unsafe attribute in some positive and negative cases
-#[allow(cstack)];
#[deny(unused_unsafe)];
mod foo {
extern "C" fn bar(f: int, x: u8) {}
-#[fixed_stack_segment]
fn main() {
unsafe {
foo(); //~ ERROR: this function takes at least 2 parameters but 0 parameters were supplied
use anonexternmod::rust_get_test_int;
-#[fixed_stack_segment]
pub fn main() {
unsafe {
rust_get_test_int();
fn rust_get_test_int() -> libc::intptr_t;
}
-#[fixed_stack_segment]
pub fn main() {
unsafe {
let _ = rust_get_test_int();
}
}
-#[fixed_stack_segment]
fn atol(s: ~str) -> int {
s.with_c_str(|x| unsafe { libc::atol(x) as int })
}
-#[fixed_stack_segment]
fn atoll(s: ~str) -> i64 {
s.with_c_str(|x| unsafe { libc::atoll(x) as i64 })
}
#[cfg(windows)]
fn process_exists(pid: libc::pid_t) -> bool {
- #[fixed_stack_segment];
-
use std::libc::types::os::arch::extra::DWORD;
use std::libc::funcs::extra::kernel32::{CloseHandle, GetExitCodeProcess, OpenProcess};
use std::libc::consts::os::extra::{FALSE, PROCESS_QUERY_INFORMATION, STILL_ACTIVE };
}
}
-#[fixed_stack_segment]
fn count(n: uint) -> uint {
unsafe {
info!("n = {}", n);
}
}
-#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
info!("n = {}", n);
extern fn f(x: uint) -> uint { x * 2 }
pub fn main() {
- #[fixed_stack_segment];
-
let x = f(22);
assert_eq!(x, 44);
}
}
}
-#[fixed_stack_segment] #[inline(never)]
fn fact(n: uint) -> uint {
unsafe {
info!("n = {}", n);
}
}
-#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
info!("n = {}", n);
extern mod externcallback(vers = "0.1");
-#[fixed_stack_segment] #[inline(never)]
fn fact(n: uint) -> uint {
unsafe {
info!("n = {}", n);
pub fn rust_dbg_extern_identity_TwoU16s(v: TwoU16s) -> TwoU16s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU16s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU32s(v: TwoU32s) -> TwoU32s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU32s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU64s(u: TwoU64s) -> TwoU64s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU64s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU64s(v: TwoU64s) -> TwoU64s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU64s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU8s(v: TwoU8s) -> TwoU8s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU8s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_u8(v: u8) -> u8;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u8, rust_dbg_extern_identity_u8(22_u8));
pub fn rust_dbg_extern_identity_double(v: f64) -> f64;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22.0_f64, rust_dbg_extern_identity_double(22.0_f64));
pub fn rust_dbg_extern_identity_u32(v: u32) -> u32;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u32, rust_dbg_extern_identity_u32(22_u32));
pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u64, rust_dbg_extern_identity_u64(22_u64));
pub fn rust_dbg_extern_return_TwoU16s() -> TwoU16s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU16s();
pub fn rust_dbg_extern_return_TwoU32s() -> TwoU32s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU32s();
pub fn rust_dbg_extern_return_TwoU64s() -> TwoU64s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU64s();
pub fn rust_dbg_extern_return_TwoU8s() -> TwoU8s;
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU8s();
}
}
-#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
rustrt::rust_dbg_call(cb, n)
}
}
-#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
task::deschedule();
use std::libc;
use std::unstable::run_in_bare_thread;
-externfn!(fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t),
- data: libc::uintptr_t) -> libc::uintptr_t)
+extern {
+ fn rust_dbg_call(cb: extern "C" fn(libc::uintptr_t),
+ data: libc::uintptr_t) -> libc::uintptr_t;
+}
pub fn main() {
unsafe {
}
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
rustrt1::rust_get_test_int();
}
}
-#[fixed_stack_segment] #[inline(never)]
fn strlen(str: ~str) -> uint {
// C string is terminated with a zero
do str.with_c_str |buf| {
}
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
rustrt::rust_get_test_int();
extern mod foreign_lib;
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let _foo = foreign_lib::rustrt::rust_get_test_int();
}
}
-#[fixed_stack_segment] #[inline(never)]
fn lgamma(n: c_double, value: &mut int) -> c_double {
unsafe {
return m::lgamma(n, to_c_int(value));
}
extern {
- #[rust_stack]
pub fn foo(v: *Foo) -> Foo;
}
}
}
trait A {
- #[fixed_stack_segment]
fn foo() {
unsafe {
rust_get_test_int();
pub struct Fd(c_int);
impl Drop for Fd {
- #[fixed_stack_segment] #[inline(never)]
fn drop(&mut self) {
unsafe {
libc::close(**self);
}
}
-#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
a::free(transmute(0));
x: int
}
-#[fixed_stack_segment] #[inline(never)]
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
unsafe {
cast::transmute(libc::malloc(mem::size_of::<Bcx<'a>>()
return alloc(bcx.fcx.arena);
}
-#[fixed_stack_segment] #[inline(never)]
fn g(fcx : &Fcx) {
let bcx = Bcx { fcx: fcx };
let bcx2 = h(&bcx);
use std::rt::io::fs;
fn rename_directory() {
- #[fixed_stack_segment];
unsafe {
static U_RWX: i32 = (libc::S_IRUSR | libc::S_IWUSR | libc::S_IXUSR) as i32;
*a = 3;
}
-#[fixed_stack_segment] #[inline(never)]
unsafe fn run() {
assert!(rust_dbg_static_mut == 3);
rust_dbg_static_mut = 4;
}
}
-#[fixed_stack_segment] #[inline(never)]
fn test1() {
unsafe {
let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
}
#[cfg(target_arch = "x86_64")]
-#[fixed_stack_segment]
-#[inline(never)]
fn test2() {
unsafe {
let f = Floats { a: 1.234567890e-15_f64,
assert_eq!(expected, res.as_str().unwrap());
}
-#[fixed_stack_segment]
pub fn main() {
unsafe {
// A function that takes a function pointer
unsafe fn call(p: extern "C" unsafe fn(*mut c_char, *c_char, ...) -> c_int) {
- #[fixed_stack_segment];
-
// Call with just the named parameter via fn pointer
do "Hello World\n".with_c_str |c| {
check("Hello World\n", |s| p(s, c));
#[cfg(windows)]
-#[fixed_stack_segment]
pub fn main() {
let heap = unsafe { kernel32::GetProcessHeap() };
let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
projects / rust.git / commitdiff