manyi/venv/Lib/site-packages/gevent/libev/corecext.ppyx

# 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