[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.331 by root, Tue Mar 9 08:55:03 2010 UTC vs.
Revision 1.370 by root, Sun Jan 30 19:05:41 2011 UTC

 /*
  * libev event processing core, watcher management
  *
- * Copyright (c) 2007,2008,2009,2010 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
  * tion, are permitted provided that the following conditions are met:
  *
  * and other provisions required by the GPL. If you do not delete the
  * provisions above, a recipient may use your version of this file under
  * either the BSD or the GPL.
  */
-#ifdef __cplusplus
-extern "C" {
-#endif
 /* this big block deduces configuration from config.h */
 #ifndef EV_STANDALONE
 # ifdef EV_CONFIG_H
 #  include EV_CONFIG_H
 # else
 #  ifndef EV_USE_REALTIME
 #   define EV_USE_REALTIME  0
 #  endif
 # endif
+# if HAVE_NANOSLEEP
-# ifndef EV_USE_NANOSLEEP
+#  ifndef EV_USE_NANOSLEEP
-#  if HAVE_NANOSLEEP
-#   define EV_USE_NANOSLEEP 1
+#    define EV_USE_NANOSLEEP EV_FEATURE_OS
+#  endif
-#  else
+# else
+#   undef EV_USE_NANOSLEEP
 #   define EV_USE_NANOSLEEP 0
+# endif
+# if HAVE_SELECT && HAVE_SYS_SELECT_H
+#  ifndef EV_USE_SELECT
+#   define EV_USE_SELECT EV_FEATURE_BACKENDS
 #  endif
+# else
+#  undef EV_USE_SELECT
+#  define EV_USE_SELECT 0
 # endif
+# if HAVE_POLL && HAVE_POLL_H
-# ifndef EV_USE_SELECT
+#  ifndef EV_USE_POLL
-#  if HAVE_SELECT && HAVE_SYS_SELECT_H
+#   define EV_USE_POLL EV_FEATURE_BACKENDS
-#   define EV_USE_SELECT 1
-#  else
-#   define EV_USE_SELECT 0
 #  endif
-# endif
-# ifndef EV_USE_POLL
-#  if HAVE_POLL && HAVE_POLL_H
-#   define EV_USE_POLL 1
-#  else
+# else
+#  undef EV_USE_POLL
-#   define EV_USE_POLL 0
+#  define EV_USE_POLL 0
-#  endif
 # endif
-# ifndef EV_USE_EPOLL
-#  if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
+# if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
-#   define EV_USE_EPOLL 1
+#  ifndef EV_USE_EPOLL
-#  else
+#   define EV_USE_EPOLL EV_FEATURE_BACKENDS
-#   define EV_USE_EPOLL 0
 #  endif
+# else
+#  undef EV_USE_EPOLL
+#  define EV_USE_EPOLL 0
 # endif
-# ifndef EV_USE_KQUEUE
-#  if HAVE_KQUEUE && HAVE_SYS_EVENT_H
+# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
-#   define EV_USE_KQUEUE 1
+#  ifndef EV_USE_KQUEUE
-#  else
+#   define EV_USE_KQUEUE EV_FEATURE_BACKENDS
-#   define EV_USE_KQUEUE 0
 #  endif
+# else
+#  undef EV_USE_KQUEUE
+#  define EV_USE_KQUEUE 0
 # endif
-# ifndef EV_USE_PORT
-#  if HAVE_PORT_H && HAVE_PORT_CREATE
+# if HAVE_PORT_H && HAVE_PORT_CREATE
-#   define EV_USE_PORT 1
+#  ifndef EV_USE_PORT
-#  else
+#   define EV_USE_PORT EV_FEATURE_BACKENDS
-#   define EV_USE_PORT 0
 #  endif
+# else
+#  undef EV_USE_PORT
+#  define EV_USE_PORT 0
 # endif
-# ifndef EV_USE_INOTIFY
-#  if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
+# if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
-#   define EV_USE_INOTIFY 1
+#  ifndef EV_USE_INOTIFY
-#  else
-#   define EV_USE_INOTIFY 0
+#   define EV_USE_INOTIFY EV_FEATURE_OS
 #  endif
+# else
+#  undef EV_USE_INOTIFY
+#  define EV_USE_INOTIFY 0
 # endif
-# ifndef EV_USE_SIGNALFD
-#  if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
+# if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
-#   define EV_USE_SIGNALFD 1
+#  ifndef EV_USE_SIGNALFD
-#  else
-#   define EV_USE_SIGNALFD 0
+#   define EV_USE_SIGNALFD EV_FEATURE_OS
 #  endif
+# else
+#  undef EV_USE_SIGNALFD
+#  define EV_USE_SIGNALFD 0
 # endif
+# if HAVE_EVENTFD
-# ifndef EV_USE_EVENTFD
+#  ifndef EV_USE_EVENTFD
-#  if HAVE_EVENTFD
-#   define EV_USE_EVENTFD 1
+#   define EV_USE_EVENTFD EV_FEATURE_OS
-#  else
-#   define EV_USE_EVENTFD 0
 #  endif
+# else
+#  undef EV_USE_EVENTFD
+#  define EV_USE_EVENTFD 0
 # endif
 #endif
 #include <math.h>
 #ifdef EV_H
 # include EV_H
 #else
 # include "ev.h"
 #endif
+EV_CPP(extern "C" {)
 #ifndef _WIN32
 # include <sys/time.h>
 # include <sys/wait.h>
 # include <unistd.h>
 # ifndef EV_SELECT_IS_WINSOCKET
 #  define EV_SELECT_IS_WINSOCKET 1
 # endif
 # undef EV_AVOID_STDIO
 #endif
+/* OS X, in its infinite idiocy, actually HARDCODES
+ * a limit of 1024 into their select. Where people have brains,
+ * OS X engineers apparently have a vacuum. Or maybe they were
+ * ordered to have a vacuum, or they do anything for money.
+ * This might help. Or not.
+ */
+#define _DARWIN_UNLIMITED_SELECT 1
 /* this block tries to deduce configuration from header-defined symbols and defaults */
 /* try to deduce the maximum number of signals on this platform */
 #if defined (EV_NSIG)
 #elif defined (MAXSIG)
 # define EV_NSIG (MAXSIG+1)
 #elif defined (MAX_SIG)
 # define EV_NSIG (MAX_SIG+1)
 #elif defined (SIGARRAYSIZE)
-# define EV_NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */
+# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
 #elif defined (_sys_nsig)
 # define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
 #else
 # error "unable to find value for NSIG, please report"
-/* to make it compile regardless, just remove the above line */
+/* to make it compile regardless, just remove the above line, */
+/* but consider reporting it, too! :) */
 # define EV_NSIG 65
 #endif
 #ifndef EV_USE_CLOCK_SYSCALL
 # if __linux && __GLIBC__ >= 2
-#  define EV_USE_CLOCK_SYSCALL 1
+#  define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
 # else
 #  define EV_USE_CLOCK_SYSCALL 0
 # endif
 #endif
 #ifndef EV_USE_MONOTONIC
 # if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
-#  define EV_USE_MONOTONIC 1
+#  define EV_USE_MONOTONIC EV_FEATURE_OS
 # else
 #  define EV_USE_MONOTONIC 0
 # endif
 #endif
 # define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
 #endif
 #ifndef EV_USE_NANOSLEEP
 # if _POSIX_C_SOURCE >= 199309L
-#  define EV_USE_NANOSLEEP 1
+#  define EV_USE_NANOSLEEP EV_FEATURE_OS
 # else
 #  define EV_USE_NANOSLEEP 0
 # endif
 #endif
 #ifndef EV_USE_SELECT
-# define EV_USE_SELECT 1
+# define EV_USE_SELECT EV_FEATURE_BACKENDS
 #endif
 #ifndef EV_USE_POLL
 # ifdef _WIN32
 #  define EV_USE_POLL 0
 # else
-#  define EV_USE_POLL 1
+#  define EV_USE_POLL EV_FEATURE_BACKENDS
 # endif
 #endif
 #ifndef EV_USE_EPOLL
 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
-#  define EV_USE_EPOLL 1
+#  define EV_USE_EPOLL EV_FEATURE_BACKENDS
 # else
 #  define EV_USE_EPOLL 0
 # endif
 #endif
 # define EV_USE_PORT 0
 #endif
 #ifndef EV_USE_INOTIFY
 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
-#  define EV_USE_INOTIFY 1
+#  define EV_USE_INOTIFY EV_FEATURE_OS
 # else
 #  define EV_USE_INOTIFY 0
 # endif
 #endif
 #ifndef EV_PID_HASHSIZE
-# if EV_MINIMAL
+# define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
-#  define EV_PID_HASHSIZE 1
-# else
-#  define EV_PID_HASHSIZE 16
-# endif
 #endif
 #ifndef EV_INOTIFY_HASHSIZE
-# if EV_MINIMAL
+# define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
-#  define EV_INOTIFY_HASHSIZE 1
-# else
-#  define EV_INOTIFY_HASHSIZE 16
-# endif
 #endif
 #ifndef EV_USE_EVENTFD
 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
-#  define EV_USE_EVENTFD 1
+#  define EV_USE_EVENTFD EV_FEATURE_OS
 # else
 #  define EV_USE_EVENTFD 0
 # endif
 #endif
 #ifndef EV_USE_SIGNALFD
 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
-#  define EV_USE_SIGNALFD 1
+#  define EV_USE_SIGNALFD EV_FEATURE_OS
 # else
 #  define EV_USE_SIGNALFD 0
 # endif
 #endif
 # define EV_USE_4HEAP 1
 # define EV_HEAP_CACHE_AT 1
 #endif
 #ifndef EV_VERIFY
-# define EV_VERIFY !EV_MINIMAL
+# define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
 #endif
 #ifndef EV_USE_4HEAP
-# define EV_USE_4HEAP !EV_MINIMAL
+# define EV_USE_4HEAP EV_FEATURE_DATA
 #endif
 #ifndef EV_HEAP_CACHE_AT
-# define EV_HEAP_CACHE_AT !EV_MINIMAL
+# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
 #endif
 /* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
 /* which makes programs even slower. might work on other unices, too. */
 #if EV_USE_CLOCK_SYSCALL
 # undef EV_USE_INOTIFY
 # define EV_USE_INOTIFY 0
 #endif
 #if !EV_USE_NANOSLEEP
-# ifndef _WIN32
+/* hp-ux has it in sys/time.h, which we unconditionally include above */
+# if !defined(_WIN32) && !defined(__hpux)
 #  include <sys/select.h>
 # endif
 #endif
 #if EV_USE_INOTIFY
-# include <sys/utsname.h>
 # include <sys/statfs.h>
 # include <sys/inotify.h>
 /* some very old inotify.h headers don't have IN_DONT_FOLLOW */
 # ifndef IN_DONT_FOLLOW
 #  undef EV_USE_INOTIFY
 #   define EFD_CLOEXEC O_CLOEXEC
 #  else
 #   define EFD_CLOEXEC 02000000
 #  endif
 # endif
-# ifdef __cplusplus
-extern "C" {
-# endif
-int (eventfd) (unsigned int initval, int flags);
+EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
-# ifdef __cplusplus
-}
-# endif
 #endif
 #if EV_USE_SIGNALFD
 /* our minimum requirement is glibc 2.7 which has the stub, but not the header */
 # include <stdint.h>
 #   define SFD_CLOEXEC O_CLOEXEC
 #  else
 #   define SFD_CLOEXEC 02000000
 #  endif
 # endif
-# ifdef __cplusplus
-extern "C" {
-# endif
-int signalfd (int fd, const sigset_t *mask, int flags);
+EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);
 struct signalfd_siginfo
 {
   uint32_t ssi_signo;
   char pad[128 - sizeof (uint32_t)];
 };
-# ifdef __cplusplus
-}
-# endif
+#endif
-#endif
 /**/
 #if EV_VERIFY >= 3
-# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
+# define EV_FREQUENT_CHECK ev_verify (EV_A)
 #else
 # define EV_FREQUENT_CHECK do { } while (0)
 #endif
 /*
 #define TIME_EPSILON  0.0001220703125 /* 1/8192 */
 #define MIN_TIMEJUMP  1. /* minimum timejump that gets detected (if monotonic clock available) */
 #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
+#define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
+#define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
 #if __GNUC__ >= 4
 # define expect(expr,value)         __builtin_expect ((expr),(value))
 # define noinline                   __attribute__ ((noinline))
 #else
 # define expect(expr,value)         (expr)
 #define expect_false(expr) expect ((expr) != 0, 0)
 #define expect_true(expr)  expect ((expr) != 0, 1)
 #define inline_size        static inline
-#if EV_MINIMAL
+#if EV_FEATURE_CODE
+# define inline_speed      static inline
+#else
 # define inline_speed      static noinline
-#else
-# define inline_speed      static inline
 #endif
 #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
 #if EV_MINPRI == EV_MAXPRI
 #define ev_active(w) ((W)(w))->active
 #define ev_at(w) ((WT)(w))->at
 #if EV_USE_REALTIME
 /* sig_atomic_t is used to avoid per-thread variables or locking but still */
-/* giving it a reasonably high chance of working on typical architetcures */
+/* giving it a reasonably high chance of working on typical architectures */
 static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */
 #endif
 #if EV_USE_MONOTONIC
 static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 #endif
 #ifdef _WIN32
 # include "ev_win32.c"
 #endif
+/*****************************************************************************/
+#ifdef __linux
+# include <sys/utsname.h>
+#endif
+static unsigned int noinline
+ev_linux_version (void)
+{
+#ifdef __linux
+  unsigned int v = 0;
+  struct utsname buf;
+  int i;
+  char *p = buf.release;
+  if (uname (&buf))
+    return 0;
+  for (i = 3+1; --i; )
+    {
+      unsigned int c = 0;
+      for (;;)
+        {
+          if (*p >= '0' && *p <= '9')
+            c = c * 10 + *p++ - '0';
+          else
+            {
+              p += *p == '.';
+              break;
+            }
+        }
+      v = (v << 8) | c;
+    }
+  return v;
+#else
+  return 0;
+#endif
+}
 /*****************************************************************************/
 #if EV_AVOID_STDIO
 static void noinline
   if (syserr_cb)
     syserr_cb (msg);
   else
     {
 #if EV_AVOID_STDIO
-      const char *err = strerror (errno);
       ev_printerr (msg);
       ev_printerr (": ");
-      ev_printerr (err);
+      ev_printerr (strerror (errno));
       ev_printerr ("\n");
 #else
       perror (msg);
 #endif
       abort ();
 }
 static void *
 ev_realloc_emul (void *ptr, long size)
 {
+#if __GLIBC__
+  return realloc (ptr, size);
+#else
   /* some systems, notably openbsd and darwin, fail to properly
-   * implement realloc (x, 0) (as required by both ansi c-98 and
+   * implement realloc (x, 0) (as required by both ansi c-89 and
    * the single unix specification, so work around them here.
    */
   if (size)
     return realloc (ptr, size);
   free (ptr);
   return 0;
+#endif
 }
 static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
 void
   ptr = alloc (ptr, size);
   if (!ptr && size)
     {
 #if EV_AVOID_STDIO
-      ev_printerr ("libev: memory allocation failed, aborting.\n");
+      ev_printerr ("(libev) memory allocation failed, aborting.\n");
 #else
-      fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
+      fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size);
 #endif
       abort ();
     }
   return ptr;
   unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */
   unsigned char unused;
 #if EV_USE_EPOLL
   unsigned int egen;    /* generation counter to counter epoll bugs */
 #endif
-#if EV_SELECT_IS_WINSOCKET
+#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
   SOCKET handle;
+#endif
+#if EV_USE_IOCP
+  OVERLAPPED or, ow;
 #endif
 } ANFD;
 /* stores the pending event set for a given watcher */
 typedef struct
   static int ev_default_loop_ptr;
 #endif
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
 # define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
 # define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
 # define EV_INVOKE_PENDING invoke_cb (EV_A)
 #else
 # define EV_RELEASE_CB (void)0
 # define EV_ACQUIRE_CB (void)0
 # define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
 #endif
