return coro_handle::from_promise(*this);
}
auto initial_suspend() { return std::suspend_always(); }
- auto final_suspend() { return std::suspend_always(); }
+ auto final_suspend() noexcept { return std::suspend_always(); }
void yield_value(int v) { value_ = v; }
void unhandled_exception() {}
};
~promise_type() {}
Coro get_return_object () { return Coro (handle_type::from_promise (*this)); }
auto initial_suspend () { return coro::suspend_always{}; }
- auto final_suspend () { return coro::suspend_always{}; }
+ auto final_suspend () noexcept { return coro::suspend_always{}; }
void return_void () { }
void unhandled_exception() { }
};
auto get_return_object () { return handle_type::from_promise (*this);}
coro::suspend_always initial_suspend () const { return {}; }
- coro::suspend_always final_suspend () const { return {}; }
+ coro::suspend_always final_suspend () const noexcept { return {}; }
void return_value(T&& v) noexcept { value = std::move(v); }
void return_value(const T&) noexcept = delete;
return coro_handle::from_promise(*this);
}
auto initial_suspend() { return std::suspend_always(); }
- auto final_suspend() { return std::suspend_always(); }
+ auto final_suspend() noexcept { return std::suspend_always(); }
void return_value(int v) { value_ = v; }
std::suspend_always yield_value(int v) {
value_ = v;
DummyYield (coro::coroutine_handle<> handle) : handle (handle) {}
struct dummy_yield {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
DummyYield get_return_object() {
return DummyYield (coro::coroutine_handle<dummy_yield>::from_promise (*this));
}
}
~promise_type () { PRINT ("Destroyed Promise"); g_promise = 0;}
Thing get_return_object() { return {}; }
-
+ //int get_return_object() { return 0; }
auto initial_suspend() {
return std::suspend_always{};
}
- auto final_suspend() { return std::suspend_never{}; }
+ auto final_suspend() noexcept { return std::suspend_never{}; }
void return_void() {}
void unhandled_exception() {}
auto initial_suspend() {
return std::suspend_always{};
}
- auto final_suspend() { return std::suspend_never{}; }
+ auto final_suspend() noexcept { return std::suspend_never{}; }
void return_void() {}
void unhandled_exception() {}
MissingGRO (coro::coroutine_handle<> handle) : handle (handle) {}
struct missing_gro {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
void return_void () {}
void unhandled_exception() { /*std::terminate();*/ };
};
MissingPromiseYield (coro::coroutine_handle<> handle) : handle (handle) {}
struct missing_yield {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
MissingPromiseYield get_return_object() {
return MissingPromiseYield (coro::coroutine_handle<missing_yield>::from_promise (*this));
}
MissingRetValue (coro::coroutine_handle<> handle) : handle (handle) {}
struct missing_retvoid {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
MissingRetValue get_return_object() {
return MissingRetValue (coro::coroutine_handle<missing_retvoid>::from_promise (*this));
}
MissingRetVoid (coro::coroutine_handle<> handle) : handle (handle) {}
struct missing_retvoid {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
MissingRetVoid get_return_object() {
return MissingRetVoid (coro::coroutine_handle<missing_retvoid>::from_promise (*this));
}
MissingUEH (coro::coroutine_handle<> handle) : handle (handle) {}
struct missing_ueh {
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
MissingUEH get_return_object() {
return MissingUEH (coro::coroutine_handle<missing_ueh>::from_promise (*this));
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
#endif
#ifdef MISSING_FINAL_SUSPEND
#else
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
promise(Class &,int) { static_assert(!std::is_pointer<Class>::value, ""); }
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
future get_return_object() { return {}; }
promise_type() {}
task get_return_object() { return {}; }
suspend_never initial_suspend() { return {}; }
- suspend_never final_suspend() { return {}; }
+ suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
promise_type (CallOp op, T ...args) {}
Fake get_return_object() { return {}; }
std::suspend_always initial_suspend() { return {}; }
- std::suspend_never final_suspend() { return {}; }
+ std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
public:
std::g initial_suspend();
- l final_suspend();
+ l final_suspend() noexcept;
};
class m : public j {
public:
public:
void get_return_object();
std::b initial_suspend();
- j final_suspend();
+ j final_suspend() noexcept;
void unhandled_exception();
template <typename g>
auto await_transform (g c) { return ab(f, c); }
{
auto get_return_object () -> task { return {}; }
auto initial_suspend () -> suspend_always { return {}; }
- auto final_suspend () -> suspend_always { return {}; }
+ auto final_suspend () noexcept -> suspend_always { return {}; }
void return_void () {}
void unhandled_exception () { }
void thing (ret_type x) {}
void await_resume() { }
dummy_coro get_return_object() { return {}; }
dummy_coro initial_suspend() { return {}; }
- dummy_coro final_suspend() { return {}; }
+ dummy_coro final_suspend() noexcept { return {}; }
void return_void() { }
void unhandled_exception() { }
};
// static constexpr suspend_n initial_suspend() { return {2}; }
#endif
static constexpr std::suspend_always initial_suspend() { return {}; }
- static constexpr std::suspend_never final_suspend() { return {}; }
+ static constexpr std::suspend_never final_suspend() noexcept { return {}; }
static constexpr void return_void() {}
static constexpr void unhandled_exception() {}
};
void return_void();
void unhandled_exception();
suspend_always initial_suspend();
- suspend_always final_suspend();
+ suspend_always final_suspend() noexcept;
template<typename Arg>
suspend_always yield_value(Arg&&) {
std::suspend_always initial_suspend (){
return {};
}
- std::suspend_always final_suspend (){
+ std::suspend_always final_suspend () noexcept {
return {};
}
struct coroutine_traits<lazy<T>, Args...> {
struct promise_type {
suspend_always initial_suspend() const { return {}; }
- suspend_always final_suspend() const { return {}; }
+ suspend_always final_suspend() const noexcept { return {}; }
void return_value(T val) {}
lazy<T> get_return_object() {
return lazy<T>();
}
coro::suspend_always initial_suspend() { return {}; }
- coro::suspend_always final_suspend() { return {}; }
+ coro::suspend_always final_suspend() noexcept { return {}; }
void unhandled_exception() { /*std::terminate();*/ }
void return_void() {}
return suspend_never_prt{};
}
- auto final_suspend() {
+ auto final_suspend() noexcept {
PRINT ("get final_suspend");
return suspend_always_prt{};
}
return coro_handle::from_promise(*this);
}
auto initial_suspend() { return std::suspend_never(); }
- auto final_suspend() { return std::suspend_always(); }
+ auto final_suspend() noexcept { return std::suspend_always(); }
void return_value(int x) {used = x;}
void unhandled_exception() {}
PRINT ("get initial_suspend (never) ");
return suspend_never_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always) ");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () const {
+ auto final_suspend () const noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- suspend_always_prt final_suspend () const {
+ suspend_always_prt final_suspend () const noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always, but really never) ");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always, but never) ");
return suspend_always_prt{};
}
using coro_handle = std::coroutine_handle<promise_type>;
auto get_return_object() { return coro_handle::from_promise(*this); }
auto initial_suspend() { return std::suspend_always(); }
- auto final_suspend() { return std::suspend_always(); }
+ auto final_suspend() noexcept { return std::suspend_always(); }
void return_void() { value_ = -1; }
void unhandled_exception() {}
private:
auto initial_suspend() {
return std::suspend_always{};
}
- auto final_suspend() { return std::suspend_never{}; }
+ auto final_suspend() noexcept { return std::suspend_never{}; }
void return_void() {}
void unhandled_exception() {}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
PRINT ("get initial_suspend (always)");
return suspend_always_susp_throws_prt(throw_control);
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
int a, b, c;
nontriv (int _a, int _b, int _c) : a(_a), b(_b), c(_c) {}
virtual int getA () { return a; }
+ ~nontriv() { a = -1; }
};
struct coro1
{
if (t.a > 30)
{
- PRINTF ("coro1: about to return %d", t.b);
+ PRINTF ("coro1: about to return %d\n", t.b);
co_return t.b;
}
else if (t.a > 20)
{
- PRINTF ("coro1: about to co-return %d", t.c);
+ PRINTF ("coro1: about to co-return %d\n", t.c);
co_return t.c;
}
else
promise (Args&... args) {}
coro::suspend_never initial_suspend() { return {}; }
- coro::suspend_never final_suspend() { return {}; }
+ coro::suspend_never final_suspend() noexcept { return {}; }
future get_return_object() { return {}; }
PRINT ("get initial_suspend (always)");
return suspend_always_prt{};
}
- auto final_suspend () {
+ auto final_suspend () noexcept {
PRINT ("get final_suspend (always)");
return suspend_always_prt{};
}
projects / platform / upstream / gcc.git / commitdiff