Style: remove unwanted space.

[software/ev.d.git] / ev.d

diff --git a/ev.d b/ev.d
index 5c82a04eae1ad2d139445d06aa78f746781e23c8..1a2d0d02be8c5d59936091f1a61350c79ad88e93 100644 (file)
--- a/ev.d
+++ b/ev.d
@@ -61,474 +61,471 @@ enum how
        ALL    = 2, // unloop all loops
 }
 
        ALL    = 2, // unloop all loops
 }
 

-extern (C)
+
+extern (C):
+align (4):
+
+version (EV_ENABLE_SELECT)
+{
+}
+else

 {
 {

+       version = EV_PERIODIC_ENABLE;
+       version = EV_STAT_ENABLE;
+       version = EV_IDLE_ENABLE;
+       version = EV_FORK_ENABLE;
+       version = EV_EMBED_ENABLE;
+}

 
 

-       version (EV_ENABLE_SELECT)
-       {
-       }
-       else
-       {
-               version = EV_PERIODIC_ENABLE;
-               version = EV_STAT_ENABLE;
-               version = EV_IDLE_ENABLE;
-               version = EV_FORK_ENABLE;
-               version = EV_EMBED_ENABLE;
-       }
+alias double ev_tstamp;

 
 

-       alias double ev_tstamp;
+struct ev_loop_t;

 
 

-       struct ev_loop_t;
+template EV_COMMON()
+{
+       void* data;
+}

 
 

-       template EV_COMMON()
-       {
-               void* data;
-       }
+template EV_CB_DECLARE(TYPE)
+{
+       void function (ev_loop_t*, TYPE*, int) cb;
+}

 
 

-       template EV_CB_DECLARE(TYPE)
-       {
-               void function (ev_loop_t*, TYPE*, int) cb;
-       }
+template EV_WATCHER(TYPE)
+{
+       int active;                 // private
+       int pending;                // private
+       int priority;               // private
+       mixin EV_COMMON;            // rw
+       mixin EV_CB_DECLARE!(TYPE); // private
+}

 
 

-       template EV_WATCHER(TYPE)
-       {
-               int active;                 // private
-               int pending;                // private
-               int priority;               // private
-               mixin EV_COMMON;            // rw
-               mixin EV_CB_DECLARE!(TYPE); // private
-       }
+template EV_WATCHER_LIST(TYPE)
+{
+       mixin EV_WATCHER!(TYPE);
+       ev_watcher_list* next;      // private
+}

 
 

-       template EV_WATCHER_LIST(TYPE)
-       {
-               mixin EV_WATCHER!(TYPE);
-               ev_watcher_list* next;      // private
-       }
+template EV_WATCHER_TIME(TYPE)
+{
+       mixin EV_WATCHER!(TYPE);
+       ev_tstamp at;               // private
+}

 
 

-       template EV_WATCHER_TIME(TYPE)
-       {
-               mixin EV_WATCHER!(TYPE);
-               ev_tstamp at;               // private
-       }
+struct ev_watcher
+{
+       mixin EV_WATCHER!(ev_watcher);
+}

 
 

-       align (4) {
-
-               struct ev_watcher
-               {
-                       mixin EV_WATCHER!(ev_watcher);
-               }
-
-               struct ev_watcher_list
-               {
-                       mixin EV_WATCHER_LIST!(ev_watcher_list);
-               }
-
-               struct ev_watcher_time
-               {
-                       mixin EV_WATCHER_TIME!(ev_watcher_time);
-               }
-
-               struct ev_io
-               {
-                       mixin EV_WATCHER_LIST!(ev_io);
-                       int fd;     // ro
-                       int events; // ro
-               }
-
-               struct ev_timer
-               {
-                       mixin EV_WATCHER_TIME!(ev_timer);
-                       ev_tstamp repeat; // rw
-               }
-
-               version (EV_PERIODIC_ENABLE)
-               {
-                       struct ev_periodic
-                       {
-                               mixin EV_WATCHER_TIME!(ev_periodic);
-                               ev_tstamp offset;                     // rw
-                               ev_tstamp interval;                   // rw
-                               ev_tstamp function(ev_periodic *w,
-                                       ev_tstamp now) reschedule_cb; // rw
-                       }
-               }
-
-               struct ev_signal
-               {
-                       mixin EV_WATCHER_LIST!(ev_signal);
-                       int signum; // ro
-               }
-
-               struct ev_child
-               {
-                       mixin EV_WATCHER_LIST!(ev_child);
-                       int pid;     // ro
-                       int rpid;    // rw, holds the received pid
-                       int rstatus; // rw, holds the exit status, use the
-                                    // macros from sys/wait.h
-               }
-
-               version (EV_STAT_ENABLE)
-               {
-
-                       version (Windows) // alias _stati64 ev_statdata;
-                       {
-                               pragma (msg, "ev_stat not supported in windows "
-                                               "because I don't know the "
-                                               "layout of _stati64");
-                               static assert(0);
-                               // Maybe this should work?
-                               //static import stat = std.c.windows.stat;
-                               //alias stat.struct_stat ev_statdata;
-                       }
-                       else // It should be POSIX
-                       {
-                               static import stat = std.c.unix.unix;
-                               alias stat.struct_stat ev_statdata;
-                       }
-
-                       struct ev_stat
-                       {
-                               mixin EV_WATCHER_LIST!(ev_stat);
-
-                               ev_timer timer;     // private
-                               ev_tstamp interval; // ro
-                               const char *path;   // ro
-                               ev_statdata prev;   // ro
-                               ev_statdata attr;   // ro
-                               int wd; // wd for inotify, fd for kqueue
-                       }
-               }
-
-               version (EV_IDLE_ENABLE)
-               {
-                       struct ev_idle
-                       {
-                               mixin EV_WATCHER!(ev_idle);
-                       }
-               }
-
-               struct ev_prepare
-               {
-                       mixin EV_WATCHER!(ev_prepare);
-               }
-
-               struct ev_check
-               {
-                       mixin EV_WATCHER!(ev_check);
-               }
-
-               version (EV_FORK_ENABLE)
-               {
-                       struct ev_fork
-                       {
-                               mixin EV_WATCHER!(ev_fork);
-                       }
-               }
-
-               version (EV_EMBED_ENABLE)
-               {
-                       struct ev_embed
-                       {
-                               mixin EV_WATCHER!(ev_embed);
-                               ev_loop_t* other;     // ro
-                               ev_io io;             // private
-                               ev_prepare prepare;   // private
-                               ev_check check;       // unused
-                               ev_timer timer;       // unused
-                               ev_periodic periodic; // unused
-                               ev_idle idle;         // unused
-                               ev_fork fork;         // unused
-                       }
-               }
-       }
+struct ev_watcher_list
+{
+       mixin EV_WATCHER_LIST!(ev_watcher_list);
+}

 
 

-       int ev_version_major();
-       int ev_version_minor();
-
-       uint ev_supported_backends();
-       uint ev_recommended_backends();
-       uint ev_embeddable_backends();
-
-       ev_tstamp ev_time();
-       void ev_sleep(ev_tstamp delay); // sleep for a while
-
-       // Sets the allocation function to use, works like realloc.
-       // It is used to allocate and free memory.
-       // If it returns zero when memory needs to be allocated, the library
-       // might abort
-       // or take some potentially destructive action.
-       // The default is your system realloc function.
-       void ev_set_allocator(void* function(void* ptr, int size));
-
-       // set the callback function to call on a
-       // retryable syscall error
-       // (such as failed select, poll, epoll_wait)
-       void ev_set_syserr_cb(void* function(char* msg));
-
-       extern ev_loop_t* ev_default_loop_ptr;
-
-       ev_loop_t* ev_default_loop_init(uint flags);
-
-       // create and destroy alternative loops that don't handle signals
-       ev_loop_t* ev_loop_new(uint flags);
-       void ev_loop_destroy(ev_loop_t*);
-       void ev_loop_fork(ev_loop_t*);
-
-       ev_tstamp ev_now(ev_loop_t*);
-       void ev_default_destroy();
-       void ev_default_fork();
-       uint ev_backend(ev_loop_t*);
-       uint ev_loop_count(ev_loop_t*);
-       void ev_loop(ev_loop_t*, int flags);
-       void ev_unloop(ev_loop_t*, how);
-       void ev_set_io_collect_interval(ev_loop_t*, ev_tstamp interval);
-       void ev_set_timeout_collect_interval(ev_loop_t*, ev_tstamp interval);
-       void ev_ref(ev_loop_t*);
-       void ev_unref(ev_loop_t*);
-       void ev_once(ev_loop_t*, int fd, int events, ev_tstamp timeout,
-                       void function(int revents, void* arg), void* arg);
-
-       void ev_feed_event(ev_loop_t*, void *w, int revents);
-       void ev_feed_fd_event(ev_loop_t*, int fd, int revents);
-       void ev_feed_signal_event (ev_loop_t*, int signum);
-       void ev_invoke(ev_loop_t*, void *w, int revents);
-       int  ev_clear_pending(ev_loop_t*, void *w);
-
-       void ev_io_start(ev_loop_t*, ev_io *w);
-       void ev_io_stop(ev_loop_t*, ev_io *w);
-
-       void ev_timer_start(ev_loop_t*, ev_timer *w);
-       void ev_timer_stop(ev_loop_t*, ev_timer *w);
-       void ev_timer_again(ev_loop_t*, ev_timer *w);
-
-       version (EV_PERIODIC_ENABLE)
-       {
-               void ev_periodic_start(ev_loop_t*, ev_periodic *w);
-               void ev_periodic_stop(ev_loop_t*, ev_periodic *w);
-               void ev_periodic_again(ev_loop_t*, ev_periodic *w);
-       }
+struct ev_watcher_time
+{
+       mixin EV_WATCHER_TIME!(ev_watcher_time);
+}

 
 

-       void ev_signal_start(ev_loop_t*, ev_signal *w);
-       void ev_signal_stop(ev_loop_t*, ev_signal *w);
+struct ev_io
+{
+       mixin EV_WATCHER_LIST!(ev_io);
+       int fd;     // ro
+       int events; // ro
+}

 
 

-       /* only supported in the default loop */
-       void ev_child_start(ev_loop_t*, ev_child *w);
-       void ev_child_stop(ev_loop_t*, ev_child *w);
+struct ev_timer
+{
+       mixin EV_WATCHER_TIME!(ev_timer);
+       ev_tstamp repeat; // rw
+}

 
 

-       version (EV_STAT_ENABLE)
+version (EV_PERIODIC_ENABLE)
+{
+       struct ev_periodic

        {
        {

-               void ev_stat_start(ev_loop_t*, ev_stat *w);
-               void ev_stat_stop(ev_loop_t*, ev_stat *w);
-               void ev_stat_stat(ev_loop_t*, ev_stat *w);
+               mixin EV_WATCHER_TIME!(ev_periodic);
+               ev_tstamp offset;                     // rw
+               ev_tstamp interval;                   // rw
+               ev_tstamp function(ev_periodic *w,
+                               ev_tstamp now) reschedule_cb; // rw

        }
        }

+}

 
 

-       version (EV_IDLE_ENABLE)
-       {
-               void ev_idle_start(ev_loop_t*, ev_idle *w);
-               void ev_idle_stop(ev_loop_t*, ev_idle *w);
-       }
+struct ev_signal
+{
+       mixin EV_WATCHER_LIST!(ev_signal);
+       int signum; // ro
+}

 
 

-       void ev_prepare_start(ev_loop_t*, ev_prepare *w);
-       void ev_prepare_stop(ev_loop_t*, ev_prepare *w);
+struct ev_child
+{
+       mixin EV_WATCHER_LIST!(ev_child);
+       int pid;     // ro
+       int rpid;    // rw, holds the received pid
+       int rstatus; // rw, holds the exit status, use the
+       // macros from sys/wait.h
+}

 
 

-       void ev_check_start(ev_loop_t*, ev_check *w);
-       void ev_check_stop(ev_loop_t*, ev_check *w);
+version (EV_STAT_ENABLE)
+{

 
 

-       version (EV_FORK_ENABLE)
+       version (Windows) // alias _stati64 ev_statdata;

        {
        {

-               void ev_fork_start(ev_loop_t*, ev_fork *w);
-               void ev_fork_stop(ev_loop_t*, ev_fork *w);
+               pragma (msg, "ev_stat not supported in windows "
+                               "because I don't know the "
+                               "layout of _stati64");
+               static assert(0);
+               // Maybe this should work?
+               //static import stat = std.c.windows.stat;
+               //alias stat.struct_stat ev_statdata;

        }
        }

-
-       version (EV_EMBED_ENABLE)
+       else // It should be POSIX

        {
        {

-               // only supported when loop to be embedded is in fact embeddable
-               void ev_embed_start(ev_loop_t*, ev_embed *w);
-               void ev_embed_stop(ev_loop_t*, ev_embed *w);
-               void ev_embed_sweep(ev_loop_t*, ev_embed *w);
+               static import stat = std.c.unix.unix;
+               alias stat.struct_stat ev_statdata;

        }
 
        }
 

-       bool ev_is_pending(TYPE)(TYPE* w)
+       struct ev_stat

        {
        {

-               return w.pending;
-       }
+               mixin EV_WATCHER_LIST!(ev_stat);

 
 

-       bool ev_is_active(TYPE)(TYPE* w)
-       {
-               return w.active;
+               ev_timer timer;     // private
+               ev_tstamp interval; // ro
+               const char *path;   // ro
+               ev_statdata prev;   // ro
+               ev_statdata attr;   // ro
+               int wd; // wd for inotify, fd for kqueue

        }
        }

+}

 
 

-       int ev_priority(TYPE)(TYPE* w)
+version (EV_IDLE_ENABLE)
+{
+       struct ev_idle

        {
        {

-               return w.priority;
+               mixin EV_WATCHER!(ev_idle);

        }
        }

+}

 
 

-       void function(ev_loop_t*, TYPE*, int) ev_cb(TYPE)(TYPE* w)
-       {
-               return w.cb;
-       }
+struct ev_prepare
+{
+       mixin EV_WATCHER!(ev_prepare);
+}

 
 

-       void ev_set_priority(TYPE)(TYPE* w, int pri)
-       {
-               w.priority = pri;
-       }
+struct ev_check
+{
+       mixin EV_WATCHER!(ev_check);
+}

 
 

-       void ev_set_cb(TYPE)(TYPE* w,
-                       void function(ev_loop_t*, TYPE*, int) cb)
+version (EV_FORK_ENABLE)
+{
+       struct ev_fork

        {
        {

-               w.cb = cb;
+               mixin EV_WATCHER!(ev_fork);

        }
        }

+}

 
 

-       void ev_init(TYPE)(TYPE* w,
-                       void function(ev_loop_t*, TYPE*, int) cb)
-       {
-               w.active = 0;
-               w.pending = 0;
-               w.priority = 0;
-               ev_set_cb(w, cb);
+version (EV_EMBED_ENABLE)
+{
+       struct ev_embed
+       {
+               mixin EV_WATCHER!(ev_embed);
+               ev_loop_t* other;     // ro
+               ev_io io;             // private
+               ev_prepare prepare;   // private
+               ev_check check;       // unused
+               ev_timer timer;       // unused
+               ev_periodic periodic; // unused
+               ev_idle idle;         // unused
+               ev_fork fork;         // unused

        }
        }

+}

 
 

-       void ev_io_set(ev_io* w, int fd, int events)
-       {
-               w.fd = fd;
-               w.events = events | IOFDSET;
-       }
+int ev_version_major();
+int ev_version_minor();
+
+uint ev_supported_backends();
+uint ev_recommended_backends();
+uint ev_embeddable_backends();
+
+ev_tstamp ev_time();
+void ev_sleep(ev_tstamp delay); // sleep for a while
+
+// Sets the allocation function to use, works like realloc.
+// It is used to allocate and free memory.
+// If it returns zero when memory needs to be allocated, the library
+// might abort
+// or take some potentially destructive action.
+// The default is your system realloc function.
+void ev_set_allocator(void* function(void* ptr, int size));
+
+// set the callback function to call on a
+// retryable syscall error
+// (such as failed select, poll, epoll_wait)
+void ev_set_syserr_cb(void* function(char* msg));
+
+extern ev_loop_t* ev_default_loop_ptr;
+
+ev_loop_t* ev_default_loop_init(uint flags);
+
+// create and destroy alternative loops that don't handle signals
+ev_loop_t* ev_loop_new(uint flags);
+void ev_loop_destroy(ev_loop_t*);
+void ev_loop_fork(ev_loop_t*);
+
+ev_tstamp ev_now(ev_loop_t*);
+void ev_default_destroy();
+void ev_default_fork();
+uint ev_backend(ev_loop_t*);
+uint ev_loop_count(ev_loop_t*);
+void ev_loop(ev_loop_t*, int flags);
+void ev_unloop(ev_loop_t*, how);
+void ev_set_io_collect_interval(ev_loop_t*, ev_tstamp interval);
+void ev_set_timeout_collect_interval(ev_loop_t*, ev_tstamp interval);
+void ev_ref(ev_loop_t*);
+void ev_unref(ev_loop_t*);
+void ev_once(ev_loop_t*, int fd, int events, ev_tstamp timeout,
+               void function(int revents, void* arg), void* arg);
+
+void ev_feed_event(ev_loop_t*, void *w, int revents);
+void ev_feed_fd_event(ev_loop_t*, int fd, int revents);
+void ev_feed_signal_event (ev_loop_t*, int signum);
+void ev_invoke(ev_loop_t*, void *w, int revents);
+int  ev_clear_pending(ev_loop_t*, void *w);
+
+void ev_io_start(ev_loop_t*, ev_io *w);
+void ev_io_stop(ev_loop_t*, ev_io *w);
+
+void ev_timer_start(ev_loop_t*, ev_timer *w);
+void ev_timer_stop(ev_loop_t*, ev_timer *w);
+void ev_timer_again(ev_loop_t*, ev_timer *w);
+
+version (EV_PERIODIC_ENABLE)
+{
+       void ev_periodic_start(ev_loop_t*, ev_periodic *w);
+       void ev_periodic_stop(ev_loop_t*, ev_periodic *w);
+       void ev_periodic_again(ev_loop_t*, ev_periodic *w);
+}

 
 

-       void ev_timer_set(ev_timer* w, ev_tstamp after, ev_tstamp repeat)
-       {
-               w.at = after;
-               w.repeat = repeat;
-       }
+void ev_signal_start(ev_loop_t*, ev_signal *w);
+void ev_signal_stop(ev_loop_t*, ev_signal *w);

 
 

-       void ev_periodic_set(ev_periodic* w, ev_tstamp ofs, ev_tstamp ival,
-                       ev_tstamp function(ev_periodic *w, ev_tstamp now) res)
-       {
-               w.offset = ofs;
-               w.interval = ival;
-               w.reschedule_cb = res;
-       }
+/* only supported in the default loop */
+void ev_child_start(ev_loop_t*, ev_child *w);
+void ev_child_stop(ev_loop_t*, ev_child *w);

 
 

-       void ev_signal_set(ev_signal* w, int signum)
-       {
-               w.signum = signum;
-       }
+version (EV_STAT_ENABLE)
+{
+       void ev_stat_start(ev_loop_t*, ev_stat *w);
+       void ev_stat_stop(ev_loop_t*, ev_stat *w);
+       void ev_stat_stat(ev_loop_t*, ev_stat *w);
+}

 
 

-       void ev_child_set(ev_child* w, int pid)
-       {
-               w.pid = pid;
-       }
+version (EV_IDLE_ENABLE)
+{
+       void ev_idle_start(ev_loop_t*, ev_idle *w);
+       void ev_idle_stop(ev_loop_t*, ev_idle *w);
+}

 
 

-       void ev_stat_set(ev_stat* w, char* path, ev_tstamp interval)
-       {
-               w.path = path;
-               w.interval = interval;
-               w.wd = -2;
-       }
+void ev_prepare_start(ev_loop_t*, ev_prepare *w);
+void ev_prepare_stop(ev_loop_t*, ev_prepare *w);

 
 

-       void ev_idle_set(ev_idle* w)
-       {
-       }
+void ev_check_start(ev_loop_t*, ev_check *w);
+void ev_check_stop(ev_loop_t*, ev_check *w);

 
 

-       void ev_prepare_set(ev_prepare* w)
-       {
-       }
+version (EV_FORK_ENABLE)
+{
+       void ev_fork_start(ev_loop_t*, ev_fork *w);
+       void ev_fork_stop(ev_loop_t*, ev_fork *w);
+}

 
 

-       void ev_check_set(ev_check* w)
-       {
-       }
+version (EV_EMBED_ENABLE)
+{
+       // only supported when loop to be embedded is in fact embeddable
+       void ev_embed_start(ev_loop_t*, ev_embed *w);
+       void ev_embed_stop(ev_loop_t*, ev_embed *w);
+       void ev_embed_sweep(ev_loop_t*, ev_embed *w);
+}

 
 

-       void ev_embed_set(ev_embed* w, ev_loop_t* other)
-       {
-               w.other = other;
-       }
+bool ev_is_pending(TYPE)(TYPE* w)
+{
+       return w.pending;
+}

 
 

-       void ev_fork_set(ev_fork* w)
-       {
-       }
+bool ev_is_active(TYPE)(TYPE* w)
+{
+       return w.active;
+}

 
 

-       void ev_io_init(ev_io* w, void function(ev_loop_t*, ev_io*, int) cb, int fd,
-                       int events)
-       {
-               ev_init(w, cb);
-               ev_io_set(w, fd, events);
-       }
+int ev_priority(TYPE)(TYPE* w)
+{
+       return w.priority;
+}

 
 

-       void ev_timer_init(ev_timer* w, void function(ev_loop_t*, ev_timer*, int) cb,
-                       ev_tstamp after, ev_tstamp repeat)
-       {
-               ev_init(w, cb);
-               ev_timer_set(w, after, repeat);
-       }
+void function(ev_loop_t*, TYPE*, int) ev_cb(TYPE)(TYPE* w)
+{
+       return w.cb;
+}

 
 

-       void ev_periodic_init(ev_periodic* w,
-                       void function(ev_loop_t*, ev_periodic*, int) cb,
-                       ev_tstamp ofs, ev_tstamp ival,
-                       ev_tstamp function(ev_periodic *w, ev_tstamp now) res)
-       {
-               ev_init(w, cb);
-               ev_periodic_set(w, ofs, ival, res);
-       }
+void ev_set_priority(TYPE)(TYPE* w, int pri)
+{
+       w.priority = pri;
+}

 
 

-       void ev_signal_init(ev_signal* w, void function(ev_loop_t*, ev_signal*, int) cb,
-                       int signum)
-       {
-               ev_init(w, cb);
-               ev_signal_set(w, signum);
-       }
+void ev_set_cb(TYPE)(TYPE* w,
+               void function(ev_loop_t*, TYPE*, int) cb)
+{
+       w.cb = cb;
+}

 
 

-       void ev_child_init(ev_child* w, void function(ev_loop_t*, ev_child*, int) cb,
-                       int pid)
-       {
-               ev_init(w, cb);
-               ev_child_set(w, pid);
-       }
+void ev_init(TYPE)(TYPE* w,
+               void function(ev_loop_t*, TYPE*, int) cb)
+{
+       w.active = 0;
+       w.pending = 0;
+       w.priority = 0;
+       ev_set_cb(w, cb);
+}

 
 

-       void ev_stat_init(ev_stat* w, void function(ev_loop_t*, ev_stat*, int) cb,
-                       char* path, ev_tstamp interval)
-       {
-               ev_init(w, cb);
-               ev_stat_set(w, path, interval);
-       }
+void ev_io_set(ev_io* w, int fd, int events)
+{
+       w.fd = fd;
+       w.events = events | IOFDSET;
+}

 
 

-       void ev_idle_init(ev_idle* w, void function(ev_loop_t*, ev_idle*, int) cb)
-       {
-               ev_init(w, cb);
-               ev_idle_set(w);
-       }
+void ev_timer_set(ev_timer* w, ev_tstamp after, ev_tstamp repeat)
+{
+       w.at = after;
+       w.repeat = repeat;
+}

 
 

-       void ev_prepare_init(ev_prepare* w,
-                       void function(ev_loop_t*, ev_prepare*, int) cb)
-       {
-               ev_init(w, cb);
-               ev_prepare_set(w);
-       }
+void ev_periodic_set(ev_periodic* w, ev_tstamp ofs, ev_tstamp ival,
+               ev_tstamp function(ev_periodic *w, ev_tstamp now) res)
+{
+       w.offset = ofs;
+       w.interval = ival;
+       w.reschedule_cb = res;
+}

 
 

-       void ev_check_init(ev_check* w, void function(ev_loop_t*, ev_check*, int) cb)
-       {
-               ev_init(w, cb);
-               ev_check_set(w);
-       }
+void ev_signal_set(ev_signal* w, int signum)
+{
+       w.signum = signum;
+}

 
 

-       void ev_embed_init(ev_embed* w, void function(ev_loop_t*, ev_embed*, int) cb,
-                       ev_loop_t* other)
-       {
-               ev_init(w, cb);
-               ev_embed_set(w, other);
-       }
+void ev_child_set(ev_child* w, int pid)
+{
+       w.pid = pid;
+}

 
 

-       void ev_fork_init(ev_fork* w, void function(ev_loop_t*, ev_fork*, int) cb)
-       {
-               ev_init(w, cb);
-               ev_fork_set(w);
-       }
+void ev_stat_set(ev_stat* w, char* path, ev_tstamp interval)
+{
+       w.path = path;
+       w.interval = interval;
+       w.wd = -2;
+}

 
 

-       ev_loop_t* ev_default_loop(uint flags = AUTO)
-       {
-               if (!ev_default_loop_ptr)
-                       ev_default_loop_init(flags);
-               return ev_default_loop_ptr;
-       }
+void ev_idle_set(ev_idle* w)
+{
+}
+
+void ev_prepare_set(ev_prepare* w)
+{
+}
+
+void ev_check_set(ev_check* w)
+{
+}
+
+void ev_embed_set(ev_embed* w, ev_loop_t* other)
+{
+       w.other = other;
+}
+
+void ev_fork_set(ev_fork* w)
+{
+}
+
+void ev_io_init(ev_io* w, void function(ev_loop_t*, ev_io*, int) cb, int fd,
+               int events)
+{
+       ev_init(w, cb);
+       ev_io_set(w, fd, events);
+}
+
+void ev_timer_init(ev_timer* w, void function(ev_loop_t*, ev_timer*, int) cb,
+               ev_tstamp after, ev_tstamp repeat)
+{
+       ev_init(w, cb);
+       ev_timer_set(w, after, repeat);
+}
+
+void ev_periodic_init(ev_periodic* w,
+               void function(ev_loop_t*, ev_periodic*, int) cb,
+               ev_tstamp ofs, ev_tstamp ival,
+               ev_tstamp function(ev_periodic *w, ev_tstamp now) res)
+{
+       ev_init(w, cb);
+       ev_periodic_set(w, ofs, ival, res);
+}
+
+void ev_signal_init(ev_signal* w, void function(ev_loop_t*, ev_signal*, int) cb,
+               int signum)
+{
+       ev_init(w, cb);
+       ev_signal_set(w, signum);
+}

 
 

+void ev_child_init(ev_child* w, void function(ev_loop_t*, ev_child*, int) cb,
+               int pid)
+{
+       ev_init(w, cb);
+       ev_child_set(w, pid);

 }
 
 }
 