-#define EVUNLOOP_RECURSE 0x80
+#define EVBREAK_RECURSE 0x80
 /*****************************************************************************/
 #ifndef EV_HAVE_EV_TIME
 ev_tstamp
   if (delay > 0.)
     {
 #if EV_USE_NANOSLEEP
       struct timespec ts;
-      ts.tv_sec  = (time_t)delay;
+      EV_TS_SET (ts, delay);
-      ts.tv_nsec = (long)((delay - (ev_tstamp)(ts.tv_sec)) * 1e9);
       nanosleep (&ts, 0);
 #elif defined(_WIN32)
       Sleep ((unsigned long)(delay * 1e3));
 #else
       struct timeval tv;
-      tv.tv_sec  = (time_t)delay;
-      tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
       /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
       /* something not guaranteed by newer posix versions, but guaranteed */
       /* by older ones */
+      EV_TV_SET (tv, delay);
       select (0, 0, 0, 0, &tv);
 #endif
     }
 }
+inline_speed int
+ev_timeout_to_ms (ev_tstamp timeout)
+{
+  int ms = timeout * 1000. + .999999;
+  return expect_true (ms) ? ms : timeout < 1e-6 ? 0 : 1;
+}
 /*****************************************************************************/
 #define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
 /* find a suitable new size for the given array, */
