context-coroutine 3.1.0

This is a simple set of extensions to provide stackful coroutines; it is not officially associated with the context crate.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// This file is part of context-coroutine. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/context-coroutine/master/COPYRIGHT. No part of context-coroutine, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2019 The developers of context-coroutine. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/context-coroutine/master/COPYRIGHT.


#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![deny(missing_docs)]
#![deny(unreachable_patterns)]
#![feature(allocator_api)]
#![feature(asm)]
#![feature(core_intrinsics)]
#![feature(global_asm)]
#![feature(naked_functions)]


//! # context-coroutine
//!
//! Provides coroutines using the trait `Coroutine`.
//!
//! Coroutines use a separate, special stack.
//!
//! Implement this trait and then call `Coroutine::start_coroutine()`, passing in start arguments and a source of memory for the stack and heap.
//! Coroutines can use a switchable allocator, providing a straightforward way to restrict the amount of dynamic memory they can access and to ensure they only use thread-local memory.
//!
//! For a simple coroutine, use the stack `stacks::ProtectedStack`.
//!
//! This crate was originally a simple set of extensions to the [context](https://github.com/zonyitoo/context-rs) crate to provide stackful coroutines.
//! The developers are not associated with the authors of [context](https://github.com/zonyitoo/context-rs) but are extremely grateful for the work they've put into to a superb piece of code.
//!
//!
//! ## Licensing
//!
//! The license for this project is MIT.


extern crate context_allocator;
extern crate libc;
extern crate libc_extra;
#[macro_use] extern crate likely;


use self::context::*;
use self::stacks::*;
use ::context_allocator::*;
use ::context_allocator::allocators::global::*;
use ::context_allocator::extensions::*;
use ::context_allocator::memory_sources::*;
use ::context_allocator::memory_sources::arena_memory_source::*;
use ::context_allocator::memory_sources::mmap::*;
use ::std::alloc::AllocErr;
use ::std::intrinsics::unreachable;
use ::std::marker::PhantomData;
use ::std::mem::uninitialized;
use ::std::num::NonZeroUsize;
use ::std::panic::*;
use ::std::ptr::NonNull;
use ::std::ptr::read;
use ::std::thread;


include!("ChildOutcome.rs");
include!("Coroutine.rs");
include!("CoroutineMemory.rs");
include!("CoroutineMemorySource.rs");
include!("CoroutineInstance.rs");
include!("ParentInstructingChild.rs");
include!("ResumeOutcome.rs");
include!("StartedCoroutineInstance.rs");
include!("StartOutcome.rs");
include!("Yielder.rs");


/// Context; derived from `Boost.Context` and [context-rs](https://github.com/zonyitoo/context-rs).
///
/// Use the `TypeSafeTransfer` struct to work with contexts (or the lower-level `Transfer`).
pub mod context;


/// Stack implementations.
pub mod stacks;