+void ev_stat_init(ev_stat* w, void function(ev_loop_t*, ev_stat*, int) cb,
+               char* path, ev_tstamp interval)
+{
+       ev_init(w, cb);
+       ev_stat_set(w, path, interval);
+}
+
+void ev_idle_init(ev_idle* w, void function(ev_loop_t*, ev_idle*, int) cb)
+{
+       ev_init(w, cb);
+       ev_idle_set(w);
+}
+
+void ev_prepare_init(ev_prepare* w,
+               void function(ev_loop_t*, ev_prepare*, int) cb)
+{
+       ev_init(w, cb);
+       ev_prepare_set(w);
+}
+
+void ev_check_init(ev_check* w, void function(ev_loop_t*, ev_check*, int) cb)
+{
+       ev_init(w, cb);
+       ev_check_set(w);
+}
+
+void ev_embed_init(ev_embed* w, void function(ev_loop_t*, ev_embed*, int) cb,
+               ev_loop_t* other)
+{
+       ev_init(w, cb);
+       ev_embed_set(w, other);
+}
+
+void ev_fork_init(ev_fork* w, void function(ev_loop_t*, ev_fork*, int) cb)
+{
+       ev_init(w, cb);
+       ev_fork_set(w);
+}
+
+ev_loop_t* ev_default_loop(uint flags = AUTO)
+{
+       if (!ev_default_loop_ptr)
+               ev_default_loop_init(flags);
+       return ev_default_loop_ptr;
+}
+
+