-/* hopefully by rounding to a ncie-to-malloc size */
+/* hopefully by rounding to a nice-to-malloc size */
 inline_size int
 array_nextsize (int elem, int cur, int cnt)
 {
   int ncur = cur + 1;
 }
 /*****************************************************************************/
 inline_speed void
-fd_event_nc (EV_P_ int fd, int revents)
+fd_event_nocheck (EV_P_ int fd, int revents)
 {
   ANFD *anfd = anfds + fd;
   ev_io *w;
   for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
 fd_event (EV_P_ int fd, int revents)
 {
   ANFD *anfd = anfds + fd;
   if (expect_true (!anfd->reify))
-    fd_event_nc (EV_A_ fd, revents);
+    fd_event_nocheck (EV_A_ fd, revents);
 }
 void
 ev_feed_fd_event (EV_P_ int fd, int revents)
 {
   if (fd >= 0 && fd < anfdmax)
-    fd_event_nc (EV_A_ fd, revents);
+    fd_event_nocheck (EV_A_ fd, revents);
 }
 /* make sure the external fd watch events are in-sync */
 /* with the kernel/libev internal state */
 inline_size void
     {
       int fd = fdchanges [i];
       ANFD *anfd = anfds + fd;
       ev_io *w;
-      unsigned char events = 0;
+      unsigned char o_events = anfd->events;
+      unsigned char o_reify  = anfd->reify;
-      for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
+      anfd->reify  = 0;
-        events |= (unsigned char)w->events;
-#if EV_SELECT_IS_WINSOCKET
+#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
-      if (events)
+      if (o_reify & EV__IOFDSET)
         {
           unsigned long arg;
           anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
           assert (("libev: only socket fds supported in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
+          printf ("oi %d %x\n", fd, anfd->handle);//D
         }
 #endif
+      /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
-      {
+        {
-        unsigned char o_events = anfd->events;
-        unsigned char o_reify  = anfd->reify;
-        anfd->reify  = 0;
-        anfd->events = events;
+          anfd->events = 0;
-        if (o_events != events || o_reify & EV__IOFDSET)
+          for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
+            anfd->events |= (unsigned char)w->events;
+          if (o_events != anfd->events)
+            o_reify = EV__IOFDSET; /* actually |= */
+        }
+      if (o_reify & EV__IOFDSET)
-          backend_modify (EV_A_ fd, o_events, events);
+        backend_modify (EV_A_ fd, o_events, anfd->events);
-      }
     }
   fdchangecnt = 0;
 }
       ev_io_stop (EV_A_ w);
       ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
     }
 }
