1
2// Copyright Oliver Kowalke 2009.
3// Distributed under the Boost Software License, Version 1.0.
4// (See accompanying file LICENSE_1_0.txt or copy at
5// http://www.boost.org/LICENSE_1_0.txt)
6
7#ifndef BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
8#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
9
10#include <boost/assert.hpp>
11#include <boost/config.hpp>
12#include <boost/cstdint.hpp>
13#include <boost/utility.hpp>
14
15#include <boost/coroutine/detail/config.hpp>
16#include <boost/coroutine/detail/coroutine_context.hpp>
17#include <boost/coroutine/detail/flags.hpp>
18#include <boost/coroutine/detail/parameters.hpp>
19#include <boost/coroutine/detail/preallocated.hpp>
20#include <boost/coroutine/detail/trampoline.hpp>
21#include <boost/coroutine/exceptions.hpp>
22#include <boost/coroutine/stack_context.hpp>
23
24#ifdef BOOST_HAS_ABI_HEADERS
25# include BOOST_ABI_PREFIX
26#endif
27
28namespace boost {
29namespace coroutines {
30namespace detail {
31
32template< typename R >
33class symmetric_coroutine_impl : private noncopyable
34{
35public:
36 typedef parameters< R > param_type;
37
38 symmetric_coroutine_impl( preallocated const& palloc,
39 bool unwind) BOOST_NOEXCEPT :
40 flags_( 0),
41 caller_(),
42 callee_( trampoline< symmetric_coroutine_impl< R > >, palloc)
43 {
44 if ( unwind) flags_ |= flag_force_unwind;
45 }
46
47 virtual ~symmetric_coroutine_impl() {}
48
49 bool force_unwind() const BOOST_NOEXCEPT
50 { return 0 != ( flags_ & flag_force_unwind); }
51
52 bool unwind_requested() const BOOST_NOEXCEPT
53 { return 0 != ( flags_ & flag_unwind_stack); }
54
55 bool is_started() const BOOST_NOEXCEPT
56 { return 0 != ( flags_ & flag_started); }
57
58 bool is_running() const BOOST_NOEXCEPT
59 { return 0 != ( flags_ & flag_running); }
60
61 bool is_complete() const BOOST_NOEXCEPT
62 { return 0 != ( flags_ & flag_complete); }
63
64 void unwind_stack() BOOST_NOEXCEPT
65 {
66 if ( is_started() && ! is_complete() && force_unwind() )
67 {
68 flags_ |= flag_unwind_stack;
69 flags_ |= flag_running;
70 param_type to( unwind_t::force_unwind);
71 caller_.jump(
72 callee_,
73 & to);
74 flags_ &= ~flag_running;
75 flags_ &= ~flag_unwind_stack;
76
77 BOOST_ASSERT( is_complete() );
78 }
79 }
80
81 void resume( R r) BOOST_NOEXCEPT
82 {
83 param_type to( const_cast< R * >( & r), this);
84 resume_( to: & to);
85 }
86
87 R * yield()
88 {
89 BOOST_ASSERT( is_running() );
90 BOOST_ASSERT( ! is_complete() );
91
92 flags_ &= ~flag_running;
93 param_type to;
94 param_type * from(
95 static_cast< param_type * >(
96 callee_.jump(
97 caller_,
98 & to) ) );
99 flags_ |= flag_running;
100 if ( from->do_unwind) throw forced_unwind();
101 BOOST_ASSERT( from->data);
102 return from->data;
103 }
104
105 template< typename X >
106 R * yield_to( symmetric_coroutine_impl< X > * other, X x)
107 {
108 typename symmetric_coroutine_impl< X >::param_type to( & x, other);
109 return yield_to_( other, & to);
110 }
111
112 template< typename X >
113 R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
114 {
115 typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
116 return yield_to_( other, & to);
117 }
118
119 template< typename X >
120 R * yield_to( symmetric_coroutine_impl< X > * other)
121 {
122 typename symmetric_coroutine_impl< X >::param_type to( other);
123 return yield_to_( other, & to);
124 }
125
126 virtual void run( R *) BOOST_NOEXCEPT = 0;
127
128 virtual void destroy() = 0;
129
130protected:
131 template< typename X >
132 friend class symmetric_coroutine_impl;
133
134 int flags_;
135 coroutine_context caller_;
136 coroutine_context callee_;
137
138 void resume_( param_type * to) BOOST_NOEXCEPT
139 {
140 BOOST_ASSERT( ! is_running() );
141 BOOST_ASSERT( ! is_complete() );
142
143 flags_ |= flag_running;
144 caller_.jump(
145 callee_,
146 to);
147 flags_ &= ~flag_running;
148 }
149
150 template< typename Other >
151 R * yield_to_( Other * other, typename Other::param_type * to)
152 {
153 BOOST_ASSERT( is_running() );
154 BOOST_ASSERT( ! is_complete() );
155 BOOST_ASSERT( ! other->is_running() );
156 BOOST_ASSERT( ! other->is_complete() );
157
158 other->caller_ = caller_;
159 flags_ &= ~flag_running;
160 param_type * from(
161 static_cast< param_type * >(
162 callee_.jump(
163 other->callee_,
164 to) ) );
165 flags_ |= flag_running;
166 if ( from->do_unwind) throw forced_unwind();
167 BOOST_ASSERT( from->data);
168 return from->data;
169 }
170};
171
172template< typename R >
173class symmetric_coroutine_impl< R & > : private noncopyable
174{
175public:
176 typedef parameters< R & > param_type;
177
178 symmetric_coroutine_impl( preallocated const& palloc,
179 bool unwind) BOOST_NOEXCEPT :
180 flags_( 0),
181 caller_(),
182 callee_( trampoline< symmetric_coroutine_impl< R > >, palloc)
183 {
184 if ( unwind) flags_ |= flag_force_unwind;
185 }
186
187 virtual ~symmetric_coroutine_impl() {}
188
189 bool force_unwind() const BOOST_NOEXCEPT
190 { return 0 != ( flags_ & flag_force_unwind); }
191
192 bool unwind_requested() const BOOST_NOEXCEPT
193 { return 0 != ( flags_ & flag_unwind_stack); }
194
195 bool is_started() const BOOST_NOEXCEPT
196 { return 0 != ( flags_ & flag_started); }
197
198 bool is_running() const BOOST_NOEXCEPT
199 { return 0 != ( flags_ & flag_running); }
200
201 bool is_complete() const BOOST_NOEXCEPT
202 { return 0 != ( flags_ & flag_complete); }
203
204 void unwind_stack() BOOST_NOEXCEPT
205 {
206 if ( is_started() && ! is_complete() && force_unwind() )
207 {
208 flags_ |= flag_unwind_stack;
209 flags_ |= flag_running;
210 param_type to( unwind_t::force_unwind);
211 caller_.jump(
212 callee_,
213 & to);
214 flags_ &= ~flag_running;
215 flags_ &= ~flag_unwind_stack;
216
217 BOOST_ASSERT( is_complete() );
218 }
219 }
220
221 void resume( R & arg) BOOST_NOEXCEPT
222 {
223 param_type to( & arg, this);
224 resume_( to: & to);
225 }
226
227 R * yield()
228 {
229 BOOST_ASSERT( is_running() );
230 BOOST_ASSERT( ! is_complete() );
231
232 flags_ &= ~flag_running;
233 param_type to;
234 param_type * from(
235 static_cast< param_type * >(
236 callee_.jump(
237 caller_,
238 & to) ) );
239 flags_ |= flag_running;
240 if ( from->do_unwind) throw forced_unwind();
241 BOOST_ASSERT( from->data);
242 return from->data;
243 }
244
245 template< typename X >
246 R * yield_to( symmetric_coroutine_impl< X > * other, X x)
247 {
248 typename symmetric_coroutine_impl< X >::param_type to( & x, other);
249 return yield_to_( other, & to);
250 }
251
252 template< typename X >
253 R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
254 {
255 typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
256 return yield_to_( other, & to);
257 }
258
259 template< typename X >
260 R * yield_to( symmetric_coroutine_impl< X > * other)
261 {
262 typename symmetric_coroutine_impl< X >::param_type to( other);
263 return yield_to_( other, & to);
264 }
265
266 virtual void run( R *) BOOST_NOEXCEPT = 0;
267
268 virtual void destroy() = 0;
269
270protected:
271 template< typename X >
272 friend class symmetric_coroutine_impl;
273
274 int flags_;
275 coroutine_context caller_;
276 coroutine_context callee_;
277
278 void resume_( param_type * to) BOOST_NOEXCEPT
279 {
280 BOOST_ASSERT( ! is_running() );
281 BOOST_ASSERT( ! is_complete() );
282
283 flags_ |= flag_running;
284 caller_.jump(
285 callee_,
286 to);
287 flags_ &= ~flag_running;
288 }
289
290 template< typename Other >
291 R * yield_to_( Other * other, typename Other::param_type * to)
292 {
293 BOOST_ASSERT( is_running() );
294 BOOST_ASSERT( ! is_complete() );
295 BOOST_ASSERT( ! other->is_running() );
296 BOOST_ASSERT( ! other->is_complete() );
297
298 other->caller_ = caller_;
299 flags_ &= ~flag_running;
300 param_type * from(
301 static_cast< param_type * >(
302 callee_.jump(
303 other->callee_,
304 to) ) );
305 flags_ |= flag_running;
306 if ( from->do_unwind) throw forced_unwind();
307 BOOST_ASSERT( from->data);
308 return from->data;
309 }
310};
311
312template<>
313class symmetric_coroutine_impl< void > : private noncopyable
314{
315public:
316 typedef parameters< void > param_type;
317
318 symmetric_coroutine_impl( preallocated const& palloc,
319 bool unwind) BOOST_NOEXCEPT :
320 flags_( 0),
321 caller_(),
322 callee_( trampoline_void< symmetric_coroutine_impl< void > >, palloc)
323 {
324 if ( unwind) flags_ |= flag_force_unwind;
325 }
326
327 virtual ~symmetric_coroutine_impl() {}
328
329 inline bool force_unwind() const BOOST_NOEXCEPT
330 { return 0 != ( flags_ & flag_force_unwind); }
331
332 inline bool unwind_requested() const BOOST_NOEXCEPT
333 { return 0 != ( flags_ & flag_unwind_stack); }
334
335 inline bool is_started() const BOOST_NOEXCEPT
336 { return 0 != ( flags_ & flag_started); }
337
338 inline bool is_running() const BOOST_NOEXCEPT
339 { return 0 != ( flags_ & flag_running); }
340
341 inline bool is_complete() const BOOST_NOEXCEPT
342 { return 0 != ( flags_ & flag_complete); }
343
344 inline void unwind_stack() BOOST_NOEXCEPT
345 {
346 if ( is_started() && ! is_complete() && force_unwind() )
347 {
348 flags_ |= flag_unwind_stack;
349 flags_ |= flag_running;
350 param_type to( unwind_t::force_unwind);
351 caller_.jump(
352 callee_,
353 & to);
354 flags_ &= ~flag_running;
355 flags_ &= ~flag_unwind_stack;
356
357 BOOST_ASSERT( is_complete() );
358 }
359 }
360
361 inline void resume() BOOST_NOEXCEPT
362 {
363 BOOST_ASSERT( ! is_running() );
364 BOOST_ASSERT( ! is_complete() );
365
366 param_type to( this);
367 flags_ |= flag_running;
368 caller_.jump(
369 callee_,
370 & to);
371 flags_ &= ~flag_running;
372 }
373
374 inline void yield()
375 {
376 BOOST_ASSERT( is_running() );
377 BOOST_ASSERT( ! is_complete() );
378
379 flags_ &= ~flag_running;
380 param_type to;
381 param_type * from(
382 static_cast< param_type * >(
383 callee_.jump(
384 caller_,
385 & to) ) );
386 flags_ |= flag_running;
387 if ( from->do_unwind) throw forced_unwind();
388 }
389
390 template< typename X >
391 void yield_to( symmetric_coroutine_impl< X > * other, X x)
392 {
393 typename symmetric_coroutine_impl< X >::param_type to( & x, other);
394 yield_to_( other, & to);
395 }
396
397 template< typename X >
398 void yield_to( symmetric_coroutine_impl< X & > * other, X & x)
399 {
400 typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
401 yield_to_( other, & to);
402 }
403
404 template< typename X >
405 void yield_to( symmetric_coroutine_impl< X > * other)
406 {
407 typename symmetric_coroutine_impl< X >::param_type to( other);
408 yield_to_( other, & to);
409 }
410
411 virtual void run() BOOST_NOEXCEPT = 0;
412
413 virtual void destroy() = 0;
414
415protected:
416 template< typename X >
417 friend class symmetric_coroutine_impl;
418
419 int flags_;
420 coroutine_context caller_;
421 coroutine_context callee_;
422
423 template< typename Other >
424 void yield_to_( Other * other, typename Other::param_type * to)
425 {
426 BOOST_ASSERT( is_running() );
427 BOOST_ASSERT( ! is_complete() );
428 BOOST_ASSERT( ! other->is_running() );
429 BOOST_ASSERT( ! other->is_complete() );
430
431 other->caller_ = caller_;
432 flags_ &= ~flag_running;
433 param_type * from(
434 static_cast< param_type * >(
435 callee_.jump(
436 other->callee_,
437 to) ) );
438 flags_ |= flag_running;
439 if ( from->do_unwind) throw forced_unwind();
440 }
441};
442
443}}}
444
445#ifdef BOOST_HAS_ABI_HEADERS
446# include BOOST_ABI_SUFFIX
447#endif
448
449#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
450

source code of boost/libs/coroutine/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp