Windows: Use 32-bit distribution of python

1 files changed, 0 insertions, 1134 deletions

diff --git a/python/gevent/libev/corecext.ppyx b/python/gevent/libev/corecext.ppyx
deleted file mode 100644
index a474d7e..0000000
--- a/python/gevent/libev/corecext.ppyx
+++ /dev/null
@@ -1,1134 +0,0 @@
-# Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
-# This directive, supported in Cython 0.24+, causes sources files to be
-# much smaller and thus cythonpp.py to be slightly faster. But it does make
-# debugging more difficult.
-# cython: emit_code_comments=False
-cimport cython
-cimport libev
-# Note this is not the standard cython 'cpython' (which has a backwards compat alias of 'python')
-# it's our custom def. If it's not on the include path, we get warned.
-from python cimport *
-
-# Work around lack of absolute_import in Cython
-# Note for PY3: not doing so will leave reference to locals() on import
-# (reproducible under Python 3.3, not under Python 3.4; see test__refcount_core.py)
-sys = __import__('sys', level=0)
-os = __import__('os', level=0)
-traceback = __import__('traceback', level=0)
-signalmodule = __import__('signal', level=0)
-
-
-__all__ = ['get_version',
-           'get_header_version',
-           'supported_backends',
-           'recommended_backends',
-           'embeddable_backends',
-           'time',
-           'loop']
-
-cdef tuple integer_types
-
-if sys.version_info[0] >= 3:
-    integer_types = int,
-else:
-    integer_types = (int, long)
-
-
-cdef extern from "callbacks.h":
-    void gevent_callback_io(libev.ev_loop, void*, int)
-    void gevent_callback_timer(libev.ev_loop, void*, int)
-    void gevent_callback_signal(libev.ev_loop, void*, int)
-    void gevent_callback_idle(libev.ev_loop, void*, int)
-    void gevent_callback_prepare(libev.ev_loop, void*, int)
-    void gevent_callback_check(libev.ev_loop, void*, int)
-    void gevent_callback_fork(libev.ev_loop, void*, int)
-    void gevent_callback_async(libev.ev_loop, void*, int)
-    void gevent_callback_child(libev.ev_loop, void*, int)
-    void gevent_callback_stat(libev.ev_loop, void*, int)
-    void gevent_run_callbacks(libev.ev_loop, void*, int)
-    void gevent_periodic_signal_check(libev.ev_loop, void*, int)
-    void gevent_call(loop, callback)
-    void gevent_noop(libev.ev_loop, void*, int)
-
-cdef extern from *:
-    int errno
-
-cdef extern from "stathelper.c":
-    object _pystat_fromstructstat(void*)
-
-
-UNDEF = libev.EV_UNDEF
-NONE = libev.EV_NONE
-READ = libev.EV_READ
-WRITE = libev.EV_WRITE
-TIMER = libev.EV_TIMER
-PERIODIC = libev.EV_PERIODIC
-SIGNAL = libev.EV_SIGNAL
-CHILD = libev.EV_CHILD
-STAT = libev.EV_STAT
-IDLE = libev.EV_IDLE
-PREPARE = libev.EV_PREPARE
-CHECK = libev.EV_CHECK
-EMBED = libev.EV_EMBED
-FORK = libev.EV_FORK
-CLEANUP = libev.EV_CLEANUP
-ASYNC = libev.EV_ASYNC
-CUSTOM = libev.EV_CUSTOM
-ERROR = libev.EV_ERROR
-
-READWRITE = libev.EV_READ | libev.EV_WRITE
-
-MINPRI = libev.EV_MINPRI
-MAXPRI = libev.EV_MAXPRI
-
-BACKEND_PORT = libev.EVBACKEND_PORT
-BACKEND_KQUEUE = libev.EVBACKEND_KQUEUE
-BACKEND_EPOLL = libev.EVBACKEND_EPOLL
-BACKEND_POLL = libev.EVBACKEND_POLL
-BACKEND_SELECT = libev.EVBACKEND_SELECT
-FORKCHECK = libev.EVFLAG_FORKCHECK
-NOINOTIFY = libev.EVFLAG_NOINOTIFY
-SIGNALFD = libev.EVFLAG_SIGNALFD
-NOSIGMASK = libev.EVFLAG_NOSIGMASK
-
-
-@cython.internal
-cdef class _EVENTSType:
-
-    def __repr__(self):
-        return 'gevent.core.EVENTS'
-
-
-cdef public object GEVENT_CORE_EVENTS = _EVENTSType()
-EVENTS = GEVENT_CORE_EVENTS
-
-
-def get_version():
-    return 'libev-%d.%02d' % (libev.ev_version_major(), libev.ev_version_minor())
-
-
-def get_header_version():
-    return 'libev-%d.%02d' % (libev.EV_VERSION_MAJOR, libev.EV_VERSION_MINOR)
-
-
-# This list backends in the order they are actually tried by libev
-_flags = [(libev.EVBACKEND_PORT, 'port'),
-          (libev.EVBACKEND_KQUEUE, 'kqueue'),
-          (libev.EVBACKEND_EPOLL, 'epoll'),
-          (libev.EVBACKEND_POLL, 'poll'),
-          (libev.EVBACKEND_SELECT, 'select'),
-          (libev.EVFLAG_NOENV, 'noenv'),
-          (libev.EVFLAG_FORKCHECK, 'forkcheck'),
-          (libev.EVFLAG_NOINOTIFY, 'noinotify'),
-          (libev.EVFLAG_SIGNALFD, 'signalfd'),
-          (libev.EVFLAG_NOSIGMASK, 'nosigmask')]
-
-
-_flags_str2int = dict((string, flag) for (flag, string) in _flags)
-
-
-_events = [(libev.EV_READ,     'READ'),
-           (libev.EV_WRITE,    'WRITE'),
-           (libev.EV__IOFDSET, '_IOFDSET'),
-           (libev.EV_PERIODIC, 'PERIODIC'),
-           (libev.EV_SIGNAL,   'SIGNAL'),
-           (libev.EV_CHILD,    'CHILD'),
-           (libev.EV_STAT,     'STAT'),
-           (libev.EV_IDLE,     'IDLE'),
-           (libev.EV_PREPARE,  'PREPARE'),
-           (libev.EV_CHECK,    'CHECK'),
-           (libev.EV_EMBED,    'EMBED'),
-           (libev.EV_FORK,     'FORK'),
-           (libev.EV_CLEANUP,  'CLEANUP'),
-           (libev.EV_ASYNC,    'ASYNC'),
-           (libev.EV_CUSTOM,   'CUSTOM'),
-           (libev.EV_ERROR,    'ERROR')]
-
-
-cpdef _flags_to_list(unsigned int flags):
-    cdef list result = []
-    for code, value in _flags:
-        if flags & code:
-            result.append(value)
-        flags &= ~code
-        if not flags:
-            break
-    if flags:
-        result.append(flags)
-    return result
-
-
-if sys.version_info[0] >= 3:
-    basestring = (bytes, str)
-else:
-    basestring = __builtins__.basestring
-
-
-cpdef unsigned int _flags_to_int(object flags) except? -1:
-    # Note, that order does not matter, libev has its own predefined order
-    if not flags:
-        return 0
-    if isinstance(flags, integer_types):
-        return flags
-    cdef unsigned int result = 0
-    try:
-        if isinstance(flags, basestring):
-            flags = flags.split(',')
-        for value in flags:
-            value = value.strip().lower()
-            if value:
-                result |= _flags_str2int[value]
-    except KeyError as ex:
-        raise ValueError('Invalid backend or flag: %s\nPossible values: %s' % (ex, ', '.join(sorted(_flags_str2int.keys()))))
-    return result
-
-
-cdef str _str_hex(object flag):
-    if isinstance(flag, integer_types):
-        return hex(flag)
-    return str(flag)
-
-
-cpdef _check_flags(unsigned int flags):
-    cdef list as_list
-    flags &= libev.EVBACKEND_MASK
-    if not flags:
-        return
-    if not (flags & libev.EVBACKEND_ALL):
-        raise ValueError('Invalid value for backend: 0x%x' % flags)
-    if not (flags & libev.ev_supported_backends()):
-        as_list = [_str_hex(x) for x in _flags_to_list(flags)]
-        raise ValueError('Unsupported backend: %s' % '|'.join(as_list))
-
-
-cpdef _events_to_str(int events):
-    cdef list result = []
-    cdef int c_flag
-    for (flag, string) in _events:
-        c_flag = flag
-        if events & c_flag:
-            result.append(string)
-            events = events & (~c_flag)
-        if not events:
-            break
-    if events:
-        result.append(hex(events))
-    return '|'.join(result)
-
-
-def supported_backends():
-    return _flags_to_list(libev.ev_supported_backends())
-
-
-def recommended_backends():
-    return _flags_to_list(libev.ev_recommended_backends())
-
-
-def embeddable_backends():
-    return _flags_to_list(libev.ev_embeddable_backends())
-
-
-def time():
-    return libev.ev_time()
-
-
-#define LOOP_PROPERTY(NAME) property NAME:  \
-                                            \
-        def __get__(self):                  \
-            CHECK_LOOP3(self)               \
-            return self._ptr.NAME
-
-
-cdef bint _default_loop_destroyed = False
-
-
-#define CHECK_LOOP2(LOOP)                                   \
-        if not LOOP._ptr:                                   \
-            raise ValueError('operation on destroyed loop')
-
-
-#define CHECK_LOOP3(LOOP)                                       \
-            if not LOOP._ptr:                                   \
-                raise ValueError('operation on destroyed loop')
-
-
-
-cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
-    cdef libev.ev_loop* _ptr
-    cdef public object error_handler
-    cdef libev.ev_prepare _prepare
-    cdef public list _callbacks
-    cdef libev.ev_timer _timer0
-#ifdef _WIN32
-    cdef libev.ev_timer _periodic_signal_checker
-#endif
-
-    def __init__(self, object flags=None, object default=None, size_t ptr=0):
-        cdef unsigned int c_flags
-        cdef object old_handler = None
-        libev.ev_prepare_init(&self._prepare, <void*>gevent_run_callbacks)
-#ifdef _WIN32
-        libev.ev_timer_init(&self._periodic_signal_checker, <void*>gevent_periodic_signal_check, 0.3, 0.3)
-#endif
-        libev.ev_timer_init(&self._timer0, <void*>gevent_noop, 0.0, 0.0)
-        if ptr:
-            self._ptr = <libev.ev_loop*>ptr
-        else:
-            c_flags = _flags_to_int(flags)
-            _check_flags(c_flags)
-            c_flags |= libev.EVFLAG_NOENV
-            c_flags |= libev.EVFLAG_FORKCHECK
-            if default is None:
-                default = True
-                if _default_loop_destroyed:
-                    default = False
-            if default:
-                self._ptr = libev.gevent_ev_default_loop(c_flags)
-                if not self._ptr:
-                    raise SystemError("ev_default_loop(%s) failed" % (c_flags, ))
-#ifdef _WIN32
-                libev.ev_timer_start(self._ptr, &self._periodic_signal_checker)
-                libev.ev_unref(self._ptr)
-#endif
-            else:
-                self._ptr = libev.ev_loop_new(c_flags)
-                if not self._ptr:
-                    raise SystemError("ev_loop_new(%s) failed" % (c_flags, ))
-            if default or __SYSERR_CALLBACK is None:
-                set_syserr_cb(self._handle_syserr)
-            libev.ev_prepare_start(self._ptr, &self._prepare)
-            libev.ev_unref(self._ptr)
-        self._callbacks = []
-
-    cdef _run_callbacks(self):
-        cdef callback cb
-        cdef object callbacks
-        cdef int count = 1000
-        libev.ev_timer_stop(self._ptr, &self._timer0)
-        while self._callbacks and count > 0:
-            callbacks = self._callbacks
-            self._callbacks = []
-            for cb in callbacks:
-                libev.ev_unref(self._ptr)
-                gevent_call(self, cb)
-                count -= 1
-        if self._callbacks:
-            libev.ev_timer_start(self._ptr, &self._timer0)
-
-    def _stop_watchers(self):
-        if libev.ev_is_active(&self._prepare):
-            libev.ev_ref(self._ptr)
-            libev.ev_prepare_stop(self._ptr, &self._prepare)
-#ifdef _WIN32
-        if libev.ev_is_active(&self._periodic_signal_checker):
-            libev.ev_ref(self._ptr)
-            libev.ev_timer_stop(self._ptr, &self._periodic_signal_checker)
-#endif
-
-    def destroy(self):
-        global _default_loop_destroyed
-        if self._ptr:
-            self._stop_watchers()
-            if __SYSERR_CALLBACK == self._handle_syserr:
-                set_syserr_cb(None)
-            if libev.ev_is_default_loop(self._ptr):
-                _default_loop_destroyed = True
-            libev.ev_loop_destroy(self._ptr)
-            self._ptr = NULL
-
-    def __dealloc__(self):
-        if self._ptr:
-            self._stop_watchers()
-            if not libev.ev_is_default_loop(self._ptr):
-                libev.ev_loop_destroy(self._ptr)
-            self._ptr = NULL
-
-    property ptr:
-
-        def __get__(self):
-            return <size_t>self._ptr
-
-    property WatcherType:
-
-        def __get__(self):
-            return watcher
-
-    property MAXPRI:
-
-       def __get__(self):
-           return libev.EV_MAXPRI
-
-    property MINPRI:
-
-        def __get__(self):
-            return libev.EV_MINPRI
-
-    def _handle_syserr(self, message, errno):
-        if sys.version_info[0] >= 3:
-            message = message.decode()
-        self.handle_error(None, SystemError, SystemError(message + ': ' + os.strerror(errno)), None)
-
-    cpdef handle_error(self, context, type, value, tb):
-        cdef object handle_error
-        cdef object error_handler = self.error_handler
-        if error_handler is not None:
-            # we do want to do getattr every time so that setting Hub.handle_error property just works
-            handle_error = getattr(error_handler, 'handle_error', error_handler)
-            handle_error(context, type, value, tb)
-        else:
-            self._default_handle_error(context, type, value, tb)
-
-    cpdef _default_handle_error(self, context, type, value, tb):
-        # note: Hub sets its own error handler so this is not used by gevent
-        # this is here to make core.loop usable without the rest of gevent
-        traceback.print_exception(type, value, tb)
-        if self._ptr:
-            libev.ev_break(self._ptr, libev.EVBREAK_ONE)
-
-    def run(self, nowait=False, once=False):
-        CHECK_LOOP2(self)
-        cdef unsigned int flags = 0
-        if nowait:
-            flags |= libev.EVRUN_NOWAIT
-        if once:
-            flags |= libev.EVRUN_ONCE
-        with nogil:
-            libev.ev_run(self._ptr, flags)
-
-    def reinit(self):
-        if self._ptr:
-            libev.ev_loop_fork(self._ptr)
-
-    def ref(self):
-        CHECK_LOOP2(self)
-        libev.ev_ref(self._ptr)
-
-    def unref(self):
-        CHECK_LOOP2(self)
-        libev.ev_unref(self._ptr)
-
-    def break_(self, int how=libev.EVBREAK_ONE):
-        CHECK_LOOP2(self)
-        libev.ev_break(self._ptr, how)
-
-    def verify(self):
-        CHECK_LOOP2(self)
-        libev.ev_verify(self._ptr)
-
-    def now(self):
-        CHECK_LOOP2(self)
-        return libev.ev_now(self._ptr)
-
-    def update(self):
-        CHECK_LOOP2(self)
-        libev.ev_now_update(self._ptr)
-
-    def __repr__(self):
-        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format())
-
-    property default:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return True if libev.ev_is_default_loop(self._ptr) else False
-
-    property iteration:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return libev.ev_iteration(self._ptr)
-
-    property depth:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return libev.ev_depth(self._ptr)
-
-    property backend_int:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return libev.ev_backend(self._ptr)
-
-    property backend:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            cdef unsigned int backend = libev.ev_backend(self._ptr)
-            for key, value in _flags:
-                if key == backend:
-                    return value
-            return backend
-
-    property pendingcnt:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return libev.ev_pending_count(self._ptr)
-
-#ifdef _WIN32
-    def io(self, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        return io(self, fd, events, ref, priority)
-#else
-    def io(self, int fd, int events, ref=True, priority=None):
-        return io(self, fd, events, ref, priority)
-#endif
-
-    def timer(self, double after, double repeat=0.0, ref=True, priority=None):
-        return timer(self, after, repeat, ref, priority)
-
-    def signal(self, int signum, ref=True, priority=None):
-        return signal(self, signum, ref, priority)
-
-    def idle(self, ref=True, priority=None):
-        return idle(self, ref, priority)
-
-    def prepare(self, ref=True, priority=None):
-        return prepare(self, ref, priority)
-
-    def check(self, ref=True, priority=None):
-        return check(self, ref, priority)
-
-    def fork(self, ref=True, priority=None):
-        return fork(self, ref, priority)
-
-    def async(self, ref=True, priority=None):
-        return async(self, ref, priority)
-
-#ifdef _WIN32
-#else
-
-    def child(self, int pid, bint trace=0, ref=True):
-        return child(self, pid, trace, ref)
-
-    def install_sigchld(self):
-        libev.gevent_install_sigchld_handler()
-
-    def reset_sigchld(self):
-        libev.gevent_reset_sigchld_handler()
-
-#endif
-
-    def stat(self, str path, float interval=0.0, ref=True, priority=None):
-        return stat(self, path, interval, ref, priority)
-
-    def run_callback(self, func, *args):
-        CHECK_LOOP2(self)
-        cdef callback cb = callback(func, args)
-        self._callbacks.append(cb)
-        libev.ev_ref(self._ptr)
-        return cb
-
-    def _format(self):
-        if not self._ptr:
-            return 'destroyed'
-        cdef object msg = self.backend
-        if self.default:
-            msg += ' default'
-        msg += ' pending=%s' % self.pendingcnt
-#ifdef LIBEV_EMBED
-        msg += self._format_details()
-#endif
-        return msg
-
-#ifdef LIBEV_EMBED
-
-    def _format_details(self):
-        cdef str msg = ''
-        cdef object fileno = self.fileno()
-        cdef object sigfd = None
-        cdef object activecnt = None
-        try:
-            sigfd = self.sigfd
-        except AttributeError:
-            sigfd = None
-        try:
-            activecnt = self.activecnt
-        except AttributeError:
-            pass
-        if activecnt is not None:
-            msg += ' ref=' + repr(activecnt)
-        if fileno is not None:
-            msg += ' fileno=' + repr(fileno)
-        if sigfd is not None and sigfd != -1:
-            msg += ' sigfd=' + repr(sigfd)
-        return msg
-
-    def fileno(self):
-        cdef int fd
-        if self._ptr:
-            fd = self._ptr.backend_fd
-            if fd >= 0:
-                return fd
-
-    LOOP_PROPERTY(activecnt)
-
-    LOOP_PROPERTY(sig_pending)
-
-#if EV_USE_SIGNALFD
-    LOOP_PROPERTY(sigfd)
-#endif
-
-    property origflags:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return _flags_to_list(self._ptr.origflags)
-
-    property origflags_int:
-
-        def __get__(self):
-            CHECK_LOOP3(self)
-            return self._ptr.origflags
-
-#endif
-
-
-cdef public class callback [object PyGeventCallbackObject, type PyGeventCallback_Type]:
-    cdef public object callback
-    cdef public tuple args
-
-    def __init__(self, callback, args):
-        self.callback = callback
-        self.args = args
-
-    def stop(self):
-        self.callback = None
-        self.args = None
-
-    # Note, that __nonzero__ and pending are different
-    # nonzero is used in contexts where we need to know whether to schedule another callback,
-    # so it's true if it's pending or currently running
-    # 'pending' has the same meaning as libev watchers: it is cleared before entering callback
-
-    def __nonzero__(self):
-        # it's nonzero if it's pending or currently executing
-        return self.args is not None
-
-    property pending:
-
-        def __get__(self):
-            return self.callback is not None
-
-    def __repr__(self):
-        if Py_ReprEnter(<PyObjectPtr>self) != 0:
-            return "<...>"
-        try:
-            format = self._format()
-            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
-            if self.pending:
-                result += " pending"
-            if self.callback is not None:
-                result += " callback=%r" % (self.callback, )
-            if self.args is not None:
-                result += " args=%r" % (self.args, )
-            if self.callback is None and self.args is None:
-                result += " stopped"
-            return result + ">"
-        finally:
-            Py_ReprLeave(<PyObjectPtr>self)
-
-    def _format(self):
-        return ''
-
-
-#define PYTHON_INCREF if not self._flags & 1:  \
-            Py_INCREF(<PyObjectPtr>self)       \
-            self._flags |= 1
-
-#define LIBEV_UNREF if self._flags & 6 == 4:   \
-            libev.ev_unref(self.loop._ptr)     \
-            self._flags |= 2
-
-# about readonly _flags attribute:
-# bit #1 set if object owns Python reference to itself (Py_INCREF was called and we must call Py_DECREF later)
-# bit #2 set if ev_unref() was called and we must call ev_ref() later
-# bit #3 set if user wants to call ev_unref() before start()
-
-#define WATCHER_BASE(TYPE)                                                              \
-    cdef public loop loop                                                               \
-    cdef object _callback                                                               \
-    cdef public tuple args                                                              \
-    cdef readonly int _flags                                                            \
-    cdef libev.ev_##TYPE _watcher                                                       \
-                                                                                        \
-    property ref:                                                                       \
-                                                                                        \
-        def __get__(self):                                                              \
-            return False if self._flags & 4 else True                                   \
-                                                                                        \
-        def __set__(self, object value):                                                \
-            CHECK_LOOP3(self.loop)                                                      \
-            if value:                                                                   \
-                if not self._flags & 4:                                                 \
-                    return  # ref is already True                                       \
-                if self._flags & 2:  # ev_unref was called, undo                        \
-                    libev.ev_ref(self.loop._ptr)                                        \
-                self._flags &= ~6  # do not want unref, no outstanding unref            \
-            else:                                                                       \
-                if self._flags & 4:                                                     \
-                    return  # ref is already False                                      \
-                self._flags |= 4                                                        \
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):          \
-                    libev.ev_unref(self.loop._ptr)                                      \
-                    self._flags |= 2                                                    \
-                                                                                        \
-    property callback:                                                                  \
-                                                                                        \
-        def __get__(self):                                                              \
-            return self._callback                                                       \
-                                                                                        \
-        def __set__(self, object callback):                                             \
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:    \
-                raise TypeError("Expected callable, not %r" % (callback, ))             \
-            self._callback = callback                                                   \
-                                                                                        \
-    def stop(self):                                                                     \
-        CHECK_LOOP2(self.loop)                                                          \
-        if self._flags & 2:                                                             \
-            libev.ev_ref(self.loop._ptr)                                                \
-            self._flags &= ~2                                                           \
-        libev.ev_##TYPE##_stop(self.loop._ptr, &self._watcher)                          \
-        self._callback = None                                                           \
-        self.args = None                                                                \
-        if self._flags & 1:                                                             \
-            Py_DECREF(<PyObjectPtr>self)                                                \
-            self._flags &= ~1                                                           \
-                                                                                        \
-    property priority:                                                                  \
-                                                                                        \
-        def __get__(self):                                                              \
-            return libev.ev_priority(&self._watcher)                                    \
-                                                                                        \
-        def __set__(self, int priority):                                                \
-            if libev.ev_is_active(&self._watcher):                                      \
-                raise AttributeError("Cannot set priority of an active watcher")        \
-            libev.ev_set_priority(&self._watcher, priority)                             \
-                                                                                        \
-    def feed(self, int revents, object callback, *args):                                \
-        CHECK_LOOP2(self.loop)                                                          \
-        self.callback = callback                                                        \
-        self.args = args                                                                \
-        LIBEV_UNREF                                                                     \
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)                    \
-        PYTHON_INCREF
-
-#define ACTIVE property active:                                             \
-                                                                            \
-        def __get__(self):                                                  \
-            return True if libev.ev_is_active(&self._watcher) else False
-
-#define START(TYPE) def start(self, object callback, *args):       \
-        CHECK_LOOP2(self.loop)                                     \
-        if callback is None:                                       \
-            raise TypeError('callback must be callable, not None') \
-        self.callback = callback                                   \
-        self.args = args                                           \
-        LIBEV_UNREF                                                \
-        libev.ev_##TYPE##_start(self.loop._ptr, &self._watcher)    \
-        PYTHON_INCREF
-
-
-#define PENDING                                                            \
-    property pending:                                                      \
-                                                                           \
-        def __get__(self):                                                 \
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-
-
-#define WATCHER(TYPE) WATCHER_BASE(TYPE) \
-                                         \
-    START(TYPE)                          \
-                                         \
-    ACTIVE                               \
-                                         \
-    PENDING
-
-
-#define COMMA ,
-
-
-#define INIT(TYPE, ARGS_INITIALIZERS, ARGS)                                                \
-    def __init__(self, loop loop ARGS_INITIALIZERS, ref=True, priority=None):              \
-        libev.ev_##TYPE##_init(&self._watcher, <void *>gevent_callback_##TYPE ARGS)        \
-        self.loop = loop                                                                   \
-        if ref:                                                                            \
-            self._flags = 0                                                                \
-        else:                                                                              \
-            self._flags = 4                                                                \
-        if priority is not None:                                                           \
-            libev.ev_set_priority(&self._watcher, priority)
-
-
-cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]:
-    """Abstract base class for all the watchers"""
-
-    def __repr__(self):
-        if Py_ReprEnter(<PyObjectPtr>self) != 0:
-            return "<...>"
-        try:
-            format = self._format()
-            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
-            if self.active:
-                result += " active"
-            if self.pending:
-                result += " pending"
-            if self.callback is not None:
-                result += " callback=%r" % (self.callback, )
-            if self.args is not None:
-                result += " args=%r" % (self.args, )
-            return result + ">"
-        finally:
-            Py_ReprLeave(<PyObjectPtr>self)
-
-    def _format(self):
-        return ''
-
-
-cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]:
-
-    WATCHER_BASE(io)
-
-    def start(self, object callback, *args, pass_events=False):
-        CHECK_LOOP2(self.loop)
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        if pass_events:
-            self.args = (GEVENT_CORE_EVENTS, ) + args
-        else:
-            self.args = args
-        LIBEV_UNREF
-        libev.ev_io_start(self.loop._ptr, &self._watcher)
-        PYTHON_INCREF
-
-    ACTIVE
-
-    PENDING
-
-#ifdef _WIN32
-
-    def __init__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE):
-            raise ValueError('illegal event mask: %r' % events)
-        cdef int vfd = libev.vfd_open(fd)
-        libev.vfd_free(self._watcher.fd)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, events)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-#else
-
-    def __init__(self, loop loop, int fd, int events, ref=True, priority=None):
-        if fd < 0:
-            raise ValueError('fd must be non-negative: %r' % fd)
-        if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE):
-            raise ValueError('illegal event mask: %r' % events)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, fd, events)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-#endif
-
-    property fd:
-
-        def __get__(self):
-            return libev.vfd_get(self._watcher.fd)
-
-        def __set__(self, long fd):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active")
-            cdef int vfd = libev.vfd_open(fd)
-            libev.vfd_free(self._watcher.fd)
-            libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, self._watcher.events)
-
-    property events:
-
-        def __get__(self):
-            return self._watcher.events
-
-        def __set__(self, int events):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active")
-            libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, self._watcher.fd, events)
-
-    property events_str:
-
-        def __get__(self):
-            return _events_to_str(self._watcher.events)
-
-    def _format(self):
-        return ' fd=%s events=%s' % (self.fd, self.events_str)
-
-#ifdef _WIN32
-
-    def __cinit__(self):
-        self._watcher.fd = -1;
-
-    def __dealloc__(self):
-        libev.vfd_free(self._watcher.fd)
-
-#endif
-
-
-cdef public class timer(watcher) [object PyGeventTimerObject, type PyGeventTimer_Type]:
-
-    WATCHER_BASE(timer)
-
-    def start(self, object callback, *args, update=True):
-        CHECK_LOOP2(self.loop)
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        LIBEV_UNREF
-        if update:
-            libev.ev_now_update(self.loop._ptr)
-        libev.ev_timer_start(self.loop._ptr, &self._watcher)
-        PYTHON_INCREF
-
-    ACTIVE
-
-    PENDING
-
-    def __init__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
-        if repeat < 0.0:
-            raise ValueError("repeat must be positive or zero: %r" % repeat)
-        libev.ev_timer_init(&self._watcher, <void *>gevent_callback_timer, after, repeat)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-    property at:
-
-        def __get__(self):
-            return self._watcher.at
-
-    # QQQ: add 'after' and 'repeat' properties?
-
-    def again(self, object callback, *args, update=True):
-        CHECK_LOOP2(self.loop)
-        self.callback = callback
-        self.args = args
-        LIBEV_UNREF
-        if update:
-            libev.ev_now_update(self.loop._ptr)
-        libev.ev_timer_again(self.loop._ptr, &self._watcher)
-        PYTHON_INCREF
-
-
-cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]:
-
-    WATCHER(signal)
-
-    def __init__(self, loop loop, int signalnum, ref=True, priority=None):
-        if signalnum < 1 or signalnum >= signalmodule.NSIG:
-            raise ValueError('illegal signal number: %r' % signalnum)
-        # still possible to crash on one of libev's asserts:
-        # 1) "libev: ev_signal_start called with illegal signal number"
-        #    EV_NSIG might be different from signal.NSIG on some platforms
-        # 2) "libev: a signal must not be attached to two different loops"
-        #    we probably could check that in LIBEV_EMBED mode, but not in general
-        libev.ev_signal_init(&self._watcher, <void *>gevent_callback_signal, signalnum)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-
-cdef public class idle(watcher) [object PyGeventIdleObject, type PyGeventIdle_Type]:
-
-    WATCHER(idle)
-
-    INIT(idle,,)
-
-
-cdef public class prepare(watcher) [object PyGeventPrepareObject, type PyGeventPrepare_Type]:
-
-    WATCHER(prepare)
-
-    INIT(prepare,,)
-
-
-cdef public class check(watcher) [object PyGeventCheckObject, type PyGeventCheck_Type]:
-
-    WATCHER(check)
-
-    INIT(check,,)
-
-
-cdef public class fork(watcher) [object PyGeventForkObject, type PyGeventFork_Type]:
-
-    WATCHER(fork)
-
-    INIT(fork,,)
-
-
-cdef public class async(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]:
-
-    WATCHER_BASE(async)
-
-    START(async)
-
-    ACTIVE
-
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_async_pending(&self._watcher) else False
-
-    INIT(async,,)
-
-    def send(self):
-        CHECK_LOOP2(self.loop)
-        libev.ev_async_send(self.loop._ptr, &self._watcher)
-
-#ifdef _WIN32
-#else
-
-cdef public class child(watcher) [object PyGeventChildObject, type PyGeventChild_Type]:
-
-    WATCHER(child)
-
-    def __init__(self, loop loop, int pid, bint trace=0, ref=True):
-        if not loop.default:
-            raise TypeError('child watchers are only available on the default loop')
-        libev.gevent_install_sigchld_handler()
-        libev.ev_child_init(&self._watcher, <void *>gevent_callback_child, pid, trace)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-
-    def _format(self):
-        return ' pid=%r rstatus=%r' % (self.pid, self.rstatus)
-
-    property pid:
-
-        def __get__(self):
-            return self._watcher.pid
-
-    property rpid:
-
-        def __get__(self):
-            return self._watcher.rpid
-
-        def __set__(self, int value):
-            self._watcher.rpid = value
-
-    property rstatus:
-
-        def __get__(self):
-            return self._watcher.rstatus
-
-        def __set__(self, int value):
-            self._watcher.rstatus = value
-
-#endif
-
-
-cdef public class stat(watcher) [object PyGeventStatObject, type PyGeventStat_Type]:
-
-    WATCHER(stat)
-    cdef readonly str path
-    cdef readonly bytes _paths
-
-    def __init__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
-        self.path = path
-        cdef bytes paths
-        if isinstance(path, unicode):
-            # the famous Python3 filesystem encoding debacle hits us here. Can we do better?
-            # We must keep a reference to the encoded string so that its bytes don't get freed
-            # and overwritten, leading to strange errors from libev ("no such file or directory")
-            paths = (<unicode>path).encode(sys.getfilesystemencoding())
-            self._paths = paths
-        else:
-            paths = <bytes>path
-            self._paths = paths
-        libev.ev_stat_init(&self._watcher, <void *>gevent_callback_stat, <char*>paths, interval)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-    property attr:
-
-        def __get__(self):
-            if not self._watcher.attr.st_nlink:
-                return
-            return _pystat_fromstructstat(&self._watcher.attr)
-
-    property prev:
-
-       def __get__(self):
-            if not self._watcher.prev.st_nlink:
-                return
-            return _pystat_fromstructstat(&self._watcher.prev)
-
-    property interval:
-
-        def __get__(self):
-            return self._watcher.interval
-
-
-__SYSERR_CALLBACK = None
-
-
-cdef void _syserr_cb(char* msg) with gil:
-    try:
-        __SYSERR_CALLBACK(msg, errno)
-    except:
-        set_syserr_cb(None)
-        print_exc = getattr(traceback, 'print_exc', None)
-        if print_exc is not None:
-            print_exc()
-
-
-cpdef set_syserr_cb(callback):
-    global __SYSERR_CALLBACK
-    if callback is None:
-        libev.ev_set_syserr_cb(NULL)
-        __SYSERR_CALLBACK = None
-    elif callable(callback):
-        libev.ev_set_syserr_cb(<void *>_syserr_cb)
-        __SYSERR_CALLBACK = callback
-    else:
-        raise TypeError('Expected callable or None, got %r' % (callback, ))
-
-
-#ifdef LIBEV_EMBED
-LIBEV_EMBED = True
-EV_USE_FLOOR = libev.EV_USE_FLOOR
-EV_USE_CLOCK_SYSCALL = libev.EV_USE_CLOCK_SYSCALL
-EV_USE_REALTIME = libev.EV_USE_REALTIME
-EV_USE_MONOTONIC = libev.EV_USE_MONOTONIC
-EV_USE_NANOSLEEP = libev.EV_USE_NANOSLEEP
-EV_USE_INOTIFY = libev.EV_USE_INOTIFY
-EV_USE_SIGNALFD = libev.EV_USE_SIGNALFD
-EV_USE_EVENTFD = libev.EV_USE_EVENTFD
-EV_USE_4HEAP = libev.EV_USE_4HEAP
-#else
-LIBEV_EMBED = False
-#endif