-/* check whether the given fd is atcually valid, for error recovery */
+/* check whether the given fd is actually valid, for error recovery */
 inline_size int
 fd_valid (int fd)
 {
 #ifdef _WIN32
   return EV_FD_TO_WIN32_HANDLE (fd) != -1;
         anfds [fd].emask  = 0;
         fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
       }
 }
+/* used to prepare libev internal fd's */
+/* this is not fork-safe */
+inline_speed void
+fd_intern (int fd)
+{
+#ifdef _WIN32
+  unsigned long arg = 1;
+  ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
+#else
+  fcntl (fd, F_SETFD, FD_CLOEXEC);
+  fcntl (fd, F_SETFL, O_NONBLOCK);
+#endif
+}
 /*****************************************************************************/
 /*
- * the heap functions want a real array index. array index 0 uis guaranteed to not
+ * the heap functions want a real array index. array index 0 is guaranteed to not
  * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
  * the branching factor of the d-tree.
  */
 /*
 static ANSIG signals [EV_NSIG - 1];
 /*****************************************************************************/
-/* used to prepare libev internal fd's */
+#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
-/* this is not fork-safe */
-inline_speed void
-fd_intern (int fd)
-{
-#ifdef _WIN32
-  unsigned long arg = 1;
-  ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
-#else
-  fcntl (fd, F_SETFD, FD_CLOEXEC);
-  fcntl (fd, F_SETFL, O_NONBLOCK);
-#endif
-}
 static void noinline
 evpipe_init (EV_P)
 {
   if (!ev_is_active (&pipe_w))
     {
-#if EV_USE_EVENTFD
+# if EV_USE_EVENTFD
       evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
       if (evfd < 0 && errno == EINVAL)
         evfd = eventfd (0, 0);
       if (evfd >= 0)
           evpipe [0] = -1;
           fd_intern (evfd); /* doing it twice doesn't hurt */
           ev_io_set (&pipe_w, evfd, EV_READ);
         }
       else
-#endif
+# endif
         {
           while (pipe (evpipe))
             ev_syserr ("(libev) error creating signal/async pipe");
           fd_intern (evpipe [0]);
 evpipe_write (EV_P_ EV_ATOMIC_T *flag)
 {
   if (!*flag)
     {
       int old_errno = errno; /* save errno because write might clobber it */
+      char dummy;
       *flag = 1;
 #if EV_USE_EVENTFD
       if (evfd >= 0)
           uint64_t counter = 1;
           write (evfd, &counter, sizeof (uint64_t));
         }
       else
 #endif
+        /* win32 people keep sending patches that change this write() to send() */
+        /* and then run away. but send() is wrong, it wants a socket handle on win32 */
+        /* so when you think this write should be a send instead, please find out */
+        /* where your send() is from - it's definitely not the microsoft send, and */
+        /* tell me. thank you. */
-        write (evpipe [1], &old_errno, 1);
+        write (evpipe [1], &dummy, 1);
       errno = old_errno;
     }
 }
     }
   else
 #endif
     {
       char dummy;
+      /* see discussion in evpipe_write when you think this read should be recv in win32 */
       read (evpipe [0], &dummy, 1);
     }
+#if EV_SIGNAL_ENABLE
   if (sig_pending)
     {
       sig_pending = 0;
       for (i = EV_NSIG - 1; i--; )
         if (expect_false (signals [i].pending))
           ev_feed_signal_event (EV_A_ i + 1);
     }
+#endif
 #if EV_ASYNC_ENABLE
   if (async_pending)
     {
       async_pending = 0;
 #endif
 }
 /*****************************************************************************/
+void
+ev_feed_signal (int signum)
+{
+#if EV_MULTIPLICITY
+  EV_P = signals [signum - 1].loop;
+  if (!EV_A)
+    return;
+#endif
+  signals [signum - 1].pending = 1;
+  evpipe_write (EV_A_ &sig_pending);
+}
 static void
 ev_sighandler (int signum)
 {
-#if EV_MULTIPLICITY
-  EV_P = signals [signum - 1].loop;
-#endif
 #ifdef _WIN32
   signal (signum, ev_sighandler);
 #endif
-  signals [signum - 1].pending = 1;
+  ev_feed_signal (signum);
-  evpipe_write (EV_A_ &sig_pending);
 }
 void noinline
 ev_feed_signal_event (EV_P_ int signum)
 {
         break;
     }
 }
 #endif
+#endif
 /*****************************************************************************/
+#if EV_CHILD_ENABLE
 static WL childs [EV_PID_HASHSIZE];
