From e6c8317b407cc1d66789482f7113b59afb87acb4 Mon Sep 17 00:00:00 2001 From: Marc Alexander Lehmann Date: Thu, 25 Oct 2018 03:11:04 +0000 Subject: [PATCH] *** empty log message *** --- Changes | 3 + ev++.h | 164 +++++++++++++++++++++++++++--------------------------- ev.c | 146 ++++++++++++++++++++++++------------------------ ev.h | 156 +++++++++++++++++++++++++-------------------------- ev_vars.h | 4 +- 5 files changed, 238 insertions(+), 235 deletions(-) diff --git a/Changes b/Changes index aa235bc..7747e10 100644 --- a/Changes +++ b/Changes @@ -6,6 +6,9 @@ Revision history for libev, a high-performance and full-featured event loop. - disable epoll_create1 on android because it has broken header files and google is unwilling to fix them (reported by enh@google.com). - avoid a minor compilation warning on win32. + - c++: rename EV_THROW to EV_NOEXCEPT + - c++: remove deprecated dynamic throw() specifications. + - c++: improve the (unsupported) bad_loop exception class. 4.24 Wed Dec 28 05:19:55 CET 2016 - bump version to 4.24, as the release tarball inexplicably diff --git a/ev++.h b/ev++.h index c9b453b..a3e57de 100644 --- a/ev++.h +++ b/ev++.h @@ -113,13 +113,13 @@ namespace ev { struct bad_loop #if EV_USE_STDEXCEPT - : std::runtime_error + : std::exception #endif { #if EV_USE_STDEXCEPT - bad_loop () - : std::runtime_error ("libev event loop cannot be initialized, bad value of LIBEV_FLAGS?") + const char *what () const EV_NOEXCEPT { + return "libev event loop cannot be initialized, bad value of LIBEV_FLAGS?"; } #endif }; @@ -142,14 +142,14 @@ namespace ev { struct loop_ref { - loop_ref (EV_P) throw () + loop_ref (EV_P) EV_NOEXCEPT #if EV_MULTIPLICITY : EV_AX (EV_A) #endif { } - bool operator == (const loop_ref &other) const throw () + bool operator == (const loop_ref &other) const EV_NOEXCEPT { #if EV_MULTIPLICITY return EV_AX == other.EV_AX; @@ -158,7 +158,7 @@ namespace ev { #endif } - bool operator != (const loop_ref &other) const throw () + bool operator != (const loop_ref &other) const EV_NOEXCEPT { #if EV_MULTIPLICITY return ! (*this == other); @@ -168,27 +168,27 @@ namespace ev { } #if EV_MULTIPLICITY - bool operator == (const EV_P) const throw () + bool operator == (const EV_P) const EV_NOEXCEPT { return this->EV_AX == EV_A; } - bool operator != (const EV_P) const throw () + bool operator != (const EV_P) const EV_NOEXCEPT { return ! (*this == EV_A); } - operator struct ev_loop * () const throw () + operator struct ev_loop * () const EV_NOEXCEPT { return EV_AX; } - operator const struct ev_loop * () const throw () + operator const struct ev_loop * () const EV_NOEXCEPT { return EV_AX; } - bool is_default () const throw () + bool is_default () const EV_NOEXCEPT { return EV_AX == ev_default_loop (0); } @@ -200,7 +200,7 @@ namespace ev { ev_run (EV_AX_ flags); } - void unloop (how_t how = ONE) throw () + void unloop (how_t how = ONE) EV_NOEXCEPT { ev_break (EV_AX_ how); } @@ -211,74 +211,74 @@ namespace ev { ev_run (EV_AX_ flags); } - void break_loop (how_t how = ONE) throw () + void break_loop (how_t how = ONE) EV_NOEXCEPT { ev_break (EV_AX_ how); } - void post_fork () throw () + void post_fork () EV_NOEXCEPT { ev_loop_fork (EV_AX); } - unsigned int backend () const throw () + unsigned int backend () const EV_NOEXCEPT { return ev_backend (EV_AX); } - tstamp now () const throw () + tstamp now () const EV_NOEXCEPT { return ev_now (EV_AX); } - void ref () throw () + void ref () EV_NOEXCEPT { ev_ref (EV_AX); } - void unref () throw () + void unref () EV_NOEXCEPT { ev_unref (EV_AX); } #if EV_FEATURE_API - unsigned int iteration () const throw () + unsigned int iteration () const EV_NOEXCEPT { return ev_iteration (EV_AX); } - unsigned int depth () const throw () + unsigned int depth () const EV_NOEXCEPT { return ev_depth (EV_AX); } - void set_io_collect_interval (tstamp interval) throw () + void set_io_collect_interval (tstamp interval) EV_NOEXCEPT { ev_set_io_collect_interval (EV_AX_ interval); } - void set_timeout_collect_interval (tstamp interval) throw () + void set_timeout_collect_interval (tstamp interval) EV_NOEXCEPT { ev_set_timeout_collect_interval (EV_AX_ interval); } #endif // function callback - void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void *arg = 0) throw () + void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void *arg = 0) EV_NOEXCEPT { ev_once (EV_AX_ fd, events, timeout, cb, arg); } // method callback template - void once (int fd, int events, tstamp timeout, K *object) throw () + void once (int fd, int events, tstamp timeout, K *object) EV_NOEXCEPT { once (fd, events, timeout, method_thunk, object); } // default method == operator () template - void once (int fd, int events, tstamp timeout, K *object) throw () + void once (int fd, int events, tstamp timeout, K *object) EV_NOEXCEPT { once (fd, events, timeout, method_thunk, object); } @@ -292,7 +292,7 @@ namespace ev { // no-argument method callback template - void once (int fd, int events, tstamp timeout, K *object) throw () + void once (int fd, int events, tstamp timeout, K *object) EV_NOEXCEPT { once (fd, events, timeout, method_noargs_thunk, object); } @@ -306,7 +306,7 @@ namespace ev { // simpler function callback template - void once (int fd, int events, tstamp timeout) throw () + void once (int fd, int events, tstamp timeout) EV_NOEXCEPT { once (fd, events, timeout, simpler_func_thunk); } @@ -320,7 +320,7 @@ namespace ev { // simplest function callback template - void once (int fd, int events, tstamp timeout) throw () + void once (int fd, int events, tstamp timeout) EV_NOEXCEPT { once (fd, events, timeout, simplest_func_thunk); } @@ -332,12 +332,12 @@ namespace ev { (); } - void feed_fd_event (int fd, int revents) throw () + void feed_fd_event (int fd, int revents) EV_NOEXCEPT { ev_feed_fd_event (EV_AX_ fd, revents); } - void feed_signal_event (int signum) throw () + void feed_signal_event (int signum) EV_NOEXCEPT { ev_feed_signal_event (EV_AX_ signum); } @@ -352,14 +352,14 @@ namespace ev { struct dynamic_loop : loop_ref { - dynamic_loop (unsigned int flags = AUTO) throw (bad_loop) + dynamic_loop (unsigned int flags = AUTO) : loop_ref (ev_loop_new (flags)) { if (!EV_AX) throw bad_loop (); } - ~dynamic_loop () throw () + ~dynamic_loop () EV_NOEXCEPT { ev_loop_destroy (EV_AX); EV_AX = 0; @@ -376,7 +376,7 @@ namespace ev { struct default_loop : loop_ref { - default_loop (unsigned int flags = AUTO) throw (bad_loop) + default_loop (unsigned int flags = AUTO) #if EV_MULTIPLICITY : loop_ref (ev_default_loop (flags)) #endif @@ -396,7 +396,7 @@ namespace ev { default_loop &operator = (const default_loop &); }; - inline loop_ref get_default_loop () throw () + inline loop_ref get_default_loop () EV_NOEXCEPT { #if EV_MULTIPLICITY return ev_default_loop (0); @@ -425,13 +425,13 @@ namespace ev { EV_PX; // loop set - void set (EV_P) throw () + void set (EV_P) EV_NOEXCEPT { this->EV_A = EV_A; } #endif - base (EV_PX) throw () + base (EV_PX) EV_NOEXCEPT #if EV_MULTIPLICITY : EV_A (EV_A) #endif @@ -439,7 +439,7 @@ namespace ev { ev_init (this, 0); } - void set_ (const void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) throw () + void set_ (const void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) EV_NOEXCEPT { this->data = (void *)data; ev_set_cb (static_cast(this), cb); @@ -447,7 +447,7 @@ namespace ev { // function callback template - void set (void *data = 0) throw () + void set (void *data = 0) EV_NOEXCEPT { set_ (data, function_thunk); } @@ -461,14 +461,14 @@ namespace ev { // method callback template - void set (K *object) throw () + void set (K *object) EV_NOEXCEPT { set_ (object, method_thunk); } // default method == operator () template - void set (K *object) throw () + void set (K *object) EV_NOEXCEPT { set_ (object, method_thunk); } @@ -482,7 +482,7 @@ namespace ev { // no-argument callback template - void set (K *object) throw () + void set (K *object) EV_NOEXCEPT { set_ (object, method_noargs_thunk); } @@ -501,76 +501,76 @@ namespace ev { (static_cast(this), events); } - bool is_active () const throw () + bool is_active () const EV_NOEXCEPT { return ev_is_active (static_cast(this)); } - bool is_pending () const throw () + bool is_pending () const EV_NOEXCEPT { return ev_is_pending (static_cast(this)); } - void feed_event (int revents) throw () + void feed_event (int revents) EV_NOEXCEPT { ev_feed_event (EV_A_ static_cast(this), revents); } }; - inline tstamp now (EV_P) throw () + inline tstamp now (EV_P) EV_NOEXCEPT { return ev_now (EV_A); } - inline void delay (tstamp interval) throw () + inline void delay (tstamp interval) EV_NOEXCEPT { ev_sleep (interval); } - inline int version_major () throw () + inline int version_major () EV_NOEXCEPT { return ev_version_major (); } - inline int version_minor () throw () + inline int version_minor () EV_NOEXCEPT { return ev_version_minor (); } - inline unsigned int supported_backends () throw () + inline unsigned int supported_backends () EV_NOEXCEPT { return ev_supported_backends (); } - inline unsigned int recommended_backends () throw () + inline unsigned int recommended_backends () EV_NOEXCEPT { return ev_recommended_backends (); } - inline unsigned int embeddable_backends () throw () + inline unsigned int embeddable_backends () EV_NOEXCEPT { return ev_embeddable_backends (); } - inline void set_allocator (void *(*cb)(void *ptr, long size) throw ()) throw () + inline void set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT { ev_set_allocator (cb); } - inline void set_syserr_cb (void (*cb)(const char *msg) throw ()) throw () + inline void set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT { ev_set_syserr_cb (cb); } #if EV_MULTIPLICITY #define EV_CONSTRUCT(cppstem,cstem) \ - (EV_PX = get_default_loop ()) throw () \ + (EV_PX = get_default_loop ()) EV_NOEXCEPT \ : base (EV_A) \ { \ } #else #define EV_CONSTRUCT(cppstem,cstem) \ - () throw () \ + () EV_NOEXCEPT \ { \ } #endif @@ -581,19 +581,19 @@ namespace ev { \ struct cppstem : base \ { \ - void start () throw () \ + void start () EV_NOEXCEPT \ { \ ev_ ## cstem ## _start (EV_A_ static_cast(this)); \ } \ \ - void stop () throw () \ + void stop () EV_NOEXCEPT \ { \ ev_ ## cstem ## _stop (EV_A_ static_cast(this)); \ } \ \ cppstem EV_CONSTRUCT(cppstem,cstem) \ \ - ~cppstem () throw () \ + ~cppstem () EV_NOEXCEPT \ { \ stop (); \ } \ @@ -612,7 +612,7 @@ namespace ev { }; EV_BEGIN_WATCHER (io, io) - void set (int fd, int events) throw () + void set (int fd, int events) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -620,7 +620,7 @@ namespace ev { if (active) start (); } - void set (int events) throw () + void set (int events) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -628,7 +628,7 @@ namespace ev { if (active) start (); } - void start (int fd, int events) throw () + void start (int fd, int events) EV_NOEXCEPT { set (fd, events); start (); @@ -636,7 +636,7 @@ namespace ev { EV_END_WATCHER (io, io) EV_BEGIN_WATCHER (timer, timer) - void set (ev_tstamp after, ev_tstamp repeat = 0.) throw () + void set (ev_tstamp after, ev_tstamp repeat = 0.) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -644,13 +644,13 @@ namespace ev { if (active) start (); } - void start (ev_tstamp after, ev_tstamp repeat = 0.) throw () + void start (ev_tstamp after, ev_tstamp repeat = 0.) EV_NOEXCEPT { set (after, repeat); start (); } - void again () throw () + void again () EV_NOEXCEPT { ev_timer_again (EV_A_ static_cast(this)); } @@ -663,7 +663,7 @@ namespace ev { #if EV_PERIODIC_ENABLE EV_BEGIN_WATCHER (periodic, periodic) - void set (ev_tstamp at, ev_tstamp interval = 0.) throw () + void set (ev_tstamp at, ev_tstamp interval = 0.) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -671,13 +671,13 @@ namespace ev { if (active) start (); } - void start (ev_tstamp at, ev_tstamp interval = 0.) throw () + void start (ev_tstamp at, ev_tstamp interval = 0.) EV_NOEXCEPT { set (at, interval); start (); } - void again () throw () + void again () EV_NOEXCEPT { ev_periodic_again (EV_A_ static_cast(this)); } @@ -686,7 +686,7 @@ namespace ev { #if EV_SIGNAL_ENABLE EV_BEGIN_WATCHER (sig, signal) - void set (int signum) throw () + void set (int signum) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -694,7 +694,7 @@ namespace ev { if (active) start (); } - void start (int signum) throw () + void start (int signum) EV_NOEXCEPT { set (signum); start (); @@ -704,7 +704,7 @@ namespace ev { #if EV_CHILD_ENABLE EV_BEGIN_WATCHER (child, child) - void set (int pid, int trace = 0) throw () + void set (int pid, int trace = 0) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -712,7 +712,7 @@ namespace ev { if (active) start (); } - void start (int pid, int trace = 0) throw () + void start (int pid, int trace = 0) EV_NOEXCEPT { set (pid, trace); start (); @@ -722,7 +722,7 @@ namespace ev { #if EV_STAT_ENABLE EV_BEGIN_WATCHER (stat, stat) - void set (const char *path, ev_tstamp interval = 0.) throw () + void set (const char *path, ev_tstamp interval = 0.) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -730,14 +730,14 @@ namespace ev { if (active) start (); } - void start (const char *path, ev_tstamp interval = 0.) throw () + void start (const char *path, ev_tstamp interval = 0.) EV_NOEXCEPT { stop (); set (path, interval); start (); } - void update () throw () + void update () EV_NOEXCEPT { ev_stat_stat (EV_A_ static_cast(this)); } @@ -746,25 +746,25 @@ namespace ev { #if EV_IDLE_ENABLE EV_BEGIN_WATCHER (idle, idle) - void set () throw () { } + void set () EV_NOEXCEPT { } EV_END_WATCHER (idle, idle) #endif #if EV_PREPARE_ENABLE EV_BEGIN_WATCHER (prepare, prepare) - void set () throw () { } + void set () EV_NOEXCEPT { } EV_END_WATCHER (prepare, prepare) #endif #if EV_CHECK_ENABLE EV_BEGIN_WATCHER (check, check) - void set () throw () { } + void set () EV_NOEXCEPT { } EV_END_WATCHER (check, check) #endif #if EV_EMBED_ENABLE EV_BEGIN_WATCHER (embed, embed) - void set_embed (struct ev_loop *embedded_loop) throw () + void set_embed (struct ev_loop *embedded_loop) EV_NOEXCEPT { int active = is_active (); if (active) stop (); @@ -772,7 +772,7 @@ namespace ev { if (active) start (); } - void start (struct ev_loop *embedded_loop) throw () + void start (struct ev_loop *embedded_loop) EV_NOEXCEPT { set (embedded_loop); start (); @@ -787,18 +787,18 @@ namespace ev { #if EV_FORK_ENABLE EV_BEGIN_WATCHER (fork, fork) - void set () throw () { } + void set () EV_NOEXCEPT { } EV_END_WATCHER (fork, fork) #endif #if EV_ASYNC_ENABLE EV_BEGIN_WATCHER (async, async) - void send () throw () + void send () EV_NOEXCEPT { ev_async_send (EV_A_ static_cast(this)); } - bool async_pending () throw () + bool async_pending () EV_NOEXCEPT { return ev_async_pending (static_cast(this)); } diff --git a/ev.c b/ev.c index e2b83ea..3d1ed9a 100644 --- a/ev.c +++ b/ev.c @@ -1679,11 +1679,11 @@ ev_printerr (const char *msg) } #endif -static void (*syserr_cb)(const char *msg) EV_THROW; +static void (*syserr_cb)(const char *msg) EV_NOEXCEPT; ecb_cold void -ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW +ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT { syserr_cb = cb; } @@ -1712,7 +1712,7 @@ ev_syserr (const char *msg) } static void * -ev_realloc_emul (void *ptr, long size) EV_THROW +ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT { /* some systems, notably openbsd and darwin, fail to properly * implement realloc (x, 0) (as required by both ansi c-89 and @@ -1728,11 +1728,11 @@ ev_realloc_emul (void *ptr, long size) EV_THROW return 0; } -static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul; +static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul; ecb_cold void -ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW +ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT { alloc = cb; } @@ -1859,7 +1859,7 @@ typedef struct #ifndef EV_HAVE_EV_TIME ev_tstamp -ev_time (void) EV_THROW +ev_time (void) EV_NOEXCEPT { #if EV_USE_REALTIME if (expect_true (have_realtime)) @@ -1893,14 +1893,14 @@ get_clock (void) #if EV_MULTIPLICITY ev_tstamp -ev_now (EV_P) EV_THROW +ev_now (EV_P) EV_NOEXCEPT { return ev_rt_now; } #endif void -ev_sleep (ev_tstamp delay) EV_THROW +ev_sleep (ev_tstamp delay) EV_NOEXCEPT { if (delay > 0.) { @@ -1996,7 +1996,7 @@ pendingcb (EV_P_ ev_prepare *w, int revents) noinline void -ev_feed_event (EV_P_ void *w, int revents) EV_THROW +ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT { W w_ = (W)w; int pri = ABSPRI (w_); @@ -2067,7 +2067,7 @@ fd_event (EV_P_ int fd, int revents) } void -ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW +ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT { if (fd >= 0 && fd < anfdmax) fd_event_nocheck (EV_A_ fd, revents); @@ -2559,7 +2559,7 @@ pipecb (EV_P_ ev_io *iow, int revents) /*****************************************************************************/ void -ev_feed_signal (int signum) EV_THROW +ev_feed_signal (int signum) EV_NOEXCEPT { #if EV_MULTIPLICITY EV_P; @@ -2586,7 +2586,7 @@ ev_sighandler (int signum) noinline void -ev_feed_signal_event (EV_P_ int signum) EV_THROW +ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT { WL w; @@ -2713,13 +2713,13 @@ childcb (EV_P_ ev_signal *sw, int revents) #endif ecb_cold int -ev_version_major (void) EV_THROW +ev_version_major (void) EV_NOEXCEPT { return EV_VERSION_MAJOR; } ecb_cold int -ev_version_minor (void) EV_THROW +ev_version_minor (void) EV_NOEXCEPT { return EV_VERSION_MINOR; } @@ -2738,7 +2738,7 @@ enable_secure (void) ecb_cold unsigned int -ev_supported_backends (void) EV_THROW +ev_supported_backends (void) EV_NOEXCEPT { unsigned int flags = 0; @@ -2753,7 +2753,7 @@ ev_supported_backends (void) EV_THROW ecb_cold unsigned int -ev_recommended_backends (void) EV_THROW +ev_recommended_backends (void) EV_NOEXCEPT { unsigned int flags = ev_supported_backends (); @@ -2776,7 +2776,7 @@ ev_recommended_backends (void) EV_THROW ecb_cold unsigned int -ev_embeddable_backends (void) EV_THROW +ev_embeddable_backends (void) EV_NOEXCEPT { int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; @@ -2788,56 +2788,56 @@ ev_embeddable_backends (void) EV_THROW } unsigned int -ev_backend (EV_P) EV_THROW +ev_backend (EV_P) EV_NOEXCEPT { return backend; } #if EV_FEATURE_API unsigned int -ev_iteration (EV_P) EV_THROW +ev_iteration (EV_P) EV_NOEXCEPT { return loop_count; } unsigned int -ev_depth (EV_P) EV_THROW +ev_depth (EV_P) EV_NOEXCEPT { return loop_depth; } void -ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW +ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT { io_blocktime = interval; } void -ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW +ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT { timeout_blocktime = interval; } void -ev_set_userdata (EV_P_ void *data) EV_THROW +ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT { userdata = data; } void * -ev_userdata (EV_P) EV_THROW +ev_userdata (EV_P) EV_NOEXCEPT { return userdata; } void -ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW +ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT { invoke_cb = invoke_pending_cb; } void -ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW +ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT { release_cb = release; acquire_cb = acquire; @@ -2847,7 +2847,7 @@ ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV /* initialise a loop structure, must be zero-initialised */ noinline ecb_cold static void -loop_init (EV_P_ unsigned int flags) EV_THROW +loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT { if (!backend) { @@ -3098,7 +3098,7 @@ loop_fork (EV_P) ecb_cold struct ev_loop * -ev_loop_new (unsigned int flags) EV_THROW +ev_loop_new (unsigned int flags) EV_NOEXCEPT { EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); @@ -3155,7 +3155,7 @@ array_verify (EV_P_ W *ws, int cnt) #if EV_FEATURE_API void ecb_cold -ev_verify (EV_P) EV_THROW +ev_verify (EV_P) EV_NOEXCEPT { #if EV_VERIFY int i; @@ -3246,7 +3246,7 @@ struct ev_loop * #else int #endif -ev_default_loop (unsigned int flags) EV_THROW +ev_default_loop (unsigned int flags) EV_NOEXCEPT { if (!ev_default_loop_ptr) { @@ -3275,7 +3275,7 @@ ev_default_loop (unsigned int flags) EV_THROW } void -ev_loop_fork (EV_P) EV_THROW +ev_loop_fork (EV_P) EV_NOEXCEPT { postfork = 1; } @@ -3289,7 +3289,7 @@ ev_invoke (EV_P_ void *w, int revents) } unsigned int -ev_pending_count (EV_P) EV_THROW +ev_pending_count (EV_P) EV_NOEXCEPT { int pri; unsigned int count = 0; @@ -3739,37 +3739,37 @@ ev_run (EV_P_ int flags) } void -ev_break (EV_P_ int how) EV_THROW +ev_break (EV_P_ int how) EV_NOEXCEPT { loop_done = how; } void -ev_ref (EV_P) EV_THROW +ev_ref (EV_P) EV_NOEXCEPT { ++activecnt; } void -ev_unref (EV_P) EV_THROW +ev_unref (EV_P) EV_NOEXCEPT { --activecnt; } void -ev_now_update (EV_P) EV_THROW +ev_now_update (EV_P) EV_NOEXCEPT { time_update (EV_A_ 1e100); } void -ev_suspend (EV_P) EV_THROW +ev_suspend (EV_P) EV_NOEXCEPT { ev_now_update (EV_A); } void -ev_resume (EV_P) EV_THROW +ev_resume (EV_P) EV_NOEXCEPT { ev_tstamp mn_prev = mn_now; @@ -3818,7 +3818,7 @@ clear_pending (EV_P_ W w) } int -ev_clear_pending (EV_P_ void *w) EV_THROW +ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT { W w_ = (W)w; int pending = w_->pending; @@ -3862,7 +3862,7 @@ ev_stop (EV_P_ W w) noinline void -ev_io_start (EV_P_ ev_io *w) EV_THROW +ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT { int fd = w->fd; @@ -3889,7 +3889,7 @@ ev_io_start (EV_P_ ev_io *w) EV_THROW noinline void -ev_io_stop (EV_P_ ev_io *w) EV_THROW +ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -3909,7 +3909,7 @@ ev_io_stop (EV_P_ ev_io *w) EV_THROW noinline void -ev_timer_start (EV_P_ ev_timer *w) EV_THROW +ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -3934,7 +3934,7 @@ ev_timer_start (EV_P_ ev_timer *w) EV_THROW noinline void -ev_timer_stop (EV_P_ ev_timer *w) EV_THROW +ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -3965,7 +3965,7 @@ ev_timer_stop (EV_P_ ev_timer *w) EV_THROW noinline void -ev_timer_again (EV_P_ ev_timer *w) EV_THROW +ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT { EV_FREQUENT_CHECK; @@ -3992,7 +3992,7 @@ ev_timer_again (EV_P_ ev_timer *w) EV_THROW } ev_tstamp -ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW +ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT { return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); } @@ -4000,7 +4000,7 @@ ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW #if EV_PERIODIC_ENABLE noinline void -ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW +ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4031,7 +4031,7 @@ ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW noinline void -ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW +ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4060,7 +4060,7 @@ ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW noinline void -ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW +ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT { /* TODO: use adjustheap and recalculation */ ev_periodic_stop (EV_A_ w); @@ -4076,7 +4076,7 @@ ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW noinline void -ev_signal_start (EV_P_ ev_signal *w) EV_THROW +ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4159,7 +4159,7 @@ ev_signal_start (EV_P_ ev_signal *w) EV_THROW noinline void -ev_signal_stop (EV_P_ ev_signal *w) EV_THROW +ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4200,7 +4200,7 @@ ev_signal_stop (EV_P_ ev_signal *w) EV_THROW #if EV_CHILD_ENABLE void -ev_child_start (EV_P_ ev_child *w) EV_THROW +ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT { #if EV_MULTIPLICITY assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr)); @@ -4217,7 +4217,7 @@ ev_child_start (EV_P_ ev_child *w) EV_THROW } void -ev_child_stop (EV_P_ ev_child *w) EV_THROW +ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4492,7 +4492,7 @@ infy_fork (EV_P) #endif void -ev_stat_stat (EV_P_ ev_stat *w) EV_THROW +ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT { if (lstat (w->path, &w->attr) < 0) w->attr.st_nlink = 0; @@ -4542,7 +4542,7 @@ stat_timer_cb (EV_P_ ev_timer *w_, int revents) } void -ev_stat_start (EV_P_ ev_stat *w) EV_THROW +ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4573,7 +4573,7 @@ ev_stat_start (EV_P_ ev_stat *w) EV_THROW } void -ev_stat_stop (EV_P_ ev_stat *w) EV_THROW +ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4599,7 +4599,7 @@ ev_stat_stop (EV_P_ ev_stat *w) EV_THROW #if EV_IDLE_ENABLE void -ev_idle_start (EV_P_ ev_idle *w) EV_THROW +ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4622,7 +4622,7 @@ ev_idle_start (EV_P_ ev_idle *w) EV_THROW } void -ev_idle_stop (EV_P_ ev_idle *w) EV_THROW +ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4646,7 +4646,7 @@ ev_idle_stop (EV_P_ ev_idle *w) EV_THROW #if EV_PREPARE_ENABLE void -ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW +ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4661,7 +4661,7 @@ ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW } void -ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW +ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4684,7 +4684,7 @@ ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW #if EV_CHECK_ENABLE void -ev_check_start (EV_P_ ev_check *w) EV_THROW +ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4699,7 +4699,7 @@ ev_check_start (EV_P_ ev_check *w) EV_THROW } void -ev_check_stop (EV_P_ ev_check *w) EV_THROW +ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4723,7 +4723,7 @@ ev_check_stop (EV_P_ ev_check *w) EV_THROW #if EV_EMBED_ENABLE noinline void -ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW +ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT { ev_run (w->other, EVRUN_NOWAIT); } @@ -4781,7 +4781,7 @@ embed_idle_cb (EV_P_ ev_idle *idle, int revents) #endif void -ev_embed_start (EV_P_ ev_embed *w) EV_THROW +ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4812,7 +4812,7 @@ ev_embed_start (EV_P_ ev_embed *w) EV_THROW } void -ev_embed_stop (EV_P_ ev_embed *w) EV_THROW +ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4832,7 +4832,7 @@ ev_embed_stop (EV_P_ ev_embed *w) EV_THROW #if EV_FORK_ENABLE void -ev_fork_start (EV_P_ ev_fork *w) EV_THROW +ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4847,7 +4847,7 @@ ev_fork_start (EV_P_ ev_fork *w) EV_THROW } void -ev_fork_stop (EV_P_ ev_fork *w) EV_THROW +ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4870,7 +4870,7 @@ ev_fork_stop (EV_P_ ev_fork *w) EV_THROW #if EV_CLEANUP_ENABLE void -ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW +ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4887,7 +4887,7 @@ ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW } void -ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW +ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4911,7 +4911,7 @@ ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW #if EV_ASYNC_ENABLE void -ev_async_start (EV_P_ ev_async *w) EV_THROW +ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT { if (expect_false (ev_is_active (w))) return; @@ -4930,7 +4930,7 @@ ev_async_start (EV_P_ ev_async *w) EV_THROW } void -ev_async_stop (EV_P_ ev_async *w) EV_THROW +ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT { clear_pending (EV_A_ (W)w); if (expect_false (!ev_is_active (w))) @@ -4951,7 +4951,7 @@ ev_async_stop (EV_P_ ev_async *w) EV_THROW } void -ev_async_send (EV_P_ ev_async *w) EV_THROW +ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT { w->sent = 1; evpipe_write (EV_A_ &async_pending); @@ -4998,7 +4998,7 @@ once_cb_to (EV_P_ ev_timer *w, int revents) } void -ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW +ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT { struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once)); @@ -5031,7 +5031,7 @@ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, vo #if EV_WALK_ENABLE ecb_cold void -ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW +ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT { int i, j; ev_watcher_list *wl, *wn; diff --git a/ev.h b/ev.h index db93777..307d66f 100644 --- a/ev.h +++ b/ev.h @@ -43,13 +43,13 @@ #ifdef __cplusplus # define EV_CPP(x) x # if __cplusplus >= 201103L -# define EV_THROW noexcept +# define EV_NOEXCEPT noexcept # else -# define EV_THROW throw () +# define EV_NOEXCEPT # endif #else # define EV_CPP(x) -# define EV_THROW +# define EV_NOEXCEPT #endif EV_CPP(extern "C" {) @@ -339,7 +339,7 @@ typedef struct ev_periodic ev_tstamp offset; /* rw */ ev_tstamp interval; /* rw */ - ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) EV_THROW; /* rw */ + ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) EV_NOEXCEPT; /* rw */ } ev_periodic; /* invoked when the given signal has been received */ @@ -526,15 +526,15 @@ enum { }; #if EV_PROTOTYPES -EV_API_DECL int ev_version_major (void) EV_THROW; -EV_API_DECL int ev_version_minor (void) EV_THROW; +EV_API_DECL int ev_version_major (void) EV_NOEXCEPT; +EV_API_DECL int ev_version_minor (void) EV_NOEXCEPT; -EV_API_DECL unsigned int ev_supported_backends (void) EV_THROW; -EV_API_DECL unsigned int ev_recommended_backends (void) EV_THROW; -EV_API_DECL unsigned int ev_embeddable_backends (void) EV_THROW; +EV_API_DECL unsigned int ev_supported_backends (void) EV_NOEXCEPT; +EV_API_DECL unsigned int ev_recommended_backends (void) EV_NOEXCEPT; +EV_API_DECL unsigned int ev_embeddable_backends (void) EV_NOEXCEPT; -EV_API_DECL ev_tstamp ev_time (void) EV_THROW; -EV_API_DECL void ev_sleep (ev_tstamp delay) EV_THROW; /* sleep for a while */ +EV_API_DECL ev_tstamp ev_time (void) EV_NOEXCEPT; +EV_API_DECL void ev_sleep (ev_tstamp delay) EV_NOEXCEPT; /* sleep for a while */ /* Sets the allocation function to use, works like realloc. * It is used to allocate and free memory. @@ -542,26 +542,26 @@ EV_API_DECL void ev_sleep (ev_tstamp delay) EV_THROW; /* sleep for a while */ * or take some potentially destructive action. * The default is your system realloc function. */ -EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW; +EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT; /* set the callback function to call on a * retryable syscall error * (such as failed select, poll, epoll_wait) */ -EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW; +EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT; #if EV_MULTIPLICITY /* the default loop is the only one that handles signals and child watchers */ /* you can call this as often as you like */ -EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW; +EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT; #ifdef EV_API_STATIC EV_API_DECL struct ev_loop *ev_default_loop_ptr; #endif EV_INLINE struct ev_loop * -ev_default_loop_uc_ (void) EV_THROW +ev_default_loop_uc_ (void) EV_NOEXCEPT { extern struct ev_loop *ev_default_loop_ptr; @@ -569,31 +569,31 @@ ev_default_loop_uc_ (void) EV_THROW } EV_INLINE int -ev_is_default_loop (EV_P) EV_THROW +ev_is_default_loop (EV_P) EV_NOEXCEPT { return EV_A == EV_DEFAULT_UC; } /* create and destroy alternative loops that don't handle signals */ -EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_THROW; +EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT; -EV_API_DECL ev_tstamp ev_now (EV_P) EV_THROW; /* time w.r.t. timers and the eventloop, updated after each poll */ +EV_API_DECL ev_tstamp ev_now (EV_P) EV_NOEXCEPT; /* time w.r.t. timers and the eventloop, updated after each poll */ #else -EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW; /* returns true when successful */ +EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT; /* returns true when successful */ EV_API_DECL ev_tstamp ev_rt_now; EV_INLINE ev_tstamp -ev_now (void) EV_THROW +ev_now (void) EV_NOEXCEPT { return ev_rt_now; } /* looks weird, but ev_is_default_loop (EV_A) still works if this exists */ EV_INLINE int -ev_is_default_loop (void) EV_THROW +ev_is_default_loop (void) EV_NOEXCEPT { return 1; } @@ -607,17 +607,17 @@ EV_API_DECL void ev_loop_destroy (EV_P); /* when you want to re-use it in the child */ /* you can call it in either the parent or the child */ /* you can actually call it at any time, anywhere :) */ -EV_API_DECL void ev_loop_fork (EV_P) EV_THROW; +EV_API_DECL void ev_loop_fork (EV_P) EV_NOEXCEPT; -EV_API_DECL unsigned int ev_backend (EV_P) EV_THROW; /* backend in use by loop */ +EV_API_DECL unsigned int ev_backend (EV_P) EV_NOEXCEPT; /* backend in use by loop */ -EV_API_DECL void ev_now_update (EV_P) EV_THROW; /* update event loop time */ +EV_API_DECL void ev_now_update (EV_P) EV_NOEXCEPT; /* update event loop time */ #if EV_WALK_ENABLE /* walk (almost) all watchers in the loop of a given type, invoking the */ /* callback on every such watcher. The callback might stop the watcher, */ /* but do nothing else with the loop */ -EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW; +EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT; #endif #endif /* prototypes */ @@ -637,46 +637,46 @@ enum { #if EV_PROTOTYPES EV_API_DECL int ev_run (EV_P_ int flags EV_CPP (= 0)); -EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_THROW; /* break out of the loop */ +EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_NOEXCEPT; /* break out of the loop */ /* * ref/unref can be used to add or remove a refcount on the mainloop. every watcher * keeps one reference. if you have a long-running watcher you never unregister that * should not keep ev_loop from running, unref() after starting, and ref() before stopping. */ -EV_API_DECL void ev_ref (EV_P) EV_THROW; -EV_API_DECL void ev_unref (EV_P) EV_THROW; +EV_API_DECL void ev_ref (EV_P) EV_NOEXCEPT; +EV_API_DECL void ev_unref (EV_P) EV_NOEXCEPT; /* * convenience function, wait for a single event, without registering an event watcher * if timeout is < 0, do wait indefinitely */ -EV_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW; +EV_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT; # if EV_FEATURE_API -EV_API_DECL unsigned int ev_iteration (EV_P) EV_THROW; /* number of loop iterations */ -EV_API_DECL unsigned int ev_depth (EV_P) EV_THROW; /* #ev_loop enters - #ev_loop leaves */ -EV_API_DECL void ev_verify (EV_P) EV_THROW; /* abort if loop data corrupted */ +EV_API_DECL unsigned int ev_iteration (EV_P) EV_NOEXCEPT; /* number of loop iterations */ +EV_API_DECL unsigned int ev_depth (EV_P) EV_NOEXCEPT; /* #ev_loop enters - #ev_loop leaves */ +EV_API_DECL void ev_verify (EV_P) EV_NOEXCEPT; /* abort if loop data corrupted */ -EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW; /* sleep at least this time, default 0 */ -EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW; /* sleep at least this time, default 0 */ +EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */ +EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */ /* advanced stuff for threading etc. support, see docs */ -EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_THROW; -EV_API_DECL void *ev_userdata (EV_P) EV_THROW; +EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT; +EV_API_DECL void *ev_userdata (EV_P) EV_NOEXCEPT; typedef void (*ev_loop_callback)(EV_P); -EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW; +EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT; /* C++ doesn't allow the use of the ev_loop_callback typedef here, so we need to spell it out */ -EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW; +EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT; -EV_API_DECL unsigned int ev_pending_count (EV_P) EV_THROW; /* number of pending events, if any */ +EV_API_DECL unsigned int ev_pending_count (EV_P) EV_NOEXCEPT; /* number of pending events, if any */ EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */ /* * stop/start the timer handling. */ -EV_API_DECL void ev_suspend (EV_P) EV_THROW; -EV_API_DECL void ev_resume (EV_P) EV_THROW; +EV_API_DECL void ev_suspend (EV_P) EV_NOEXCEPT; +EV_API_DECL void ev_resume (EV_P) EV_NOEXCEPT; #endif #endif @@ -744,85 +744,85 @@ EV_API_DECL void ev_resume (EV_P) EV_THROW; /* feeds an event into a watcher as if the event actually occurred */ /* accepts any ev_watcher type */ -EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents) EV_THROW; -EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW; +EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT; +EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT; #if EV_SIGNAL_ENABLE -EV_API_DECL void ev_feed_signal (int signum) EV_THROW; -EV_API_DECL void ev_feed_signal_event (EV_P_ int signum) EV_THROW; +EV_API_DECL void ev_feed_signal (int signum) EV_NOEXCEPT; +EV_API_DECL void ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT; #endif EV_API_DECL void ev_invoke (EV_P_ void *w, int revents); -EV_API_DECL int ev_clear_pending (EV_P_ void *w) EV_THROW; +EV_API_DECL int ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT; -EV_API_DECL void ev_io_start (EV_P_ ev_io *w) EV_THROW; -EV_API_DECL void ev_io_stop (EV_P_ ev_io *w) EV_THROW; +EV_API_DECL void ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT; +EV_API_DECL void ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT; -EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w) EV_THROW; -EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w) EV_THROW; +EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT; +EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT; /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */ -EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_THROW; +EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT; /* return remaining time */ -EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW; +EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT; #if EV_PERIODIC_ENABLE -EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW; -EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW; -EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW; +EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT; +EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT; +EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT; #endif /* only supported in the default loop */ #if EV_SIGNAL_ENABLE -EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w) EV_THROW; -EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w) EV_THROW; +EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT; +EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT; #endif /* only supported in the default loop */ # if EV_CHILD_ENABLE -EV_API_DECL void ev_child_start (EV_P_ ev_child *w) EV_THROW; -EV_API_DECL void ev_child_stop (EV_P_ ev_child *w) EV_THROW; +EV_API_DECL void ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT; +EV_API_DECL void ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT; # endif # if EV_STAT_ENABLE -EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w) EV_THROW; -EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w) EV_THROW; -EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w) EV_THROW; +EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT; +EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT; +EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT; # endif # if EV_IDLE_ENABLE -EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w) EV_THROW; -EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w) EV_THROW; +EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT; +EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT; # endif #if EV_PREPARE_ENABLE -EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW; -EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW; +EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT; +EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT; #endif #if EV_CHECK_ENABLE -EV_API_DECL void ev_check_start (EV_P_ ev_check *w) EV_THROW; -EV_API_DECL void ev_check_stop (EV_P_ ev_check *w) EV_THROW; +EV_API_DECL void ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT; +EV_API_DECL void ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT; #endif # if EV_FORK_ENABLE -EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w) EV_THROW; -EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w) EV_THROW; +EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT; +EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT; # endif # if EV_CLEANUP_ENABLE -EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW; -EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW; +EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT; +EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT; # endif # if EV_EMBED_ENABLE /* only supported when loop to be embedded is in fact embeddable */ -EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w) EV_THROW; -EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w) EV_THROW; -EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW; +EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT; +EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT; +EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT; # endif # if EV_ASYNC_ENABLE -EV_API_DECL void ev_async_start (EV_P_ ev_async *w) EV_THROW; -EV_API_DECL void ev_async_stop (EV_P_ ev_async *w) EV_THROW; -EV_API_DECL void ev_async_send (EV_P_ ev_async *w) EV_THROW; +EV_API_DECL void ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT; +EV_API_DECL void ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT; +EV_API_DECL void ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT; # endif #if EV_COMPAT3 diff --git a/ev_vars.h b/ev_vars.h index 04d4db1..30e9e28 100644 --- a/ev_vars.h +++ b/ev_vars.h @@ -195,8 +195,8 @@ VARx(unsigned int, loop_depth) /* #ev_run enters - #ev_run leaves */ VARx(void *, userdata) /* C++ doesn't support the ev_loop_callback typedef here. stinks. */ -VAR (release_cb, void (*release_cb)(EV_P) EV_THROW) -VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_THROW) +VAR (release_cb, void (*release_cb)(EV_P) EV_NOEXCEPT) +VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_NOEXCEPT) VAR (invoke_cb , ev_loop_callback invoke_cb) #endif