Browse Source

preliminary throw() support

master
Marc Alexander Lehmann 10 years ago
parent
commit
f6e05d6d88
  1. 1
      Changes
  2. 146
      ev.c
  3. 152
      ev.h

1
Changes

@ -6,6 +6,7 @@ TODO: EV_STANDALONE == NO_HASSEL (do not use clock_gettime in ev_standalone)
TODO: document WSA_EV_USE_SOCKET in win32 part
TODO: ^ OR use WSASend/WSARecv on the handle, which always works
TODO: throw() for most ev.h functions
TODO: assert on fd watcher linked list pointint to itself
- fix event_base_loop return code, add event_get_callback, event_base_new,
event_base_get_method calls to improve libevent 1.x emulation and add
some libevent 2.x funcitonality (based on a patch by Jeff Davey).

146
ev.c

@ -1107,10 +1107,10 @@ ev_printerr (const char *msg)
}
#endif
static void (*syserr_cb)(const char *msg);
static void (*syserr_cb)(const char *msg) EV_THROW;
void ecb_cold
ev_set_syserr_cb (void (*cb)(const char *msg))
ev_set_syserr_cb (void (*cb)(const char *msg)) EV_THROW
{
syserr_cb = cb;
}
@ -1156,10 +1156,10 @@ ev_realloc_emul (void *ptr, long size)
#endif
}
static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
void ecb_cold
ev_set_allocator (void *(*cb)(void *ptr, long size))
ev_set_allocator (void *(*cb)(void *ptr, long size)) EV_THROW
{
alloc = cb;
}
@ -1286,7 +1286,7 @@ typedef struct
#ifndef EV_HAVE_EV_TIME
ev_tstamp
ev_time (void)
ev_time (void) EV_THROW
{
#if EV_USE_REALTIME
if (expect_true (have_realtime))
@ -1320,14 +1320,14 @@ get_clock (void)
#if EV_MULTIPLICITY
ev_tstamp
ev_now (EV_P)
ev_now (EV_P) EV_THROW
{
return ev_rt_now;
}
#endif
void
ev_sleep (ev_tstamp delay)
ev_sleep (ev_tstamp delay) EV_THROW
{
if (delay > 0.)
{
@ -1418,7 +1418,7 @@ pendingcb (EV_P_ ev_prepare *w, int revents)
}
void noinline
ev_feed_event (EV_P_ void *w, int revents)
ev_feed_event (EV_P_ void *w, int revents) EV_THROW
{
W w_ = (W)w;
int pri = ABSPRI (w_);
@ -1487,7 +1487,7 @@ fd_event (EV_P_ int fd, int revents)
}
void
ev_feed_fd_event (EV_P_ int fd, int revents)
ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
{
if (fd >= 0 && fd < anfdmax)
fd_event_nocheck (EV_A_ fd, revents);
@ -1943,7 +1943,7 @@ pipecb (EV_P_ ev_io *iow, int revents)
/*****************************************************************************/
void
ev_feed_signal (int signum)
ev_feed_signal (int signum) EV_THROW
{
#if EV_MULTIPLICITY
EV_P = signals [signum - 1].loop;
@ -1970,7 +1970,7 @@ ev_sighandler (int signum)
}
void noinline
ev_feed_signal_event (EV_P_ int signum)
ev_feed_signal_event (EV_P_ int signum) EV_THROW
{
WL w;
@ -2096,13 +2096,13 @@ childcb (EV_P_ ev_signal *sw, int revents)
#endif
int ecb_cold
ev_version_major (void)
ev_version_major (void) EV_THROW
{
return EV_VERSION_MAJOR;
}
int ecb_cold
ev_version_minor (void)
ev_version_minor (void) EV_THROW
{
return EV_VERSION_MINOR;
}
@ -2120,7 +2120,7 @@ enable_secure (void)
}
unsigned int ecb_cold
ev_supported_backends (void)
ev_supported_backends (void) EV_THROW
{
unsigned int flags = 0;
@ -2134,7 +2134,7 @@ ev_supported_backends (void)
}
unsigned int ecb_cold
ev_recommended_backends (void)
ev_recommended_backends (void) EV_THROW
{
unsigned int flags = ev_supported_backends ();
@ -2156,7 +2156,7 @@ ev_recommended_backends (void)
}
unsigned int ecb_cold
ev_embeddable_backends (void)
ev_embeddable_backends (void) EV_THROW
{
int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
@ -2168,56 +2168,56 @@ ev_embeddable_backends (void)
}
unsigned int
ev_backend (EV_P)
ev_backend (EV_P) EV_THROW
{
return backend;
}
#if EV_FEATURE_API
unsigned int
ev_iteration (EV_P)
ev_iteration (EV_P) EV_THROW
{
return loop_count;
}
unsigned int
ev_depth (EV_P)
ev_depth (EV_P) EV_THROW
{
return loop_depth;
}
void
ev_set_io_collect_interval (EV_P_ ev_tstamp interval)
ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
{
io_blocktime = interval;
}
void
ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)
ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
{
timeout_blocktime = interval;
}
void
ev_set_userdata (EV_P_ void *data)
ev_set_userdata (EV_P_ void *data) EV_THROW
{
userdata = data;
}
void *
ev_userdata (EV_P)
ev_userdata (EV_P) EV_THROW
{
return userdata;
}
void
ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P))
ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
{
invoke_cb = invoke_pending_cb;
}
void
ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P))
ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) EV_THROW
{
release_cb = release;
acquire_cb = acquire;
@ -2226,7 +2226,7 @@ ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P))
/* initialise a loop structure, must be zero-initialised */
static void noinline ecb_cold
loop_init (EV_P_ unsigned int flags)
loop_init (EV_P_ unsigned int flags) EV_THROW
{
if (!backend)
{
@ -2321,7 +2321,7 @@ loop_init (EV_P_ unsigned int flags)
/* free up a loop structure */
void ecb_cold
ev_loop_destroy (EV_P)
ev_loop_destroy (EV_P) EV_THROW
{
int i;
@ -2489,7 +2489,7 @@ loop_fork (EV_P)
#if EV_MULTIPLICITY
struct ev_loop * ecb_cold
ev_loop_new (unsigned int flags)
ev_loop_new (unsigned int flags) EV_THROW
{
EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
@ -2543,7 +2543,7 @@ array_verify (EV_P_ W *ws, int cnt)
#if EV_FEATURE_API
void ecb_cold
ev_verify (EV_P)
ev_verify (EV_P) EV_THROW
{
#if EV_VERIFY
int i;
@ -2622,7 +2622,7 @@ struct ev_loop * ecb_cold
#else
int
#endif
ev_default_loop (unsigned int flags)
ev_default_loop (unsigned int flags) EV_THROW
{
if (!ev_default_loop_ptr)
{
@ -2651,7 +2651,7 @@ ev_default_loop (unsigned int flags)
}
void
ev_loop_fork (EV_P)
ev_loop_fork (EV_P) EV_THROW
{
postfork = 1; /* must be in line with ev_default_fork */
}
@ -2665,7 +2665,7 @@ ev_invoke (EV_P_ void *w, int revents)
}
unsigned int
ev_pending_count (EV_P)
ev_pending_count (EV_P) EV_THROW
{
int pri;
unsigned int count = 0;
@ -3106,37 +3106,37 @@ ev_run (EV_P_ int flags)
}
void
ev_break (EV_P_ int how)
ev_break (EV_P_ int how) EV_THROW
{
loop_done = how;
}
void
ev_ref (EV_P)
ev_ref (EV_P) EV_THROW
{
++activecnt;
}
void
ev_unref (EV_P)
ev_unref (EV_P) EV_THROW
{
--activecnt;
}
void
ev_now_update (EV_P)
ev_now_update (EV_P) EV_THROW
{
time_update (EV_A_ 1e100);
}
void
ev_suspend (EV_P)
ev_suspend (EV_P) EV_THROW
{
ev_now_update (EV_A);
}
void
ev_resume (EV_P)
ev_resume (EV_P) EV_THROW
{
ev_tstamp mn_prev = mn_now;
@ -3185,7 +3185,7 @@ clear_pending (EV_P_ W w)
}
int
ev_clear_pending (EV_P_ void *w)
ev_clear_pending (EV_P_ void *w) EV_THROW
{
W w_ = (W)w;
int pending = w_->pending;
@ -3228,7 +3228,7 @@ ev_stop (EV_P_ W w)
/*****************************************************************************/
void noinline
ev_io_start (EV_P_ ev_io *w)
ev_io_start (EV_P_ ev_io *w) EV_THROW
{
int fd = w->fd;
@ -3251,7 +3251,7 @@ ev_io_start (EV_P_ ev_io *w)
}
void noinline
ev_io_stop (EV_P_ ev_io *w)
ev_io_stop (EV_P_ ev_io *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3270,7 +3270,7 @@ ev_io_stop (EV_P_ ev_io *w)
}
void noinline
ev_timer_start (EV_P_ ev_timer *w)
ev_timer_start (EV_P_ ev_timer *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -3294,7 +3294,7 @@ ev_timer_start (EV_P_ ev_timer *w)
}
void noinline
ev_timer_stop (EV_P_ ev_timer *w)
ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3324,7 +3324,7 @@ ev_timer_stop (EV_P_ ev_timer *w)
}
void noinline
ev_timer_again (EV_P_ ev_timer *w)
ev_timer_again (EV_P_ ev_timer *w) EV_THROW
{
EV_FREQUENT_CHECK;
@ -3351,14 +3351,14 @@ ev_timer_again (EV_P_ ev_timer *w)
}
ev_tstamp
ev_timer_remaining (EV_P_ ev_timer *w)
ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
{
return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
}
#if EV_PERIODIC_ENABLE
void noinline
ev_periodic_start (EV_P_ ev_periodic *w)
ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -3388,7 +3388,7 @@ ev_periodic_start (EV_P_ ev_periodic *w)
}
void noinline
ev_periodic_stop (EV_P_ ev_periodic *w)
ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3416,7 +3416,7 @@ ev_periodic_stop (EV_P_ ev_periodic *w)
}
void noinline
ev_periodic_again (EV_P_ ev_periodic *w)
ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
{
/* TODO: use adjustheap and recalculation */
ev_periodic_stop (EV_A_ w);
@ -3431,7 +3431,7 @@ ev_periodic_again (EV_P_ ev_periodic *w)
#if EV_SIGNAL_ENABLE
void noinline
ev_signal_start (EV_P_ ev_signal *w)
ev_signal_start (EV_P_ ev_signal *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -3512,7 +3512,7 @@ ev_signal_start (EV_P_ ev_signal *w)
}
void noinline
ev_signal_stop (EV_P_ ev_signal *w)
ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3553,7 +3553,7 @@ ev_signal_stop (EV_P_ ev_signal *w)
#if EV_CHILD_ENABLE
void
ev_child_start (EV_P_ ev_child *w)
ev_child_start (EV_P_ ev_child *w) EV_THROW
{
#if EV_MULTIPLICITY
assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
@ -3570,7 +3570,7 @@ ev_child_start (EV_P_ ev_child *w)
}
void
ev_child_stop (EV_P_ ev_child *w)
ev_child_stop (EV_P_ ev_child *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3832,7 +3832,7 @@ infy_fork (EV_P)
#endif
void
ev_stat_stat (EV_P_ ev_stat *w)
ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
{
if (lstat (w->path, &w->attr) < 0)
w->attr.st_nlink = 0;
@ -3881,7 +3881,7 @@ stat_timer_cb (EV_P_ ev_timer *w_, int revents)
}
void
ev_stat_start (EV_P_ ev_stat *w)
ev_stat_start (EV_P_ ev_stat *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -3912,7 +3912,7 @@ ev_stat_start (EV_P_ ev_stat *w)
}
void
ev_stat_stop (EV_P_ ev_stat *w)
ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3938,7 +3938,7 @@ ev_stat_stop (EV_P_ ev_stat *w)
#if EV_IDLE_ENABLE
void
ev_idle_start (EV_P_ ev_idle *w)
ev_idle_start (EV_P_ ev_idle *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -3961,7 +3961,7 @@ ev_idle_start (EV_P_ ev_idle *w)
}
void
ev_idle_stop (EV_P_ ev_idle *w)
ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -3985,7 +3985,7 @@ ev_idle_stop (EV_P_ ev_idle *w)
#if EV_PREPARE_ENABLE
void
ev_prepare_start (EV_P_ ev_prepare *w)
ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4000,7 +4000,7 @@ ev_prepare_start (EV_P_ ev_prepare *w)
}
void
ev_prepare_stop (EV_P_ ev_prepare *w)
ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4023,7 +4023,7 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
#if EV_CHECK_ENABLE
void
ev_check_start (EV_P_ ev_check *w)
ev_check_start (EV_P_ ev_check *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4038,7 +4038,7 @@ ev_check_start (EV_P_ ev_check *w)
}
void
ev_check_stop (EV_P_ ev_check *w)
ev_check_stop (EV_P_ ev_check *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4061,7 +4061,7 @@ ev_check_stop (EV_P_ ev_check *w)
#if EV_EMBED_ENABLE
void noinline
ev_embed_sweep (EV_P_ ev_embed *w)
ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
{
ev_run (w->other, EVRUN_NOWAIT);
}
@ -4119,7 +4119,7 @@ embed_idle_cb (EV_P_ ev_idle *idle, int revents)
#endif
void
ev_embed_start (EV_P_ ev_embed *w)
ev_embed_start (EV_P_ ev_embed *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4150,7 +4150,7 @@ ev_embed_start (EV_P_ ev_embed *w)
}
void
ev_embed_stop (EV_P_ ev_embed *w)
ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4170,7 +4170,7 @@ ev_embed_stop (EV_P_ ev_embed *w)
#if EV_FORK_ENABLE
void
ev_fork_start (EV_P_ ev_fork *w)
ev_fork_start (EV_P_ ev_fork *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4185,7 +4185,7 @@ ev_fork_start (EV_P_ ev_fork *w)
}
void
ev_fork_stop (EV_P_ ev_fork *w)
ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4208,7 +4208,7 @@ ev_fork_stop (EV_P_ ev_fork *w)
#if EV_CLEANUP_ENABLE
void
ev_cleanup_start (EV_P_ ev_cleanup *w)
ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4225,7 +4225,7 @@ ev_cleanup_start (EV_P_ ev_cleanup *w)
}
void
ev_cleanup_stop (EV_P_ ev_cleanup *w)
ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4249,7 +4249,7 @@ ev_cleanup_stop (EV_P_ ev_cleanup *w)
#if EV_ASYNC_ENABLE
void
ev_async_start (EV_P_ ev_async *w)
ev_async_start (EV_P_ ev_async *w) EV_THROW
{
if (expect_false (ev_is_active (w)))
return;
@ -4268,7 +4268,7 @@ ev_async_start (EV_P_ ev_async *w)
}
void
ev_async_stop (EV_P_ ev_async *w)
ev_async_stop (EV_P_ ev_async *w) EV_THROW
{
clear_pending (EV_A_ (W)w);
if (expect_false (!ev_is_active (w)))
@ -4289,7 +4289,7 @@ ev_async_stop (EV_P_ ev_async *w)
}
void
ev_async_send (EV_P_ ev_async *w)
ev_async_send (EV_P_ ev_async *w) EV_THROW
{
w->sent = 1;
evpipe_write (EV_A_ &async_pending);
@ -4336,7 +4336,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_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
{
struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
@ -4368,7 +4368,7 @@ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, vo
#if EV_WALK_ENABLE
void ecb_cold
ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w))
ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
{
int i, j;
ev_watcher_list *wl, *wn;

152
ev.h

@ -46,6 +46,8 @@
# define EV_CPP(x)
#endif
#define EV_THROW EV_CPP(throw())
EV_CPP(extern "C" {)
/*****************************************************************************/
@ -518,15 +520,15 @@ enum {
};
#if EV_PROTOTYPES
EV_API_DECL int ev_version_major (void);
EV_API_DECL int ev_version_minor (void);
EV_API_DECL int ev_version_major (void) EV_THROW;
EV_API_DECL int ev_version_minor (void) EV_THROW;
EV_API_DECL unsigned int ev_supported_backends (void);
EV_API_DECL unsigned int ev_recommended_backends (void);
EV_API_DECL unsigned int ev_embeddable_backends (void);
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 ev_tstamp ev_time (void);
EV_API_DECL void ev_sleep (ev_tstamp delay); /* sleep for a while */
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 */
/* Sets the allocation function to use, works like realloc.
* It is used to allocate and free memory.
@ -534,26 +536,26 @@ EV_API_DECL void ev_sleep (ev_tstamp delay); /* 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_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW;
/* 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_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW;
#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_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW;
#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_default_loop_uc_ (void) EV_THROW
{
extern struct ev_loop *ev_default_loop_ptr;
@ -561,31 +563,31 @@ ev_default_loop_uc_ (void)
}
EV_INLINE int
ev_is_default_loop (EV_P)
ev_is_default_loop (EV_P) EV_THROW
{
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_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_THROW;
EV_API_DECL ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
EV_API_DECL ev_tstamp ev_now (EV_P) EV_THROW; /* 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)); /* returns true when successful */
EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW; /* returns true when successful */
EV_API_DECL ev_tstamp ev_rt_now;
EV_INLINE ev_tstamp
ev_now (void)
ev_now (void) EV_THROW
{
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_is_default_loop (void) EV_THROW
{
return 1;
}
@ -593,23 +595,23 @@ ev_is_default_loop (void)
#endif /* multiplicity */
/* destroy event loops, also works for the default loop */
EV_API_DECL void ev_loop_destroy (EV_P);
EV_API_DECL void ev_loop_destroy (EV_P) EV_THROW;
/* this needs to be called after fork, to duplicate the loop */
/* 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_API_DECL void ev_loop_fork (EV_P) EV_THROW;
EV_API_DECL unsigned int ev_backend (EV_P); /* backend in use by loop */
EV_API_DECL unsigned int ev_backend (EV_P) EV_THROW; /* backend in use by loop */
EV_API_DECL void ev_now_update (EV_P); /* update event loop time */
EV_API_DECL void ev_now_update (EV_P) EV_THROW; /* 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_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW;
#endif
#endif /* prototypes */
@ -629,44 +631,44 @@ 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)); /* break out of the loop */
EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_THROW; /* 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_API_DECL void ev_unref (EV_P);
EV_API_DECL void ev_ref (EV_P) EV_THROW;
EV_API_DECL void ev_unref (EV_P) EV_THROW;
/*
* 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_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW;
# if EV_FEATURE_API
EV_API_DECL unsigned int ev_iteration (EV_P); /* number of loop iterations */
EV_API_DECL unsigned int ev_depth (EV_P); /* #ev_loop enters - #ev_loop leaves */
EV_API_DECL void ev_verify (EV_P); /* abort if loop data corrupted */
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 void ev_set_io_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
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 */
/* advanced stuff for threading etc. support, see docs */
EV_API_DECL void ev_set_userdata (EV_P_ void *data);
EV_API_DECL void *ev_userdata (EV_P);
EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P));
EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P));
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_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW;
EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) EV_THROW;
EV_API_DECL unsigned int ev_pending_count (EV_P); /* number of pending events, if any */
EV_API_DECL unsigned int ev_pending_count (EV_P) EV_THROW; /* 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_API_DECL void ev_resume (EV_P);
EV_API_DECL void ev_suspend (EV_P) EV_THROW;
EV_API_DECL void ev_resume (EV_P) EV_THROW;
#endif
#endif
@ -733,85 +735,85 @@ EV_API_DECL void ev_resume (EV_P);
/* 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_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents);
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;
#if EV_SIGNAL_ENABLE
EV_API_DECL void ev_feed_signal (int signum);
EV_API_DECL void ev_feed_signal_event (EV_P_ int signum);
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;
#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_API_DECL int ev_clear_pending (EV_P_ void *w) EV_THROW;
EV_API_DECL void ev_io_start (EV_P_ ev_io *w);
EV_API_DECL void ev_io_stop (EV_P_ ev_io *w);
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_timer_start (EV_P_ ev_timer *w);
EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w);
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;
/* 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_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_THROW;
/* return remaining time */
EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w);
EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW;
#if EV_PERIODIC_ENABLE
EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w);
EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w);
EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w);
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;
#endif
/* only supported in the default loop */
#if EV_SIGNAL_ENABLE
EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w);
EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w);
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;
#endif
/* only supported in the default loop */
# if EV_CHILD_ENABLE
EV_API_DECL void ev_child_start (EV_P_ ev_child *w);
EV_API_DECL void ev_child_stop (EV_P_ ev_child *w);
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;
# endif
# if EV_STAT_ENABLE
EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w);
EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w);
EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w);
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;
# endif
# if EV_IDLE_ENABLE
EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w);
EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w);
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;
# endif
#if EV_PREPARE_ENABLE
EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w);
EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w);
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;
#endif
#if EV_CHECK_ENABLE
EV_API_DECL void ev_check_start (EV_P_ ev_check *w);
EV_API_DECL void ev_check_stop (EV_P_ ev_check *w);
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;
#endif
# if EV_FORK_ENABLE
EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w);
EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w);
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;
# endif
# if EV_CLEANUP_ENABLE
EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w);
EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w);
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;
# 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_API_DECL void ev_embed_stop (EV_P_ ev_embed *w);
EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w);
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;
# endif
# if EV_ASYNC_ENABLE
EV_API_DECL void ev_async_start (EV_P_ ev_async *w);
EV_API_DECL void ev_async_stop (EV_P_ ev_async *w);
EV_API_DECL void ev_async_send (EV_P_ ev_async *w);
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;
# endif
#if EV_COMPAT3

Loading…
Cancel
Save