-#ifndef _WIN32
 static ev_signal childev;
 #ifndef WIFCONTINUED
 # define WIFCONTINUED(status) 0
 child_reap (EV_P_ int chain, int pid, int status)
 {
   ev_child *w;
   int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
-  for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
+  for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
     {
       if ((w->pid == pid || !w->pid)
           && (!traced || (w->flags & 1)))
         {
           ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
   /* make sure we are called again until all children have been reaped */
   /* we need to do it this way so that the callback gets called before we continue */
   ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
   child_reap (EV_A_ pid, pid, status);
-  if (EV_PID_HASHSIZE > 1)
+  if ((EV_PID_HASHSIZE) > 1)
     child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
 }
 #endif
 /*****************************************************************************/
+#if EV_USE_IOCP
+# include "ev_iocp.c"
+#endif
 #if EV_USE_PORT
 # include "ev_port.c"
 #endif
 #if EV_USE_KQUEUE
 # include "ev_kqueue.c"
 #ifdef __APPLE__
   /* only select works correctly on that "unix-certified" platform */
   flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
   flags &= ~EVBACKEND_POLL;   /* poll is based on kqueue from 10.5 onwards */
 #endif
+#ifdef __FreeBSD__
+  flags &= ~EVBACKEND_POLL;   /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
+#endif
   return flags;
 }
 unsigned int
 ev_embeddable_backends (void)
 {
   int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
   /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
-  /* please fix it and tell me how to detect the fix */
+  if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
-  flags &= ~EVBACKEND_EPOLL;
+    flags &= ~EVBACKEND_EPOLL;
   return flags;
 }
 unsigned int
 ev_backend (EV_P)
 {
   return backend;
 }
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
 unsigned int
-ev_loop_count (EV_P)
+ev_iteration (EV_P)
 {
   return loop_count;
 }
 unsigned int
-ev_loop_depth (EV_P)
+ev_depth (EV_P)
 {
   return loop_depth;
 }
 void
 static void noinline
 loop_init (EV_P_ unsigned int flags)
 {
   if (!backend)
     {
+      origflags = flags;
 #if EV_USE_REALTIME
       if (!have_realtime)
         {
           struct timespec ts;
       ev_rt_now         = ev_time ();
       mn_now            = get_clock ();
       now_floor         = mn_now;
       rtmn_diff         = ev_rt_now - mn_now;
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
       invoke_cb         = ev_invoke_pending;
 #endif
       io_blocktime      = 0.;
       timeout_blocktime = 0.;
 #endif
 #if EV_USE_SIGNALFD
       sigfd             = flags & EVFLAG_SIGNALFD  ? -2 : -1;
 #endif
-      if (!(flags & 0x0000ffffU))
+      if (!(flags & EVBACKEND_MASK))
         flags |= ev_recommended_backends ();
+#if EV_USE_IOCP
+      if (!backend && (flags & EVBACKEND_IOCP  )) backend = iocp_init   (EV_A_ flags);
+#endif
 #if EV_USE_PORT
       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
 #endif
 #if EV_USE_KQUEUE
       if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
       if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
 #endif
       ev_prepare_init (&pending_w, pendingcb);
+#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
       ev_init (&pipe_w, pipecb);
       ev_set_priority (&pipe_w, EV_MAXPRI);
+#endif
     }
 }
 /* free up a loop structure */
-static void noinline
+void
-loop_destroy (EV_P)
+ev_loop_destroy (EV_P)
 {
   int i;
+#if EV_MULTIPLICITY
+  /* mimic free (0) */
+  if (!EV_A)
+    return;
+#endif
+#if EV_CLEANUP_ENABLE
+  /* queue cleanup watchers (and execute them) */
+  if (expect_false (cleanupcnt))
+    {
+      queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
+      EV_INVOKE_PENDING;
+    }
+#endif
+#if EV_CHILD_ENABLE
+  if (ev_is_active (&childev))
+    {
+      ev_ref (EV_A); /* child watcher */
+      ev_signal_stop (EV_A_ &childev);
+    }
+#endif
   if (ev_is_active (&pipe_w))
     {
       /*ev_ref (EV_A);*/
       /*ev_io_stop (EV_A_ &pipe_w);*/
 #endif
   if (backend_fd >= 0)
     close (backend_fd);
+#if EV_USE_IOCP
+  if (backend == EVBACKEND_IOCP  ) iocp_destroy   (EV_A);
+#endif
 #if EV_USE_PORT
   if (backend == EVBACKEND_PORT  ) port_destroy   (EV_A);
 #endif
 #if EV_USE_KQUEUE
   if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
   array_free (periodic, EMPTY);
 #endif
 #if EV_FORK_ENABLE
   array_free (fork, EMPTY);
 #endif
+#if EV_CLEANUP_ENABLE
+  array_free (cleanup, EMPTY);
+#endif
   array_free (prepare, EMPTY);
   array_free (check, EMPTY);
 #if EV_ASYNC_ENABLE
   array_free (async, EMPTY);
 #endif
   backend = 0;
+#if EV_MULTIPLICITY
+  if (ev_is_default_loop (EV_A))
+#endif
+    ev_default_loop_ptr = 0;
+#if EV_MULTIPLICITY
+  else
+    ev_free (EV_A);
+#endif
 }
 #if EV_USE_INOTIFY
 inline_size void infy_fork (EV_P);
 #endif
         {
           EV_WIN32_CLOSE_FD (evpipe [0]);
           EV_WIN32_CLOSE_FD (evpipe [1]);
         }
+#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
       evpipe_init (EV_A);
       /* now iterate over everything, in case we missed something */
       pipecb (EV_A_ &pipe_w, EV_READ);
+#endif
     }
   postfork = 0;
 }
   loop_init (EV_A_ flags);
   if (ev_backend (EV_A))
     return EV_A;
+  ev_free (EV_A);
   return 0;
 }
-void
-ev_loop_destroy (EV_P)
-{
-  loop_destroy (EV_A);
-  ev_free (loop);
-}
-void
-ev_loop_fork (EV_P)
-{
-  postfork = 1; /* must be in line with ev_default_fork */
-}
 #endif /* multiplicity */
 #if EV_VERIFY
 static void noinline
 verify_watcher (EV_P_ W w)
       verify_watcher (EV_A_ ws [cnt]);
     }
 }
 #endif
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
 void
