cool.io 1.4.1-x64-mingw32

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