ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.h
Revision: 1.206
Committed: Fri Jun 23 11:29:38 2023 UTC (11 months, 3 weeks ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 1.205: +1 -1 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 root 1.10 /*
2 root 1.90 * libev native API header
3     *
4 root 1.203 * Copyright (c) 2007-2020 Marc Alexander Lehmann <libev@schmorp.de>
5 root 1.10 * All rights reserved.
6     *
7 root 1.90 * Redistribution and use in source and binary forms, with or without modifica-
8     * tion, are permitted provided that the following conditions are met:
9 root 1.159 *
10 root 1.90 * 1. Redistributions of source code must retain the above copyright notice,
11     * this list of conditions and the following disclaimer.
12 root 1.159 *
13 root 1.90 * 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 root 1.159 *
17 root 1.90 * 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 root 1.10 *
28 root 1.90 * 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 root 1.10 */
39    
40 root 1.125 #ifndef EV_H_
41     #define EV_H_
42 root 1.1
43 root 1.19 #ifdef __cplusplus
44 root 1.147 # define EV_CPP(x) x
45 root 1.180 # if __cplusplus >= 201103L
46 root 1.188 # define EV_NOEXCEPT noexcept
47 root 1.180 # else
48 root 1.188 # define EV_NOEXCEPT
49 root 1.180 # endif
50 root 1.147 #else
51     # define EV_CPP(x)
52 root 1.188 # define EV_NOEXCEPT
53 root 1.19 #endif
54 root 1.190 #define EV_THROW EV_NOEXCEPT /* pre-4.25, do not use in new code */
55 root 1.19
56 root 1.147 EV_CPP(extern "C" {)
57    
58 root 1.134 /*****************************************************************************/
59    
60 root 1.142 /* pre-4.0 compatibility */
61     #ifndef EV_COMPAT3
62     # define EV_COMPAT3 1
63     #endif
64    
65 root 1.134 #ifndef EV_FEATURES
66 root 1.166 # if defined __OPTIMIZE_SIZE__
67     # define EV_FEATURES 0x7c
68     # else
69     # define EV_FEATURES 0x7f
70     # endif
71 root 1.134 #endif
72    
73     #define EV_FEATURE_CODE ((EV_FEATURES) & 1)
74     #define EV_FEATURE_DATA ((EV_FEATURES) & 2)
75 root 1.136 #define EV_FEATURE_CONFIG ((EV_FEATURES) & 4)
76     #define EV_FEATURE_API ((EV_FEATURES) & 8)
77     #define EV_FEATURE_WATCHERS ((EV_FEATURES) & 16)
78     #define EV_FEATURE_BACKENDS ((EV_FEATURES) & 32)
79     #define EV_FEATURE_OS ((EV_FEATURES) & 64)
80 root 1.1
81 root 1.137 /* these priorities are inclusive, higher priorities will be invoked earlier */
82 root 1.21 #ifndef EV_MINPRI
83 root 1.136 # define EV_MINPRI (EV_FEATURE_CONFIG ? -2 : 0)
84 root 1.21 #endif
85     #ifndef EV_MAXPRI
86 root 1.136 # define EV_MAXPRI (EV_FEATURE_CONFIG ? +2 : 0)
87 root 1.21 #endif
88    
89 root 1.29 #ifndef EV_MULTIPLICITY
90 root 1.136 # define EV_MULTIPLICITY EV_FEATURE_CONFIG
91 root 1.29 #endif
92    
93 root 1.69 #ifndef EV_PERIODIC_ENABLE
94 root 1.134 # define EV_PERIODIC_ENABLE EV_FEATURE_WATCHERS
95 root 1.69 #endif
96    
97     #ifndef EV_STAT_ENABLE
98 root 1.134 # define EV_STAT_ENABLE EV_FEATURE_WATCHERS
99 root 1.69 #endif
100    
101 root 1.133 #ifndef EV_PREPARE_ENABLE
102 root 1.134 # define EV_PREPARE_ENABLE EV_FEATURE_WATCHERS
103 root 1.133 #endif
104    
105     #ifndef EV_CHECK_ENABLE
106 root 1.134 # define EV_CHECK_ENABLE EV_FEATURE_WATCHERS
107 root 1.133 #endif
108    
109 root 1.78 #ifndef EV_IDLE_ENABLE
110 root 1.134 # define EV_IDLE_ENABLE EV_FEATURE_WATCHERS
111 root 1.78 #endif
112    
113 root 1.72 #ifndef EV_FORK_ENABLE
114 root 1.151 # define EV_FORK_ENABLE EV_FEATURE_WATCHERS
115 root 1.150 #endif
116    
117     #ifndef EV_CLEANUP_ENABLE
118 root 1.152 # define EV_CLEANUP_ENABLE EV_FEATURE_WATCHERS
119 root 1.72 #endif
120    
121 root 1.132 #ifndef EV_SIGNAL_ENABLE
122 root 1.134 # define EV_SIGNAL_ENABLE EV_FEATURE_WATCHERS
123 root 1.132 #endif
124    
125     #ifndef EV_CHILD_ENABLE
126     # ifdef _WIN32
127     # define EV_CHILD_ENABLE 0
128     # else
129 root 1.134 # define EV_CHILD_ENABLE EV_FEATURE_WATCHERS
130 root 1.132 #endif
131 root 1.69 #endif
132    
133 root 1.92 #ifndef EV_ASYNC_ENABLE
134 root 1.134 # define EV_ASYNC_ENABLE EV_FEATURE_WATCHERS
135 root 1.92 #endif
136    
137 root 1.132 #ifndef EV_EMBED_ENABLE
138 root 1.134 # define EV_EMBED_ENABLE EV_FEATURE_WATCHERS
139 root 1.132 #endif
140    
141 root 1.115 #ifndef EV_WALK_ENABLE
142     # define EV_WALK_ENABLE 0 /* not yet */
143     #endif
144    
145 root 1.69 /*****************************************************************************/
146    
147 root 1.132 #if EV_CHILD_ENABLE && !EV_SIGNAL_ENABLE
148     # undef EV_SIGNAL_ENABLE
149     # define EV_SIGNAL_ENABLE 1
150     #endif
151    
152 root 1.134 /*****************************************************************************/
153    
154 root 1.196 #ifndef EV_TSTAMP_T
155     # define EV_TSTAMP_T double
156     #endif
157     typedef EV_TSTAMP_T ev_tstamp;
158 root 1.134
159 root 1.182 #include <string.h> /* for memmove */
160    
161 root 1.134 #ifndef EV_ATOMIC_T
162     # include <signal.h>
163     # define EV_ATOMIC_T sig_atomic_t volatile
164     #endif
165    
166 root 1.69 #if EV_STAT_ENABLE
167 root 1.103 # ifdef _WIN32
168     # include <time.h>
169     # include <sys/types.h>
170     # endif
171 root 1.69 # include <sys/stat.h>
172 root 1.50 #endif
173    
174 root 1.28 /* support multiple event loops? */
175 root 1.29 #if EV_MULTIPLICITY
176 root 1.28 struct ev_loop;
177 root 1.146 # define EV_P struct ev_loop *loop /* a loop as sole parameter in a declaration */
178 root 1.145 # define EV_P_ EV_P, /* a loop as first of multiple parameters */
179 root 1.146 # define EV_A loop /* a loop as sole argument to a function call */
180 root 1.145 # define EV_A_ EV_A, /* a loop as first of multiple arguments */
181 root 1.149 # define EV_DEFAULT_UC ev_default_loop_uc_ () /* the default loop, if initialised, as sole arg */
182 root 1.145 # define EV_DEFAULT_UC_ EV_DEFAULT_UC, /* the default loop as first of multiple arguments */
183 root 1.146 # define EV_DEFAULT ev_default_loop (0) /* the default loop as sole arg */
184 root 1.145 # define EV_DEFAULT_ EV_DEFAULT, /* the default loop as first of multiple arguments */
185 root 1.28 #else
186     # define EV_P void
187     # define EV_P_
188     # define EV_A
189     # define EV_A_
190 root 1.72 # define EV_DEFAULT
191     # define EV_DEFAULT_
192 root 1.96 # define EV_DEFAULT_UC
193     # define EV_DEFAULT_UC_
194     # undef EV_EMBED_ENABLE
195     #endif
196 root 1.69
197 root 1.146 /* EV_INLINE is used for functions in header files */
198 root 1.96 #if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3
199     # define EV_INLINE static inline
200     #else
201     # define EV_INLINE static
202 root 1.28 #endif
203 root 1.27
204 root 1.162 #ifdef EV_API_STATIC
205     # define EV_API_DECL static
206     #else
207     # define EV_API_DECL extern
208     #endif
209    
210 root 1.160 /* EV_PROTOTYPES can be used to switch of prototype declarations */
211 root 1.137 #ifndef EV_PROTOTYPES
212     # define EV_PROTOTYPES 1
213     #endif
214    
215 root 1.96 /*****************************************************************************/
216    
217 root 1.137 #define EV_VERSION_MAJOR 4
218 root 1.205 #define EV_VERSION_MINOR 33
219 root 1.137
220 root 1.1 /* eventmask, revents, events... */
221 root 1.142 enum {
222 root 1.170 EV_UNDEF = (int)0xFFFFFFFF, /* guaranteed to be invalid */
223     EV_NONE = 0x00, /* no events */
224     EV_READ = 0x01, /* ev_io detected read will not block */
225     EV_WRITE = 0x02, /* ev_io detected write will not block */
226     EV__IOFDSET = 0x80, /* internal use only */
227     EV_IO = EV_READ, /* alias for type-detection */
228     EV_TIMER = 0x00000100, /* timer timed out */
229 root 1.143 #if EV_COMPAT3
230 root 1.170 EV_TIMEOUT = EV_TIMER, /* pre 4.0 API compatibility */
231 root 1.143 #endif
232 root 1.170 EV_PERIODIC = 0x00000200, /* periodic timer timed out */
233     EV_SIGNAL = 0x00000400, /* signal was received */
234     EV_CHILD = 0x00000800, /* child/pid had status change */
235     EV_STAT = 0x00001000, /* stat data changed */
236     EV_IDLE = 0x00002000, /* event loop is idling */
237     EV_PREPARE = 0x00004000, /* event loop about to poll */
238     EV_CHECK = 0x00008000, /* event loop finished poll */
239     EV_EMBED = 0x00010000, /* embedded event loop needs sweep */
240     EV_FORK = 0x00020000, /* event loop resumed in child */
241     EV_CLEANUP = 0x00040000, /* event loop resumed in child */
242     EV_ASYNC = 0x00080000, /* async intra-loop signal */
243     EV_CUSTOM = 0x01000000, /* for use by user code */
244     EV_ERROR = (int)0x80000000 /* sent when an error occurs */
245 root 1.142 };
246 root 1.1
247 root 1.51 /* can be used to add custom fields to all watchers, while losing binary compatibility */
248 root 1.6 #ifndef EV_COMMON
249 root 1.52 # define EV_COMMON void *data;
250 root 1.6 #endif
251 root 1.14
252 root 1.44 #ifndef EV_CB_DECLARE
253 root 1.46 # define EV_CB_DECLARE(type) void (*cb)(EV_P_ struct type *w, int revents);
254 root 1.44 #endif
255     #ifndef EV_CB_INVOKE
256     # define EV_CB_INVOKE(watcher,revents) (watcher)->cb (EV_A_ (watcher), (revents))
257     #endif
258    
259 root 1.137 /* not official, do not use */
260     #define EV_CB(type,name) void name (EV_P_ struct ev_ ## type *w, int revents)
261    
262 root 1.6 /*
263     * struct member types:
264 root 1.108 * private: you may look at them, but not change them,
265     * and they might not mean anything to you.
266     * ro: can be read anytime, but only changed when the watcher isn't active.
267     * rw: can be read and modified anytime, even when the watcher is active.
268 root 1.101 *
269     * some internal details that might be helpful for debugging:
270     *
271     * active is either 0, which means the watcher is not active,
272     * or the array index of the watcher (periodics, timers)
273     * or the array index + 1 (most other watchers)
274     * or simply 1 for watchers that aren't in some array.
275     * pending is either 0, in which case the watcher isn't,
276 root 1.108 * or the array index + 1 in the pendings array.
277 root 1.6 */
278    
279 root 1.117 #if EV_MINPRI == EV_MAXPRI
280     # define EV_DECL_PRIORITY
281 root 1.137 #elif !defined (EV_DECL_PRIORITY)
282 root 1.117 # define EV_DECL_PRIORITY int priority;
283     #endif
284    
285 root 1.1 /* shared by all watchers */
286     #define EV_WATCHER(type) \
287     int active; /* private */ \
288     int pending; /* private */ \
289 root 1.117 EV_DECL_PRIORITY /* private */ \
290 root 1.52 EV_COMMON /* rw */ \
291 root 1.44 EV_CB_DECLARE (type) /* private */
292 root 1.1
293     #define EV_WATCHER_LIST(type) \
294 root 1.52 EV_WATCHER (type) \
295     struct ev_watcher_list *next; /* private */
296 root 1.1
297 root 1.6 #define EV_WATCHER_TIME(type) \
298 root 1.52 EV_WATCHER (type) \
299     ev_tstamp at; /* private */
300 root 1.6
301 root 1.7 /* base class, nothing to see here unless you subclass */
302 root 1.66 typedef struct ev_watcher
303 root 1.44 {
304 root 1.52 EV_WATCHER (ev_watcher)
305 root 1.66 } ev_watcher;
306 root 1.7
307     /* base class, nothing to see here unless you subclass */
308 root 1.66 typedef struct ev_watcher_list
309 root 1.44 {
310 root 1.52 EV_WATCHER_LIST (ev_watcher_list)
311 root 1.66 } ev_watcher_list;
312 root 1.7
313     /* base class, nothing to see here unless you subclass */
314 root 1.66 typedef struct ev_watcher_time
315 root 1.44 {
316 root 1.52 EV_WATCHER_TIME (ev_watcher_time)
317 root 1.66 } ev_watcher_time;
318 root 1.7
319 root 1.70 /* invoked when fd is either EV_READable or EV_WRITEable */
320     /* revent EV_READ, EV_WRITE */
321     typedef struct ev_io
322     {
323     EV_WATCHER_LIST (ev_io)
324    
325     int fd; /* ro */
326     int events; /* ro */
327     } ev_io;
328    
329 root 1.6 /* invoked after a specific time, repeatable (based on monotonic clock) */
330 root 1.17 /* revent EV_TIMEOUT */
331 root 1.66 typedef struct ev_timer
332 root 1.1 {
333 root 1.52 EV_WATCHER_TIME (ev_timer)
334 root 1.1
335     ev_tstamp repeat; /* rw */
336 root 1.66 } ev_timer;
337 root 1.6
338     /* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */
339 root 1.17 /* revent EV_PERIODIC */
340 root 1.66 typedef struct ev_periodic
341 root 1.6 {
342 root 1.52 EV_WATCHER_TIME (ev_periodic)
343 root 1.6
344 root 1.82 ev_tstamp offset; /* rw */
345 root 1.6 ev_tstamp interval; /* rw */
346 root 1.188 ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) EV_NOEXCEPT; /* rw */
347 root 1.66 } ev_periodic;
348 root 1.1
349 root 1.5 /* invoked when the given signal has been received */
350 root 1.17 /* revent EV_SIGNAL */
351 root 1.66 typedef struct ev_signal
352 root 1.1 {
353 root 1.52 EV_WATCHER_LIST (ev_signal)
354 root 1.1
355     int signum; /* ro */
356 root 1.66 } ev_signal;
357 root 1.1
358 root 1.70 /* invoked when sigchld is received and waitpid indicates the given pid */
359     /* revent EV_CHILD */
360     /* does not support priorities */
361     typedef struct ev_child
362     {
363     EV_WATCHER_LIST (ev_child)
364    
365 root 1.91 int flags; /* private */
366 root 1.70 int pid; /* ro */
367     int rpid; /* rw, holds the received pid */
368     int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
369     } ev_child;
370    
371     #if EV_STAT_ENABLE
372     /* st_nlink = 0 means missing file or other error */
373 root 1.74 # ifdef _WIN32
374 root 1.71 typedef struct _stati64 ev_statdata;
375 root 1.74 # else
376 root 1.70 typedef struct stat ev_statdata;
377 root 1.74 # endif
378 root 1.70
379     /* invoked each time the stat data changes for a given path */
380     /* revent EV_STAT */
381     typedef struct ev_stat
382     {
383 root 1.74 EV_WATCHER_LIST (ev_stat)
384 root 1.70
385     ev_timer timer; /* private */
386     ev_tstamp interval; /* ro */
387     const char *path; /* ro */
388     ev_statdata prev; /* ro */
389     ev_statdata attr; /* ro */
390 root 1.74
391     int wd; /* wd for inotify, fd for kqueue */
392 root 1.70 } ev_stat;
393     #endif
394    
395 root 1.5 /* invoked when the nothing else needs to be done, keeps the process from blocking */
396 root 1.17 /* revent EV_IDLE */
397 root 1.66 typedef struct ev_idle
398 root 1.5 {
399 root 1.52 EV_WATCHER (ev_idle)
400 root 1.66 } ev_idle;
401 root 1.5
402 root 1.11 /* invoked for each run of the mainloop, just before the blocking call */
403     /* you can still change events in any way you like */
404 root 1.17 /* revent EV_PREPARE */
405 root 1.66 typedef struct ev_prepare
406 root 1.11 {
407 root 1.52 EV_WATCHER (ev_prepare)
408 root 1.66 } ev_prepare;
409 root 1.11
410     /* invoked for each run of the mainloop, just after the blocking call */
411 root 1.17 /* revent EV_CHECK */
412 root 1.66 typedef struct ev_check
413 root 1.5 {
414 root 1.52 EV_WATCHER (ev_check)
415 root 1.66 } ev_check;
416 root 1.5
417 root 1.72 /* the callback gets invoked before check in the child process when a fork was detected */
418 root 1.150 /* revent EV_FORK */
419 root 1.72 typedef struct ev_fork
420     {
421     EV_WATCHER (ev_fork)
422     } ev_fork;
423    
424 root 1.150 /* is invoked just before the loop gets destroyed */
425     /* revent EV_CLEANUP */
426     typedef struct ev_cleanup
427     {
428     EV_WATCHER (ev_cleanup)
429     } ev_cleanup;
430    
431 root 1.69 #if EV_EMBED_ENABLE
432 root 1.64 /* used to embed an event loop inside another */
433     /* the callback gets invoked when the event loop has handled events, and can be 0 */
434 root 1.66 typedef struct ev_embed
435 root 1.64 {
436     EV_WATCHER (ev_embed)
437    
438 root 1.86 struct ev_loop *other; /* ro */
439 root 1.200 #undef EV_IO_ENABLE
440     #define EV_IO_ENABLE 1
441 root 1.87 ev_io io; /* private */
442 root 1.200 #undef EV_PREPARE_ENABLE
443     #define EV_PREPARE_ENABLE 1
444 root 1.87 ev_prepare prepare; /* private */
445     ev_check check; /* unused */
446     ev_timer timer; /* unused */
447     ev_periodic periodic; /* unused */
448     ev_idle idle; /* unused */
449 root 1.106 ev_fork fork; /* private */
450 root 1.150 ev_cleanup cleanup; /* unused */
451 root 1.66 } ev_embed;
452 root 1.64 #endif
453    
454 root 1.92 #if EV_ASYNC_ENABLE
455     /* invoked when somebody calls ev_async_send on the watcher */
456     /* revent EV_ASYNC */
457     typedef struct ev_async
458     {
459     EV_WATCHER (ev_async)
460    
461     EV_ATOMIC_T sent; /* private */
462     } ev_async;
463 root 1.95
464 root 1.128 # define ev_async_pending(w) (+(w)->sent)
465 root 1.92 #endif
466    
467 root 1.41 /* the presence of this union forces similar struct layout */
468 root 1.35 union ev_any_watcher
469     {
470     struct ev_watcher w;
471     struct ev_watcher_list wl;
472 root 1.46
473 root 1.35 struct ev_io io;
474     struct ev_timer timer;
475     struct ev_periodic periodic;
476 root 1.72 struct ev_signal signal;
477 root 1.70 struct ev_child child;
478     #if EV_STAT_ENABLE
479     struct ev_stat stat;
480     #endif
481 root 1.78 #if EV_IDLE_ENABLE
482 root 1.35 struct ev_idle idle;
483 root 1.78 #endif
484 root 1.35 struct ev_prepare prepare;
485     struct ev_check check;
486 root 1.72 #if EV_FORK_ENABLE
487     struct ev_fork fork;
488     #endif
489 root 1.150 #if EV_CLEANUP_ENABLE
490     struct ev_cleanup cleanup;
491     #endif
492 root 1.69 #if EV_EMBED_ENABLE
493 root 1.64 struct ev_embed embed;
494 root 1.67 #endif
495 root 1.97 #if EV_ASYNC_ENABLE
496 root 1.92 struct ev_async async;
497     #endif
498 root 1.35 };
499    
500 root 1.142 /* flag bits for ev_default_loop and ev_loop_new */
501     enum {
502     /* the default */
503 root 1.197 EVFLAG_AUTO = 0x00000000U, /* not quite a mask */
504 root 1.142 /* flag bits */
505 root 1.197 EVFLAG_NOENV = 0x01000000U, /* do NOT consult environment */
506     EVFLAG_FORKCHECK = 0x02000000U, /* check for a fork in each iteration */
507 root 1.142 /* debugging/feature disable */
508 root 1.197 EVFLAG_NOINOTIFY = 0x00100000U, /* do not attempt to use inotify */
509 root 1.142 #if EV_COMPAT3
510 root 1.197 EVFLAG_NOSIGFD = 0, /* compatibility to pre-3.9 */
511 root 1.142 #endif
512 root 1.197 EVFLAG_SIGNALFD = 0x00200000U, /* attempt to use signalfd */
513     EVFLAG_NOSIGMASK = 0x00400000U, /* avoid modifying the signal mask */
514     EVFLAG_NOTIMERFD = 0x00800000U /* avoid creating a timerfd */
515 root 1.142 };
516    
517 root 1.53 /* method bits to be ored together */
518 root 1.142 enum {
519 root 1.191 EVBACKEND_SELECT = 0x00000001U, /* available just about anywhere */
520     EVBACKEND_POLL = 0x00000002U, /* !win, !aix, broken on osx */
521     EVBACKEND_EPOLL = 0x00000004U, /* linux */
522     EVBACKEND_KQUEUE = 0x00000008U, /* bsd, broken on osx */
523     EVBACKEND_DEVPOLL = 0x00000010U, /* solaris 8 */ /* NYI */
524     EVBACKEND_PORT = 0x00000020U, /* solaris 10 */
525 root 1.199 EVBACKEND_LINUXAIO = 0x00000040U, /* linux AIO, 4.19+ */
526 root 1.195 EVBACKEND_IOURING = 0x00000080U, /* linux io_uring, 5.1+ */
527 root 1.194 EVBACKEND_ALL = 0x000000FFU, /* all known backends */
528 root 1.191 EVBACKEND_MASK = 0x0000FFFFU /* all future backends */
529 root 1.142 };
530 root 1.29
531 root 1.9 #if EV_PROTOTYPES
532 root 1.188 EV_API_DECL int ev_version_major (void) EV_NOEXCEPT;
533     EV_API_DECL int ev_version_minor (void) EV_NOEXCEPT;
534 root 1.1
535 root 1.188 EV_API_DECL unsigned int ev_supported_backends (void) EV_NOEXCEPT;
536     EV_API_DECL unsigned int ev_recommended_backends (void) EV_NOEXCEPT;
537     EV_API_DECL unsigned int ev_embeddable_backends (void) EV_NOEXCEPT;
538 root 1.63
539 root 1.188 EV_API_DECL ev_tstamp ev_time (void) EV_NOEXCEPT;
540     EV_API_DECL void ev_sleep (ev_tstamp delay) EV_NOEXCEPT; /* sleep for a while */
541 root 1.29
542 root 1.36 /* Sets the allocation function to use, works like realloc.
543     * It is used to allocate and free memory.
544     * If it returns zero when memory needs to be allocated, the library might abort
545     * or take some potentially destructive action.
546     * The default is your system realloc function.
547     */
548 root 1.188 EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT;
549 root 1.36
550     /* set the callback function to call on a
551     * retryable syscall error
552     * (such as failed select, poll, epoll_wait)
553     */
554 root 1.188 EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT;
555 root 1.36
556 root 1.102 #if EV_MULTIPLICITY
557 root 1.148
558     /* the default loop is the only one that handles signals and child watchers */
559     /* you can call this as often as you like */
560 root 1.188 EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT;
561 root 1.162
562 root 1.163 #ifdef EV_API_STATIC
563 root 1.162 EV_API_DECL struct ev_loop *ev_default_loop_ptr;
564 root 1.163 #endif
565 root 1.148
566 root 1.96 EV_INLINE struct ev_loop *
567 root 1.188 ev_default_loop_uc_ (void) EV_NOEXCEPT
568 root 1.96 {
569     extern struct ev_loop *ev_default_loop_ptr;
570    
571     return ev_default_loop_ptr;
572     }
573    
574 root 1.148 EV_INLINE int
575 root 1.188 ev_is_default_loop (EV_P) EV_NOEXCEPT
576 root 1.58 {
577 root 1.149 return EV_A == EV_DEFAULT_UC;
578 root 1.58 }
579 root 1.30
580     /* create and destroy alternative loops that don't handle signals */
581 root 1.188 EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT;
582 root 1.47
583 root 1.188 EV_API_DECL ev_tstamp ev_now (EV_P) EV_NOEXCEPT; /* time w.r.t. timers and the eventloop, updated after each poll */
584 root 1.47
585 root 1.102 #else
586 root 1.47
587 root 1.188 EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT; /* returns true when successful */
588 root 1.162
589     EV_API_DECL ev_tstamp ev_rt_now;
590 root 1.47
591 root 1.96 EV_INLINE ev_tstamp
592 root 1.188 ev_now (void) EV_NOEXCEPT
593 root 1.47 {
594     return ev_rt_now;
595     }
596 root 1.29
597 root 1.148 /* looks weird, but ev_is_default_loop (EV_A) still works if this exists */
598 root 1.96 EV_INLINE int
599 root 1.188 ev_is_default_loop (void) EV_NOEXCEPT
600 root 1.94 {
601     return 1;
602     }
603    
604 root 1.148 #endif /* multiplicity */
605    
606 root 1.153 /* destroy event loops, also works for the default loop */
607 root 1.169 EV_API_DECL void ev_loop_destroy (EV_P);
608 root 1.153
609 root 1.149 /* this needs to be called after fork, to duplicate the loop */
610     /* when you want to re-use it in the child */
611 root 1.30 /* you can call it in either the parent or the child */
612     /* you can actually call it at any time, anywhere :) */
613 root 1.188 EV_API_DECL void ev_loop_fork (EV_P) EV_NOEXCEPT;
614 root 1.30
615 root 1.188 EV_API_DECL unsigned int ev_backend (EV_P) EV_NOEXCEPT; /* backend in use by loop */
616 root 1.116
617 root 1.188 EV_API_DECL void ev_now_update (EV_P) EV_NOEXCEPT; /* update event loop time */
618 root 1.118
619 root 1.115 #if EV_WALK_ENABLE
620 root 1.112 /* walk (almost) all watchers in the loop of a given type, invoking the */
621     /* callback on every such watcher. The callback might stop the watcher, */
622     /* but do nothing else with the loop */
623 root 1.188 EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT;
624 root 1.112 #endif
625    
626 root 1.102 #endif /* prototypes */
627 root 1.1
628 root 1.142 /* ev_run flags values */
629     enum {
630     EVRUN_NOWAIT = 1, /* do not block/wait */
631     EVRUN_ONCE = 2 /* block *once* only */
632     };
633    
634     /* ev_break how values */
635     enum {
636     EVBREAK_CANCEL = 0, /* undo unloop */
637     EVBREAK_ONE = 1, /* unloop once */
638     EVBREAK_ALL = 2 /* unloop all loops */
639     };
640 root 1.29
641 root 1.9 #if EV_PROTOTYPES
642 root 1.165 EV_API_DECL int ev_run (EV_P_ int flags EV_CPP (= 0));
643 root 1.188 EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_NOEXCEPT; /* break out of the loop */
644 root 1.27
645     /*
646     * ref/unref can be used to add or remove a refcount on the mainloop. every watcher
647 root 1.119 * keeps one reference. if you have a long-running watcher you never unregister that
648 root 1.27 * should not keep ev_loop from running, unref() after starting, and ref() before stopping.
649     */
650 root 1.188 EV_API_DECL void ev_ref (EV_P) EV_NOEXCEPT;
651     EV_API_DECL void ev_unref (EV_P) EV_NOEXCEPT;
652 root 1.1
653 root 1.114 /*
654 root 1.119 * convenience function, wait for a single event, without registering an event watcher
655     * if timeout is < 0, do wait indefinitely
656     */
657 root 1.188 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;
658 root 1.119
659 root 1.200 EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */
660    
661 root 1.134 # if EV_FEATURE_API
662 root 1.188 EV_API_DECL unsigned int ev_iteration (EV_P) EV_NOEXCEPT; /* number of loop iterations */
663     EV_API_DECL unsigned int ev_depth (EV_P) EV_NOEXCEPT; /* #ev_loop enters - #ev_loop leaves */
664     EV_API_DECL void ev_verify (EV_P) EV_NOEXCEPT; /* abort if loop data corrupted */
665 root 1.138
666 root 1.188 EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */
667     EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */
668 root 1.119
669 root 1.120 /* advanced stuff for threading etc. support, see docs */
670 root 1.188 EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT;
671     EV_API_DECL void *ev_userdata (EV_P) EV_NOEXCEPT;
672 root 1.172 typedef void (*ev_loop_callback)(EV_P);
673 root 1.188 EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT;
674 root 1.181 /* C++ doesn't allow the use of the ev_loop_callback typedef here, so we need to spell it out */
675 root 1.188 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;
676 root 1.119
677 root 1.188 EV_API_DECL unsigned int ev_pending_count (EV_P) EV_NOEXCEPT; /* number of pending events, if any */
678 root 1.119
679     /*
680 root 1.114 * stop/start the timer handling.
681     */
682 root 1.188 EV_API_DECL void ev_suspend (EV_P) EV_NOEXCEPT;
683     EV_API_DECL void ev_resume (EV_P) EV_NOEXCEPT;
684 root 1.119 #endif
685 root 1.114
686 root 1.9 #endif
687    
688 root 1.2 /* these may evaluate ev multiple times, and the other arguments at most once */
689 root 1.45 /* either use ev_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */
690 root 1.78 #define ev_init(ev,cb_) do { \
691 root 1.117 ((ev_watcher *)(void *)(ev))->active = \
692     ((ev_watcher *)(void *)(ev))->pending = 0; \
693     ev_set_priority ((ev), 0); \
694 root 1.78 ev_set_cb ((ev), cb_); \
695 root 1.32 } while (0)
696 root 1.3
697 root 1.202 #define ev_io_modify(ev,events_) do { (ev)->events = (ev)->events & EV__IOFDSET | (events_); } while (0)
698 root 1.111 #define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0)
699 root 1.110 #define ev_timer_set(ev,after_,repeat_) do { ((ev_watcher_time *)(ev))->at = (after_); (ev)->repeat = (repeat_); } while (0)
700     #define ev_periodic_set(ev,ofs_,ival_,rcb_) do { (ev)->offset = (ofs_); (ev)->interval = (ival_); (ev)->reschedule_cb = (rcb_); } while (0)
701     #define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
702     #define ev_child_set(ev,pid_,trace_) do { (ev)->pid = (pid_); (ev)->flags = !!(trace_); } while (0)
703     #define ev_stat_set(ev,path_,interval_) do { (ev)->path = (path_); (ev)->interval = (interval_); (ev)->wd = -2; } while (0)
704     #define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */
705     #define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */
706     #define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
707     #define ev_embed_set(ev,other_) do { (ev)->other = (other_); } while (0)
708     #define ev_fork_set(ev) /* nop, yes, this is a serious in-joke */
709 root 1.150 #define ev_cleanup_set(ev) /* nop, yes, this is a serious in-joke */
710 root 1.140 #define ev_async_set(ev) /* nop, yes, this is a serious in-joke */
711 root 1.110
712     #define ev_io_init(ev,cb,fd,events) do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
713     #define ev_timer_init(ev,cb,after,repeat) do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
714     #define ev_periodic_init(ev,cb,ofs,ival,rcb) do { ev_init ((ev), (cb)); ev_periodic_set ((ev),(ofs),(ival),(rcb)); } while (0)
715     #define ev_signal_init(ev,cb,signum) do { ev_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0)
716     #define ev_child_init(ev,cb,pid,trace) do { ev_init ((ev), (cb)); ev_child_set ((ev),(pid),(trace)); } while (0)
717     #define ev_stat_init(ev,cb,path,interval) do { ev_init ((ev), (cb)); ev_stat_set ((ev),(path),(interval)); } while (0)
718     #define ev_idle_init(ev,cb) do { ev_init ((ev), (cb)); ev_idle_set ((ev)); } while (0)
719     #define ev_prepare_init(ev,cb) do { ev_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0)
720     #define ev_check_init(ev,cb) do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
721     #define ev_embed_init(ev,cb,other) do { ev_init ((ev), (cb)); ev_embed_set ((ev),(other)); } while (0)
722     #define ev_fork_init(ev,cb) do { ev_init ((ev), (cb)); ev_fork_set ((ev)); } while (0)
723 root 1.150 #define ev_cleanup_init(ev,cb) do { ev_init ((ev), (cb)); ev_cleanup_set ((ev)); } while (0)
724 root 1.110 #define ev_async_init(ev,cb) do { ev_init ((ev), (cb)); ev_async_set ((ev)); } while (0)
725    
726     #define ev_is_pending(ev) (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
727     #define ev_is_active(ev) (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
728    
729 root 1.182 #define ev_cb_(ev) (ev)->cb /* rw */
730     #define ev_cb(ev) (memmove (&ev_cb_ (ev), &((ev_watcher *)(ev))->cb, sizeof (ev_cb_ (ev))), (ev)->cb)
731 root 1.117
732     #if EV_MINPRI == EV_MAXPRI
733     # define ev_priority(ev) ((ev), EV_MINPRI)
734     # define ev_set_priority(ev,pri) ((ev), (pri))
735     #else
736 root 1.128 # define ev_priority(ev) (+(((ev_watcher *)(void *)(ev))->priority))
737 root 1.131 # define ev_set_priority(ev,pri) ( (ev_watcher *)(void *)(ev))->priority = (pri)
738 root 1.117 #endif
739 root 1.45
740 root 1.128 #define ev_periodic_at(ev) (+((ev_watcher_time *)(ev))->at)
741 root 1.100
742 root 1.45 #ifndef ev_set_cb
743 root 1.202 /* memmove is used here to avoid strict aliasing violations, and hopefully is optimized out by any reasonable compiler */
744 root 1.182 # define ev_set_cb(ev,cb_) (ev_cb_ (ev) = (cb_), memmove (&((ev_watcher *)(ev))->cb, &ev_cb_ (ev), sizeof (ev_cb_ (ev))))
745 root 1.45 #endif
746 root 1.1
747 root 1.206 /* starting (enabling, adding) a watcher does nothing if it is already running */
748 root 1.172 /* stopping (disabling, deleting) a watcher does nothing unless it's already running */
749 root 1.9 #if EV_PROTOTYPES
750 root 1.41
751 root 1.161 /* feeds an event into a watcher as if the event actually occurred */
752 root 1.41 /* accepts any ev_watcher type */
753 root 1.188 EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT;
754     EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT;
755 root 1.132 #if EV_SIGNAL_ENABLE
756 root 1.188 EV_API_DECL void ev_feed_signal (int signum) EV_NOEXCEPT;
757     EV_API_DECL void ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT;
758 root 1.132 #endif
759 root 1.162 EV_API_DECL void ev_invoke (EV_P_ void *w, int revents);
760 root 1.188 EV_API_DECL int ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT;
761 root 1.41
762 root 1.188 EV_API_DECL void ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT;
763     EV_API_DECL void ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT;
764 root 1.6
765 root 1.188 EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT;
766     EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT;
767 root 1.30 /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
768 root 1.188 EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT;
769 root 1.123 /* return remaining time */
770 root 1.188 EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT;
771 root 1.1
772 root 1.69 #if EV_PERIODIC_ENABLE
773 root 1.188 EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT;
774     EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT;
775     EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT;
776 root 1.50 #endif
777 root 1.1
778 root 1.70 /* only supported in the default loop */
779 root 1.132 #if EV_SIGNAL_ENABLE
780 root 1.188 EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT;
781     EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT;
782 root 1.132 #endif
783 root 1.70
784     /* only supported in the default loop */
785 root 1.132 # if EV_CHILD_ENABLE
786 root 1.188 EV_API_DECL void ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT;
787     EV_API_DECL void ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT;
788 root 1.132 # endif
789 root 1.70
790     # if EV_STAT_ENABLE
791 root 1.188 EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT;
792     EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT;
793     EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT;
794 root 1.70 # endif
795    
796 root 1.78 # if EV_IDLE_ENABLE
797 root 1.188 EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT;
798     EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT;
799 root 1.78 # endif
800 root 1.5
801 root 1.133 #if EV_PREPARE_ENABLE
802 root 1.188 EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT;
803     EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT;
804 root 1.133 #endif
805 root 1.11
806 root 1.133 #if EV_CHECK_ENABLE
807 root 1.188 EV_API_DECL void ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT;
808     EV_API_DECL void ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT;
809 root 1.133 #endif
810 root 1.12
811 root 1.72 # if EV_FORK_ENABLE
812 root 1.188 EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT;
813     EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT;
814 root 1.72 # endif
815    
816 root 1.150 # if EV_CLEANUP_ENABLE
817 root 1.188 EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT;
818     EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT;
819 root 1.150 # endif
820    
821 root 1.69 # if EV_EMBED_ENABLE
822 root 1.64 /* only supported when loop to be embedded is in fact embeddable */
823 root 1.188 EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT;
824     EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT;
825     EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT;
826 root 1.64 # endif
827    
828 root 1.92 # if EV_ASYNC_ENABLE
829 root 1.188 EV_API_DECL void ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT;
830     EV_API_DECL void ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT;
831     EV_API_DECL void ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT;
832 root 1.92 # endif
833    
834 root 1.141 #if EV_COMPAT3
835     #define EVLOOP_NONBLOCK EVRUN_NOWAIT
836     #define EVLOOP_ONESHOT EVRUN_ONCE
837     #define EVUNLOOP_CANCEL EVBREAK_CANCEL
838     #define EVUNLOOP_ONE EVBREAK_ONE
839     #define EVUNLOOP_ALL EVBREAK_ALL
840     #if EV_PROTOTYPES
841     EV_INLINE void ev_loop (EV_P_ int flags) { ev_run (EV_A_ flags); }
842     EV_INLINE void ev_unloop (EV_P_ int how ) { ev_break (EV_A_ how ); }
843 root 1.149 EV_INLINE void ev_default_destroy (void) { ev_loop_destroy (EV_DEFAULT); }
844     EV_INLINE void ev_default_fork (void) { ev_loop_fork (EV_DEFAULT); }
845 root 1.141 #if EV_FEATURE_API
846 root 1.155 EV_INLINE unsigned int ev_loop_count (EV_P) { return ev_iteration (EV_A); }
847     EV_INLINE unsigned int ev_loop_depth (EV_P) { return ev_depth (EV_A); }
848     EV_INLINE void ev_loop_verify (EV_P) { ev_verify (EV_A); }
849 root 1.141 #endif
850     #endif
851     #else
852     typedef struct ev_loop ev_loop;
853     #endif
854    
855 root 1.9 #endif
856 root 1.5
857 root 1.147 EV_CPP(})
858 root 1.19
859 root 1.1 #endif
860