-ev_loop_verify (EV_P)
+ev_verify (EV_P)
 {
 #if EV_VERIFY
   int i;
   WL w;
 #if EV_FORK_ENABLE
   assert (forkmax >= forkcnt);
   array_verify (EV_A_ (W *)forks, forkcnt);
 #endif
+#if EV_CLEANUP_ENABLE
+  assert (cleanupmax >= cleanupcnt);
+  array_verify (EV_A_ (W *)cleanups, cleanupcnt);
+#endif
 #if EV_ASYNC_ENABLE
   assert (asyncmax >= asynccnt);
   array_verify (EV_A_ (W *)asyncs, asynccnt);
 #endif
+#if EV_PREPARE_ENABLE
   assert (preparemax >= preparecnt);
   array_verify (EV_A_ (W *)prepares, preparecnt);
+#endif
+#if EV_CHECK_ENABLE
   assert (checkmax >= checkcnt);
   array_verify (EV_A_ (W *)checks, checkcnt);
+#endif
 # if 0
+#if EV_CHILD_ENABLE
-  for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
+  for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
   for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
+#endif
 # endif
 #endif
 }
 #endif
 #if EV_MULTIPLICITY
 struct ev_loop *
-ev_default_loop_init (unsigned int flags)
 #else
 int
+#endif
 ev_default_loop (unsigned int flags)
-#endif
 {
   if (!ev_default_loop_ptr)
     {
 #if EV_MULTIPLICITY
       EV_P = ev_default_loop_ptr = &default_loop_struct;
       loop_init (EV_A_ flags);
       if (ev_backend (EV_A))
         {
-#ifndef _WIN32
+#if EV_CHILD_ENABLE
           ev_signal_init (&childev, childcb, SIGCHLD);
           ev_set_priority (&childev, EV_MAXPRI);
           ev_signal_start (EV_A_ &childev);
           ev_unref (EV_A); /* child watcher should not keep loop alive */
 #endif
   return ev_default_loop_ptr;
 }
 void
-ev_default_destroy (void)
+ev_loop_fork (EV_P)
 {
-#if EV_MULTIPLICITY
-  EV_P = ev_default_loop_ptr;
-#endif
-  ev_default_loop_ptr = 0;
-#ifndef _WIN32
-  ev_ref (EV_A); /* child watcher */
-  ev_signal_stop (EV_A_ &childev);
-#endif
-  loop_destroy (EV_A);
-}
-void
-ev_default_fork (void)
-{
-#if EV_MULTIPLICITY
-  EV_P = ev_default_loop_ptr;
-#endif
-  postfork = 1; /* must be in line with ev_loop_fork */
+  postfork = 1; /* must be in line with ev_default_fork */
 }
 /*****************************************************************************/
 void
   for (pri = NUMPRI; pri--; )
     while (pendingcnt [pri])
       {
         ANPENDING *p = pendings [pri] + --pendingcnt [pri];
-        /*assert (("libev: non-pending watcher on pending list", p->w->pending));*/
-        /* ^ this is no longer true, as pending_w could be here */
         p->w->pending = 0;
         EV_CB_INVOKE (p->w, p->events);
         EV_FREQUENT_CHECK;
       }
           EV_FREQUENT_CHECK;
           feed_reverse (EV_A_ (W)w);
         }
       while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);
-      feed_reverse_done (EV_A_ EV_TIMEOUT);
+      feed_reverse_done (EV_A_ EV_TIMER);
     }
 }
 #if EV_PERIODIC_ENABLE
+inline_speed
+periodic_recalc (EV_P_ ev_periodic *w)
+{
+  /* TODO: use slow but potentially more correct incremental algo, */
+  /* also do not rely on ceil */
+  ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+}
 /* make periodics pending */
 inline_size void
 periodics_reify (EV_P)
 {
   EV_FREQUENT_CHECK;
               ANHE_at_cache (periodics [HEAP0]);
               downheap (periodics, periodiccnt, HEAP0);
             }
           else if (w->interval)
             {
-              ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+              periodic_recalc (EV_A_ w);
               /* if next trigger time is not sufficiently in the future, put it there */
               /* this might happen because of floating point inexactness */
               if (ev_at (w) - ev_rt_now < TIME_EPSILON)
                 {
                   ev_at (w) += w->interval;
       feed_reverse_done (EV_A_ EV_PERIODIC);
     }
 }
 /* simply recalculate all periodics */
-/* TODO: maybe ensure that at leats one event happens when jumping forward? */
+/* TODO: maybe ensure that at least one event happens when jumping forward? */
 static void noinline
 periodics_reschedule (EV_P)
 {
   int i;
       ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
       if (w->reschedule_cb)
         ev_at (w) = w->reschedule_cb (w, ev_rt_now);
       else if (w->interval)
-        ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+        periodic_recalc (EV_A_ w);
       ANHE_at_cache (periodics [i]);
     }
   reheap (periodics, periodiccnt);
       mn_now = ev_rt_now;
     }
 }
 void
-ev_loop (EV_P_ int flags)
+ev_run (EV_P_ int flags)
 {
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
   ++loop_depth;
 #endif
-  assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE));
+  assert (("libev: ev_loop recursion during release detected", loop_done != EVBREAK_RECURSE));
-  loop_done = EVUNLOOP_CANCEL;
+  loop_done = EVBREAK_CANCEL;
   EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */
   do
     {
 #if EV_VERIFY >= 2
-      ev_loop_verify (EV_A);
+      ev_verify (EV_A);
 #endif
 #ifndef _WIN32
       if (expect_false (curpid)) /* penalise the forking check even more */
         if (expect_false (getpid () != curpid))
             queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
             EV_INVOKE_PENDING;
           }
 #endif
+#if EV_PREPARE_ENABLE
       /* queue prepare watchers (and execute them) */
       if (expect_false (preparecnt))
         {
           queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
           EV_INVOKE_PENDING;
         }
