Mirror of :pserver:anonymous@cvs.schmorp.de/schmorpforge libev http://software.schmorp.de/pkg/libev.html
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

700 lines
22 KiB

14 years ago
13 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
12 years ago
14 years ago
14 years ago
13 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
12 years ago
12 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
  1. /*
  2. * libev native API header
  3. *
  4. * Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libev@schmorp.de>
  5. * All rights reserved.
  6. *
  7. * Redistribution and use in source and binary forms, with or without modifica-
  8. * tion, are permitted provided that the following conditions are met:
  9. *
  10. * 1. Redistributions of source code must retain the above copyright notice,
  11. * this list of conditions and the following disclaimer.
  12. *
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. * notice, this list of conditions and the following disclaimer in the
  15. * documentation and/or other materials provided with the distribution.
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
  19. * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  20. * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
  21. * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22. * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23. * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24. * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
  25. * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  26. * OF THE POSSIBILITY OF SUCH DAMAGE.
  27. *
  28. * Alternatively, the contents of this file may be used under the terms of
  29. * the GNU General Public License ("GPL") version 2 or any later version,
  30. * in which case the provisions of the GPL are applicable instead of
  31. * the above. If you wish to allow the use of your version of this file
  32. * only under the terms of the GPL and not to allow others to use your
  33. * version of this file under the BSD license, indicate your decision
  34. * by deleting the provisions above and replace them with the notice
  35. * and other provisions required by the GPL. If you do not delete the
  36. * provisions above, a recipient may use your version of this file under
  37. * either the BSD or the GPL.
  38. */
  39. #ifndef EV_H__
  40. #define EV_H__
  41. #ifdef __cplusplus
  42. extern "C" {
  43. #endif
  44. typedef double ev_tstamp;
  45. /* these priorities are inclusive, higher priorities will be called earlier */
  46. #ifndef EV_MINPRI
  47. # define EV_MINPRI -2
  48. #endif
  49. #ifndef EV_MAXPRI
  50. # define EV_MAXPRI +2
  51. #endif
  52. #ifndef EV_MULTIPLICITY
  53. # define EV_MULTIPLICITY 1
  54. #endif
  55. #ifndef EV_PERIODIC_ENABLE
  56. # define EV_PERIODIC_ENABLE 1
  57. #endif
  58. #ifndef EV_STAT_ENABLE
  59. # define EV_STAT_ENABLE 1
  60. #endif
  61. #ifndef EV_IDLE_ENABLE
  62. # define EV_IDLE_ENABLE 1
  63. #endif
  64. #ifndef EV_FORK_ENABLE
  65. # define EV_FORK_ENABLE 1
  66. #endif
  67. #ifndef EV_EMBED_ENABLE
  68. # define EV_EMBED_ENABLE 1
  69. #endif
  70. #ifndef EV_ASYNC_ENABLE
  71. # define EV_ASYNC_ENABLE 1
  72. #endif
  73. #ifndef EV_WALK_ENABLE
  74. # define EV_WALK_ENABLE 0 /* not yet */
  75. #endif
  76. #ifndef EV_ATOMIC_T
  77. # include <signal.h>
  78. # define EV_ATOMIC_T sig_atomic_t volatile
  79. #endif
  80. /*****************************************************************************/
  81. #if EV_STAT_ENABLE
  82. # ifdef _WIN32
  83. # include <time.h>
  84. # include <sys/types.h>
  85. # endif
  86. # include <sys/stat.h>
  87. #endif
  88. /* support multiple event loops? */
  89. #if EV_MULTIPLICITY
  90. struct ev_loop;
  91. # define EV_P struct ev_loop *loop
  92. # define EV_P_ EV_P,
  93. # define EV_A loop
  94. # define EV_A_ EV_A,
  95. # define EV_DEFAULT_UC ev_default_loop_uc ()
  96. # define EV_DEFAULT_UC_ EV_DEFAULT_UC,
  97. # define EV_DEFAULT ev_default_loop (0)
  98. # define EV_DEFAULT_ EV_DEFAULT,
  99. #else
  100. # define EV_P void
  101. # define EV_P_
  102. # define EV_A
  103. # define EV_A_
  104. # define EV_DEFAULT
  105. # define EV_DEFAULT_
  106. # define EV_DEFAULT_UC
  107. # define EV_DEFAULT_UC_
  108. # undef EV_EMBED_ENABLE
  109. #endif
  110. #if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3
  111. # define EV_INLINE static inline
  112. #else
  113. # define EV_INLINE static
  114. #endif
  115. /*****************************************************************************/
  116. /* eventmask, revents, events... */
  117. #define EV_UNDEF -1 /* guaranteed to be invalid */
  118. #define EV_NONE 0x00 /* no events */
  119. #define EV_READ 0x01 /* ev_io detected read will not block */
  120. #define EV_WRITE 0x02 /* ev_io detected write will not block */
  121. #define EV__IOFDSET 0x80 /* internal use only */
  122. #define EV_IO EV_READ /* alias for type-detection */
  123. #define EV_TIMEOUT 0x00000100 /* timer timed out */
  124. #define EV_TIMER EV_TIMEOUT /* alias for type-detection */
  125. #define EV_PERIODIC 0x00000200 /* periodic timer timed out */
  126. #define EV_SIGNAL 0x00000400 /* signal was received */
  127. #define EV_CHILD 0x00000800 /* child/pid had status change */
  128. #define EV_STAT 0x00001000 /* stat data changed */
  129. #define EV_IDLE 0x00002000 /* event loop is idling */
  130. #define EV_PREPARE 0x00004000 /* event loop about to poll */
  131. #define EV_CHECK 0x00008000 /* event loop finished poll */
  132. #define EV_EMBED 0x00010000 /* embedded event loop needs sweep */
  133. #define EV_FORK 0x00020000 /* event loop resumed in child */
  134. #define EV_ASYNC 0x00040000 /* async intra-loop signal */
  135. #define EV_CUSTOM 0x01000000 /* for use by user code */
  136. #define EV_ERROR 0x80000000 /* sent when an error occurs */
  137. /* can be used to add custom fields to all watchers, while losing binary compatibility */
  138. #ifndef EV_COMMON
  139. # define EV_COMMON void *data;
  140. #endif
  141. #ifndef EV_PROTOTYPES
  142. # define EV_PROTOTYPES 1
  143. #endif
  144. #define EV_VERSION_MAJOR 3
  145. #define EV_VERSION_MINOR 7
  146. #ifndef EV_CB_DECLARE
  147. # define EV_CB_DECLARE(type) void (*cb)(EV_P_ struct type *w, int revents);
  148. #endif
  149. #ifndef EV_CB_INVOKE
  150. # define EV_CB_INVOKE(watcher,revents) (watcher)->cb (EV_A_ (watcher), (revents))
  151. #endif
  152. /*
  153. * struct member types:
  154. * private: you may look at them, but not change them,
  155. * and they might not mean anything to you.
  156. * ro: can be read anytime, but only changed when the watcher isn't active.
  157. * rw: can be read and modified anytime, even when the watcher is active.
  158. *
  159. * some internal details that might be helpful for debugging:
  160. *
  161. * active is either 0, which means the watcher is not active,
  162. * or the array index of the watcher (periodics, timers)
  163. * or the array index + 1 (most other watchers)
  164. * or simply 1 for watchers that aren't in some array.
  165. * pending is either 0, in which case the watcher isn't,
  166. * or the array index + 1 in the pendings array.
  167. */
  168. #if EV_MINPRI == EV_MAXPRI
  169. # define EV_DECL_PRIORITY
  170. #else
  171. # define EV_DECL_PRIORITY int priority;
  172. #endif
  173. /* shared by all watchers */
  174. #define EV_WATCHER(type) \
  175. int active; /* private */ \
  176. int pending; /* private */ \
  177. EV_DECL_PRIORITY /* private */ \
  178. EV_COMMON /* rw */ \
  179. EV_CB_DECLARE (type) /* private */
  180. #define EV_WATCHER_LIST(type) \
  181. EV_WATCHER (type) \
  182. struct ev_watcher_list *next; /* private */
  183. #define EV_WATCHER_TIME(type) \
  184. EV_WATCHER (type) \
  185. ev_tstamp at; /* private */
  186. /* base class, nothing to see here unless you subclass */
  187. typedef struct ev_watcher
  188. {
  189. EV_WATCHER (ev_watcher)
  190. } ev_watcher;
  191. /* base class, nothing to see here unless you subclass */
  192. typedef struct ev_watcher_list
  193. {
  194. EV_WATCHER_LIST (ev_watcher_list)
  195. } ev_watcher_list;
  196. /* base class, nothing to see here unless you subclass */
  197. typedef struct ev_watcher_time
  198. {
  199. EV_WATCHER_TIME (ev_watcher_time)
  200. } ev_watcher_time;
  201. /* invoked when fd is either EV_READable or EV_WRITEable */
  202. /* revent EV_READ, EV_WRITE */
  203. typedef struct ev_io
  204. {
  205. EV_WATCHER_LIST (ev_io)
  206. int fd; /* ro */
  207. int events; /* ro */
  208. } ev_io;
  209. /* invoked after a specific time, repeatable (based on monotonic clock) */
  210. /* revent EV_TIMEOUT */
  211. typedef struct ev_timer
  212. {
  213. EV_WATCHER_TIME (ev_timer)
  214. ev_tstamp repeat; /* rw */
  215. } ev_timer;
  216. /* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */
  217. /* revent EV_PERIODIC */
  218. typedef struct ev_periodic
  219. {
  220. EV_WATCHER_TIME (ev_periodic)
  221. ev_tstamp offset; /* rw */
  222. ev_tstamp interval; /* rw */
  223. ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now); /* rw */
  224. } ev_periodic;
  225. /* invoked when the given signal has been received */
  226. /* revent EV_SIGNAL */
  227. typedef struct ev_signal
  228. {
  229. EV_WATCHER_LIST (ev_signal)
  230. int signum; /* ro */
  231. } ev_signal;
  232. /* invoked when sigchld is received and waitpid indicates the given pid */
  233. /* revent EV_CHILD */
  234. /* does not support priorities */
  235. typedef struct ev_child
  236. {
  237. EV_WATCHER_LIST (ev_child)
  238. int flags; /* private */
  239. int pid; /* ro */
  240. int rpid; /* rw, holds the received pid */
  241. int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
  242. } ev_child;
  243. #if EV_STAT_ENABLE
  244. /* st_nlink = 0 means missing file or other error */
  245. # ifdef _WIN32
  246. typedef struct _stati64 ev_statdata;
  247. # else
  248. typedef struct stat ev_statdata;
  249. # endif
  250. /* invoked each time the stat data changes for a given path */
  251. /* revent EV_STAT */
  252. typedef struct ev_stat
  253. {
  254. EV_WATCHER_LIST (ev_stat)
  255. ev_timer timer; /* private */
  256. ev_tstamp interval; /* ro */
  257. const char *path; /* ro */
  258. ev_statdata prev; /* ro */
  259. ev_statdata attr; /* ro */
  260. int wd; /* wd for inotify, fd for kqueue */
  261. } ev_stat;
  262. #endif
  263. #if EV_IDLE_ENABLE
  264. /* invoked when the nothing else needs to be done, keeps the process from blocking */
  265. /* revent EV_IDLE */
  266. typedef struct ev_idle
  267. {
  268. EV_WATCHER (ev_idle)
  269. } ev_idle;
  270. #endif
  271. /* invoked for each run of the mainloop, just before the blocking call */
  272. /* you can still change events in any way you like */
  273. /* revent EV_PREPARE */
  274. typedef struct ev_prepare
  275. {
  276. EV_WATCHER (ev_prepare)
  277. } ev_prepare;
  278. /* invoked for each run of the mainloop, just after the blocking call */
  279. /* revent EV_CHECK */
  280. typedef struct ev_check
  281. {
  282. EV_WATCHER (ev_check)
  283. } ev_check;
  284. #if EV_FORK_ENABLE
  285. /* the callback gets invoked before check in the child process when a fork was detected */
  286. typedef struct ev_fork
  287. {
  288. EV_WATCHER (ev_fork)
  289. } ev_fork;
  290. #endif
  291. #if EV_EMBED_ENABLE
  292. /* used to embed an event loop inside another */
  293. /* the callback gets invoked when the event loop has handled events, and can be 0 */
  294. typedef struct ev_embed
  295. {
  296. EV_WATCHER (ev_embed)
  297. struct ev_loop *other; /* ro */
  298. ev_io io; /* private */
  299. ev_prepare prepare; /* private */
  300. ev_check check; /* unused */
  301. ev_timer timer; /* unused */
  302. ev_periodic periodic; /* unused */
  303. ev_idle idle; /* unused */
  304. ev_fork fork; /* private */
  305. } ev_embed;
  306. #endif
  307. #if EV_ASYNC_ENABLE
  308. /* invoked when somebody calls ev_async_send on the watcher */
  309. /* revent EV_ASYNC */
  310. typedef struct ev_async
  311. {
  312. EV_WATCHER (ev_async)
  313. EV_ATOMIC_T sent; /* private */
  314. } ev_async;
  315. # define ev_async_pending(w) ((w)->sent + 0)
  316. #endif
  317. /* the presence of this union forces similar struct layout */
  318. union ev_any_watcher
  319. {
  320. struct ev_watcher w;
  321. struct ev_watcher_list wl;
  322. struct ev_io io;
  323. struct ev_timer timer;
  324. struct ev_periodic periodic;
  325. struct ev_signal signal;
  326. struct ev_child child;
  327. #if EV_STAT_ENABLE
  328. struct ev_stat stat;
  329. #endif
  330. #if EV_IDLE_ENABLE
  331. struct ev_idle idle;
  332. #endif
  333. struct ev_prepare prepare;
  334. struct ev_check check;
  335. #if EV_FORK_ENABLE
  336. struct ev_fork fork;
  337. #endif
  338. #if EV_EMBED_ENABLE
  339. struct ev_embed embed;
  340. #endif
  341. #if EV_ASYNC_ENABLE
  342. struct ev_async async;
  343. #endif
  344. };
  345. /* bits for ev_default_loop and ev_loop_new */
  346. /* the default */
  347. #define EVFLAG_AUTO 0x00000000U /* not quite a mask */
  348. /* flag bits */
  349. #define EVFLAG_NOENV 0x01000000U /* do NOT consult environment */
  350. #define EVFLAG_FORKCHECK 0x02000000U /* check for a fork in each iteration */
  351. /* method bits to be ored together */
  352. #define EVBACKEND_SELECT 0x00000001U /* about anywhere */
  353. #define EVBACKEND_POLL 0x00000002U /* !win */
  354. #define EVBACKEND_EPOLL 0x00000004U /* linux */
  355. #define EVBACKEND_KQUEUE 0x00000008U /* bsd */
  356. #define EVBACKEND_DEVPOLL 0x00000010U /* solaris 8 */ /* NYI */
  357. #define EVBACKEND_PORT 0x00000020U /* solaris 10 */
  358. #if EV_PROTOTYPES
  359. int ev_version_major (void);
  360. int ev_version_minor (void);
  361. unsigned int ev_supported_backends (void);
  362. unsigned int ev_recommended_backends (void);
  363. unsigned int ev_embeddable_backends (void);
  364. ev_tstamp ev_time (void);
  365. void ev_sleep (ev_tstamp delay); /* sleep for a while */
  366. /* Sets the allocation function to use, works like realloc.
  367. * It is used to allocate and free memory.
  368. * If it returns zero when memory needs to be allocated, the library might abort
  369. * or take some potentially destructive action.
  370. * The default is your system realloc function.
  371. */
  372. void ev_set_allocator (void *(*cb)(void *ptr, long size));
  373. /* set the callback function to call on a
  374. * retryable syscall error
  375. * (such as failed select, poll, epoll_wait)
  376. */
  377. void ev_set_syserr_cb (void (*cb)(const char *msg));
  378. #if EV_MULTIPLICITY
  379. EV_INLINE struct ev_loop *
  380. ev_default_loop_uc (void)
  381. {
  382. extern struct ev_loop *ev_default_loop_ptr;
  383. return ev_default_loop_ptr;
  384. }
  385. /* the default loop is the only one that handles signals and child watchers */
  386. /* you can call this as often as you like */
  387. EV_INLINE struct ev_loop *
  388. ev_default_loop (unsigned int flags)
  389. {
  390. struct ev_loop *loop = ev_default_loop_uc ();
  391. if (!loop)
  392. {
  393. extern struct ev_loop *ev_default_loop_init (unsigned int flags);
  394. loop = ev_default_loop_init (flags);
  395. }
  396. return loop;
  397. }
  398. /* create and destroy alternative loops that don't handle signals */
  399. struct ev_loop *ev_loop_new (unsigned int flags);
  400. void ev_loop_destroy (EV_P);
  401. void ev_loop_fork (EV_P);
  402. ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */
  403. #else
  404. int ev_default_loop (unsigned int flags); /* returns true when successful */
  405. EV_INLINE ev_tstamp
  406. ev_now (void)
  407. {
  408. extern ev_tstamp ev_rt_now;
  409. return ev_rt_now;
  410. }
  411. #endif /* multiplicity */
  412. EV_INLINE int
  413. ev_is_default_loop (EV_P)
  414. {
  415. #if EV_MULTIPLICITY
  416. extern struct ev_loop *ev_default_loop_ptr;
  417. return !!(EV_A == ev_default_loop_ptr);
  418. #else
  419. return 1;
  420. #endif
  421. }
  422. void ev_default_destroy (void); /* destroy the default loop */
  423. /* this needs to be called after fork, to duplicate the default loop */
  424. /* if you create alternative loops you have to call ev_loop_fork on them */
  425. /* you can call it in either the parent or the child */
  426. /* you can actually call it at any time, anywhere :) */
  427. void ev_default_fork (void);
  428. unsigned int ev_backend (EV_P); /* backend in use by loop */
  429. void ev_now_update (EV_P); /* update event loop time */
  430. #if EV_WALK_ENABLE
  431. /* walk (almost) all watchers in the loop of a given type, invoking the */
  432. /* callback on every such watcher. The callback might stop the watcher, */
  433. /* but do nothing else with the loop */
  434. void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w));
  435. #endif
  436. #endif /* prototypes */
  437. #define EVLOOP_NONBLOCK 1 /* do not block/wait */
  438. #define EVLOOP_ONESHOT 2 /* block *once* only */
  439. #define EVUNLOOP_CANCEL 0 /* undo unloop */
  440. #define EVUNLOOP_ONE 1 /* unloop once */
  441. #define EVUNLOOP_ALL 2 /* unloop all loops */
  442. #if EV_PROTOTYPES
  443. void ev_loop (EV_P_ int flags);
  444. void ev_unloop (EV_P_ int how); /* set to 1 to break out of event loop, set to 2 to break out of all event loops */
  445. /*
  446. * ref/unref can be used to add or remove a refcount on the mainloop. every watcher
  447. * keeps one reference. if you have a long-running watcher you never unregister that
  448. * should not keep ev_loop from running, unref() after starting, and ref() before stopping.
  449. */
  450. void ev_ref (EV_P);
  451. void ev_unref (EV_P);
  452. /*
  453. * convenience function, wait for a single event, without registering an event watcher
  454. * if timeout is < 0, do wait indefinitely
  455. */
  456. void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg);
  457. # if EV_MINIMAL < 2
  458. unsigned int ev_loop_count (EV_P); /* number of loop iterations */
  459. unsigned int ev_loop_depth (EV_P); /* #ev_loop enters - #ev_loop leaves */
  460. void ev_loop_verify (EV_P); /* abort if loop data corrupted */
  461. void ev_set_io_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
  462. void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */
  463. /* advanced stuff for threading etc. support, see docs */
  464. void ev_set_userdata (EV_P_ void *data);
  465. void *ev_userdata (EV_P);
  466. void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P));
  467. void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P));
  468. unsigned int ev_pending_count (EV_P); /* number of pending events, if any */
  469. void ev_invoke_pending (EV_P); /* invoke all pending watchers */
  470. /*
  471. * stop/start the timer handling.
  472. */
  473. void ev_suspend (EV_P);
  474. void ev_resume (EV_P);
  475. #endif
  476. #endif
  477. /* these may evaluate ev multiple times, and the other arguments at most once */
  478. /* either use ev_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */
  479. #define ev_init(ev,cb_) do { \
  480. ((ev_watcher *)(void *)(ev))->active = \
  481. ((ev_watcher *)(void *)(ev))->pending = 0; \
  482. ev_set_priority ((ev), 0); \
  483. ev_set_cb ((ev), cb_); \
  484. } while (0)
  485. #define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0)
  486. #define ev_timer_set(ev,after_,repeat_) do { ((ev_watcher_time *)(ev))->at = (after_); (ev)->repeat = (repeat_); } while (0)
  487. #define ev_periodic_set(ev,ofs_,ival_,rcb_) do { (ev)->offset = (ofs_); (ev)->interval = (ival_); (ev)->reschedule_cb = (rcb_); } while (0)
  488. #define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
  489. #define ev_child_set(ev,pid_,trace_) do { (ev)->pid = (pid_); (ev)->flags = !!(trace_); } while (0)
  490. #define ev_stat_set(ev,path_,interval_) do { (ev)->path = (path_); (ev)->interval = (interval_); (ev)->wd = -2; } while (0)
  491. #define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */
  492. #define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */
  493. #define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
  494. #define ev_embed_set(ev,other_) do { (ev)->other = (other_); } while (0)
  495. #define ev_fork_set(ev) /* nop, yes, this is a serious in-joke */
  496. #define ev_async_set(ev) do { (ev)->sent = 0; } while (0)
  497. #define ev_io_init(ev,cb,fd,events) do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
  498. #define ev_timer_init(ev,cb,after,repeat) do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
  499. #define ev_periodic_init(ev,cb,ofs,ival,rcb) do { ev_init ((ev), (cb)); ev_periodic_set ((ev),(ofs),(ival),(rcb)); } while (0)
  500. #define ev_signal_init(ev,cb,signum) do { ev_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0)
  501. #define ev_child_init(ev,cb,pid,trace) do { ev_init ((ev), (cb)); ev_child_set ((ev),(pid),(trace)); } while (0)
  502. #define ev_stat_init(ev,cb,path,interval) do { ev_init ((ev), (cb)); ev_stat_set ((ev),(path),(interval)); } while (0)
  503. #define ev_idle_init(ev,cb) do { ev_init ((ev), (cb)); ev_idle_set ((ev)); } while (0)
  504. #define ev_prepare_init(ev,cb) do { ev_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0)
  505. #define ev_check_init(ev,cb) do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
  506. #define ev_embed_init(ev,cb,other) do { ev_init ((ev), (cb)); ev_embed_set ((ev),(other)); } while (0)
  507. #define ev_fork_init(ev,cb) do { ev_init ((ev), (cb)); ev_fork_set ((ev)); } while (0)
  508. #define ev_async_init(ev,cb) do { ev_init ((ev), (cb)); ev_async_set ((ev)); } while (0)
  509. #define ev_is_pending(ev) (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
  510. #define ev_is_active(ev) (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
  511. #define ev_cb(ev) (ev)->cb /* rw */
  512. #if EV_MINPRI == EV_MAXPRI
  513. # define ev_priority(ev) ((ev), EV_MINPRI)
  514. # define ev_set_priority(ev,pri) ((ev), (pri))
  515. #else
  516. # define ev_priority(ev) ((((ev_watcher *)(void *)(ev))->priority) + 0)
  517. # define ev_set_priority(ev,pri) ( (ev_watcher *)(void *)(ev))->priority = (pri)
  518. #endif
  519. #define ev_periodic_at(ev) (((ev_watcher_time *)(ev))->at + 0.)
  520. #ifndef ev_set_cb
  521. # define ev_set_cb(ev,cb_) ev_cb (ev) = (cb_)
  522. #endif
  523. /* stopping (enabling, adding) a watcher does nothing if it is already running */
  524. /* stopping (disabling, deleting) a watcher does nothing unless its already running */
  525. #if EV_PROTOTYPES
  526. /* feeds an event into a watcher as if the event actually occured */
  527. /* accepts any ev_watcher type */
  528. void ev_feed_event (EV_P_ void *w, int revents);
  529. void ev_feed_fd_event (EV_P_ int fd, int revents);
  530. void ev_feed_signal_event (EV_P_ int signum);
  531. void ev_invoke (EV_P_ void *w, int revents);
  532. int ev_clear_pending (EV_P_ void *w);
  533. void ev_io_start (EV_P_ ev_io *w);
  534. void ev_io_stop (EV_P_ ev_io *w);
  535. void ev_timer_start (EV_P_ ev_timer *w);
  536. void ev_timer_stop (EV_P_ ev_timer *w);
  537. /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
  538. void ev_timer_again (EV_P_ ev_timer *w);
  539. /* return remaining time */
  540. ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w);
  541. #if EV_PERIODIC_ENABLE
  542. void ev_periodic_start (EV_P_ ev_periodic *w);
  543. void ev_periodic_stop (EV_P_ ev_periodic *w);
  544. void ev_periodic_again (EV_P_ ev_periodic *w);
  545. #endif
  546. /* only supported in the default loop */
  547. void ev_signal_start (EV_P_ ev_signal *w);
  548. void ev_signal_stop (EV_P_ ev_signal *w);
  549. /* only supported in the default loop */
  550. void ev_child_start (EV_P_ ev_child *w);
  551. void ev_child_stop (EV_P_ ev_child *w);
  552. # if EV_STAT_ENABLE
  553. void ev_stat_start (EV_P_ ev_stat *w);
  554. void ev_stat_stop (EV_P_ ev_stat *w);
  555. void ev_stat_stat (EV_P_ ev_stat *w);
  556. # endif
  557. # if EV_IDLE_ENABLE
  558. void ev_idle_start (EV_P_ ev_idle *w);
  559. void ev_idle_stop (EV_P_ ev_idle *w);
  560. # endif
  561. void ev_prepare_start (EV_P_ ev_prepare *w);
  562. void ev_prepare_stop (EV_P_ ev_prepare *w);
  563. void ev_check_start (EV_P_ ev_check *w);
  564. void ev_check_stop (EV_P_ ev_check *w);
  565. # if EV_FORK_ENABLE
  566. void ev_fork_start (EV_P_ ev_fork *w);
  567. void ev_fork_stop (EV_P_ ev_fork *w);
  568. # endif
  569. # if EV_EMBED_ENABLE
  570. /* only supported when loop to be embedded is in fact embeddable */
  571. void ev_embed_start (EV_P_ ev_embed *w);
  572. void ev_embed_stop (EV_P_ ev_embed *w);
  573. void ev_embed_sweep (EV_P_ ev_embed *w);
  574. # endif
  575. # if EV_ASYNC_ENABLE
  576. void ev_async_start (EV_P_ ev_async *w);
  577. void ev_async_stop (EV_P_ ev_async *w);
  578. void ev_async_send (EV_P_ ev_async *w);
  579. # endif
  580. #endif
  581. #ifdef __cplusplus
  582. }
  583. #endif
  584. #endif