auto _this = reinterpret_cast<context_switching_actor*>(this_ptr);

bool cleanup_called = false;

try { _this->run(); }

catch (actor_exited&) {

// cleanup already called by scheduled_actor::quit

cleanup_called = true;

}

catch (...) {

_this->cleanup(exit_reason::unhandled_exception);

cleanup_called = true;

}

if (!cleanup_called) _this->cleanup(exit_reason::normal);

_this->on_exit();

std::atomic_thread_fence(std::memory_order_seq_cst);

detail::yield(detail::yield_state::done);

CPPA_REQUIRE(from != nullptr);

CPPA_REQUIRE(next_job == nullptr);

using namespace detail;

scoped_self_setter sss{this};

for (;;) {

switch (call(&m_fiber, from)) {

case yield_state::done: {

CPPA_REQUIRE(next_job == nullptr);

m_chained_actor.swap(next_job);

return resume_result::actor_done;

}

case yield_state::ready: {

break;

}

case yield_state::blocked: {

CPPA_REQUIRE(next_job == nullptr);

m_chained_actor.swap(next_job);

CPPA_REQUIRE(m_chained_actor == nullptr);

switch (compare_exchange_state(abstract_scheduled_actor::about_to_block,

abstract_scheduled_actor::blocked)) {

case abstract_scheduled_actor::ready: {

// restore variables

m_chained_actor.swap(next_job);

CPPA_REQUIRE(next_job == nullptr);

break;

}

case abstract_scheduled_actor::blocked: {

// wait until someone re-schedules that actor

return resume_result::actor_blocked;

}

default: {

CPPA_CRITICAL("illegal yield result");

}

}

break;

}

default: {

CPPA_CRITICAL("illegal state");

}

}

}