+#endif
       if (expect_false (loop_done))
         break;
       /* we might have forked, so reify kernel state if necessary */
       /* calculate blocking time */
       {
         ev_tstamp waittime  = 0.;
         ev_tstamp sleeptime = 0.;
+        /* remember old timestamp for io_blocktime calculation */
+        ev_tstamp prev_mn_now = mn_now;
+        /* update time to cancel out callback processing overhead */
+        time_update (EV_A_ 1e100);
-        if (expect_true (!(flags & EVLOOP_NONBLOCK || idleall || !activecnt)))
+        if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt)))
           {
-            /* remember old timestamp for io_blocktime calculation */
-            ev_tstamp prev_mn_now = mn_now;
-            /* update time to cancel out callback processing overhead */
-            time_update (EV_A_ 1e100);
             waittime = MAX_BLOCKTIME;
             if (timercnt)
               {
                 ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge;
                     waittime -= sleeptime;
                   }
               }
           }
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
         ++loop_count;
 #endif
-        assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */
+        assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
         backend_poll (EV_A_ waittime);
-        assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */
+        assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
         /* update ev_rt_now, do magic */
         time_update (EV_A_ waittime + sleeptime);
       }
 #if EV_IDLE_ENABLE
       /* queue idle watchers unless other events are pending */
       idle_reify (EV_A);
 #endif
+#if EV_CHECK_ENABLE
       /* queue check watchers, to be executed first */
       if (expect_false (checkcnt))
         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
+#endif
       EV_INVOKE_PENDING;
     }
   while (expect_true (
     activecnt
     && !loop_done
-    && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
+    && !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
   ));
-  if (loop_done == EVUNLOOP_ONE)
+  if (loop_done == EVBREAK_ONE)
-    loop_done = EVUNLOOP_CANCEL;
+    loop_done = EVBREAK_CANCEL;
-#if EV_MINIMAL < 2
+#if EV_FEATURE_API
   --loop_depth;
 #endif
 }
 void
-ev_unloop (EV_P_ int how)
+ev_break (EV_P_ int how)
 {
   loop_done = how;
 }
 void
   EV_FREQUENT_CHECK;
   wlist_del (&anfds[w->fd].head, (WL)w);
   ev_stop (EV_A_ (W)w);
-  fd_change (EV_A_ w->fd, 1);
+  fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
   EV_FREQUENT_CHECK;
 }
 void noinline
   if (w->reschedule_cb)
     ev_at (w) = w->reschedule_cb (w, ev_rt_now);
   else if (w->interval)
     {
       assert (("libev: ev_periodic_start called with negative interval value", w->interval >= 0.));
-      /* this formula differs from the one in periodic_reify because we do not always round up */
+      periodic_recalc (EV_A_ w);
-      ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
     }
   else
     ev_at (w) = w->offset;
   EV_FREQUENT_CHECK;
 #endif
 #ifndef SA_RESTART
 # define SA_RESTART 0
 #endif
+#if EV_SIGNAL_ENABLE
 void noinline
 ev_signal_start (EV_P_ ev_signal *w)
 {
   if (expect_false (ev_is_active (w)))
         sa.sa_handler = ev_sighandler;
         sigfillset (&sa.sa_mask);
         sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
         sigaction (w->signum, &sa, 0);
+        if (origflags & EVFLAG_NOSIGMASK)
+          {
-        sigemptyset (&sa.sa_mask);
+            sigemptyset (&sa.sa_mask);
-        sigaddset (&sa.sa_mask, w->signum);
+            sigaddset (&sa.sa_mask, w->signum);
-        sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
+            sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
+          }
 #endif
       }
   EV_FREQUENT_CHECK;
 }
     }
   EV_FREQUENT_CHECK;
 }
+#endif
+#if EV_CHILD_ENABLE
 void
 ev_child_start (EV_P_ ev_child *w)
 {
 #if EV_MULTIPLICITY
   assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
     return;
   EV_FREQUENT_CHECK;
   ev_start (EV_A_ (W)w, 1);
-  wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
+  wlist_add (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
   EV_FREQUENT_CHECK;
 }
 void
   if (expect_false (!ev_is_active (w)))
     return;
   EV_FREQUENT_CHECK;
-  wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
+  wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
   ev_stop (EV_A_ (W)w);
   EV_FREQUENT_CHECK;
 }
+#endif
 #if EV_STAT_ENABLE
 # ifdef _WIN32
 #  undef lstat
           while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
         }
     }
   if (w->wd >= 0)
-    wlist_add (&fs_hash [w->wd & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
+    wlist_add (&fs_hash [w->wd & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
   /* now re-arm timer, if required */
   if (ev_is_active (&w->timer)) ev_ref (EV_A);
   ev_timer_again (EV_A_ &w->timer);
   if (ev_is_active (&w->timer)) ev_unref (EV_A);
   if (wd < 0)
     return;
   w->wd = -2;
-  slot = wd & (EV_INOTIFY_HASHSIZE - 1);
+  slot = wd & ((EV_INOTIFY_HASHSIZE) - 1);
   wlist_del (&fs_hash [slot].head, (WL)w);
   /* remove this watcher, if others are watching it, they will rearm */
   inotify_rm_watch (fs_fd, wd);
 }
 static void noinline
 infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
 {
   if (slot < 0)
     /* overflow, need to check for all hash slots */
-    for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
+    for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
       infy_wd (EV_A_ slot, wd, ev);
   else
     {
       WL w_;
-      for (w_ = fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head; w_; )
+      for (w_ = fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head; w_; )
         {
           ev_stat *w = (ev_stat *)w_;
           w_ = w_->next; /* lets us remove this watcher and all before it */
           if (w->wd == wd || wd == -1)
             {
               if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
                 {
-                  wlist_del (&fs_hash [slot & (EV_INOTIFY_HASHSIZE - 1)].head, (WL)w);
+                  wlist_del (&fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
                   w->wd = -1;
                   infy_add (EV_A_ w); /* re-add, no matter what */
                 }
               stat_timer_cb (EV_A_ &w->timer, 0);
     {
       struct inotify_event *ev = (struct inotify_event *)(buf + ofs);
       infy_wd (EV_A_ ev->wd, ev->wd, ev);
       ofs += sizeof (struct inotify_event) + ev->len;
     }
-}
-inline_size unsigned int
-ev_linux_version (void)
-{
-  struct utsname buf;
-  unsigned int v;
-  int i;
-  char *p = buf.release;
-  if (uname (&buf))
-    return 0;
-  for (i = 3+1; --i; )
-    {
-      unsigned int c = 0;
-      for (;;)
-        {
-          if (*p >= '0' && *p <= '9')
-            c = c * 10 + *p++ - '0';
-          else
-            {
-              p += *p == '.';
-              break;
-            }
-        }
-      v = (v << 8) | c;
-    }
-  return v;
 }
 inline_size void
 ev_check_2625 (EV_P)
 {
       ev_io_set (&fs_w, fs_fd, EV_READ);
       ev_io_start (EV_A_ &fs_w);
       ev_unref (EV_A);
     }
-  for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
+  for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
     {
       WL w_ = fs_hash [slot].head;
       fs_hash [slot].head = 0;
       while (w_)
   EV_FREQUENT_CHECK;
 }
 #endif
+#if EV_PREPARE_ENABLE
 void
 ev_prepare_start (EV_P_ ev_prepare *w)
 {
   if (expect_false (ev_is_active (w)))
     return;
   ev_stop (EV_A_ (W)w);
   EV_FREQUENT_CHECK;
 }
+#endif
+#if EV_CHECK_ENABLE
 void
 ev_check_start (EV_P_ ev_check *w)
 {
   if (expect_false (ev_is_active (w)))
     return;
   ev_stop (EV_A_ (W)w);
   EV_FREQUENT_CHECK;
 }
+#endif
 #if EV_EMBED_ENABLE
 void noinline
 ev_embed_sweep (EV_P_ ev_embed *w)
 {
-  ev_loop (w->other, EVLOOP_NONBLOCK);
+  ev_run (w->other, EVRUN_NOWAIT);
 }
 static void
 embed_io_cb (EV_P_ ev_io *io, int revents)
 {
   ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
   if (ev_cb (w))
     ev_feed_event (EV_A_ (W)w, EV_EMBED);
   else
-    ev_loop (w->other, EVLOOP_NONBLOCK);
+    ev_run (w->other, EVRUN_NOWAIT);
 }
 static void
 embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
 {
     EV_P = w->other;
     while (fdchangecnt)
       {
         fd_reify (EV_A);
-        ev_loop (EV_A_ EVLOOP_NONBLOCK);
+        ev_run (EV_A_ EVRUN_NOWAIT);
       }
   }
 }
 static void
   {
     EV_P = w->other;
     ev_loop_fork (EV_A);
-    ev_loop (EV_A_ EVLOOP_NONBLOCK);
+    ev_run (EV_A_ EVRUN_NOWAIT);
   }
   ev_embed_start (EV_A_ w);
 }
   EV_FREQUENT_CHECK;
 }
 #endif
-#if EV_ASYNC_ENABLE
+#if EV_CLEANUP_ENABLE
 void
-ev_async_start (EV_P_ ev_async *w)
+ev_cleanup_start (EV_P_ ev_cleanup *w)
 {
   if (expect_false (ev_is_active (w)))
     return;
+  EV_FREQUENT_CHECK;
+  ev_start (EV_A_ (W)w, ++cleanupcnt);
+  array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);
+  cleanups [cleanupcnt - 1] = w;
+  /* cleanup watchers should never keep a refcount on the loop */
+  ev_unref (EV_A);
+  EV_FREQUENT_CHECK;
+}
+void
+ev_cleanup_stop (EV_P_ ev_cleanup *w)
+{
+  clear_pending (EV_A_ (W)w);
+  if (expect_false (!ev_is_active (w)))
+    return;
+  EV_FREQUENT_CHECK;
+  ev_ref (EV_A);
+  {
+    int active = ev_active (w);
+    cleanups [active - 1] = cleanups [--cleanupcnt];
+    ev_active (cleanups [active - 1]) = active;
+  }
+  ev_stop (EV_A_ (W)w);
+  EV_FREQUENT_CHECK;
+}
+#endif
+#if EV_ASYNC_ENABLE
+void
+ev_async_start (EV_P_ ev_async *w)
+{
+  if (expect_false (ev_is_active (w)))
+    return;
+  w->sent = 0;
   evpipe_init (EV_A);
   EV_FREQUENT_CHECK;
 {
   struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
   if (expect_false (!once))
     {
-      cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMEOUT, arg);
+      cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg);
       return;
     }
   once->cb  = cb;
   once->arg = arg;
   if (types & EV_ASYNC)
     for (i = asynccnt; i--; )
       cb (EV_A_ EV_ASYNC, asyncs [i]);
 #endif
+#if EV_PREPARE_ENABLE
   if (types & EV_PREPARE)
     for (i = preparecnt; i--; )
-#if EV_EMBED_ENABLE
+# if EV_EMBED_ENABLE
       if (ev_cb (prepares [i]) != embed_prepare_cb)
-#endif
+# endif
         cb (EV_A_ EV_PREPARE, prepares [i]);
+#endif
+#if EV_CHECK_ENABLE
   if (types & EV_CHECK)
     for (i = checkcnt; i--; )
       cb (EV_A_ EV_CHECK, checks [i]);
+#endif
+#if EV_SIGNAL_ENABLE
   if (types & EV_SIGNAL)
     for (i = 0; i < EV_NSIG - 1; ++i)
       for (wl = signals [i].head; wl; )
         {
           wn = wl->next;
           cb (EV_A_ EV_SIGNAL, wl);
           wl = wn;
         }
+#endif
+#if EV_CHILD_ENABLE
   if (types & EV_CHILD)
-    for (i = EV_PID_HASHSIZE; i--; )
+    for (i = (EV_PID_HASHSIZE); i--; )
       for (wl = childs [i]; wl; )
         {
           wn = wl->next;
           cb (EV_A_ EV_CHILD, wl);
           wl = wn;
         }
+#endif
 /* EV_STAT     0x00001000 /* stat data changed */
 /* EV_EMBED    0x00010000 /* embedded event loop needs sweep */
 }
 #endif
 #if EV_MULTIPLICITY
   #include "ev_wrap.h"
 #endif
-#ifdef __cplusplus
+EV_CPP(})
-}
-#endif

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.c (file contents): Revision 1.331 by root, Tue Mar 9 08:55:03 2010 UTC vs. Revision 1.370 by root, Sun Jan 30 19:05:41 2011 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.331 by root, Tue Mar 9 08:55:03 2010 UTC vs.
Revision 1.370 by root, Sun Jan 30 19:05:41 2011 UTC